anchor.diff:    }
   
     // Computes the function type of a given redirection target. Returns [null] if
  -  // the type of actual target could not be computed.
  +  // the type of the target could not be computed.
     FunctionType computeRedirecteeType(KernelRedirectingFactoryBuilder factory,
         TypeEnvironment typeEnvironment) {
       ConstructorReferenceBuilder redirectionTarget = factory.redirectionTarget;
       FunctionNode target;
  -    bool isConstructor = false;
  -    Class targetClass; // Used when the redirection target is a constructor.
  +    if (redirectionTarget.target == null) return null;
       if (redirectionTarget.target is KernelFunctionBuilder) {
         KernelFunctionBuilder targetBuilder = redirectionTarget.target;
         target = targetBuilder.function;
  -      isConstructor = targetBuilder.isConstructor;
  -      if (isConstructor) {
  -        targetClass = targetBuilder.parent.target;
  -      }
       } else if (redirectionTarget.target is DillMemberBuilder &&
           (redirectionTarget.target.isConstructor ||
               redirectionTarget.target.isFactory)) {
  
positive.code:       return null;
      }
  
      FunctionType redirecteeType;
      // If the target is a constructor then we need to patch the return type of
      // [targetFunctionType], because constructors always have return type to be
      // "void", whereas the return type of a factory is its enclosing
      // class. TODO(hillerstrom): It may be worthwhile to change the typing of
      // constructors such that the return type is its enclosing class.
      if (isConstructor) {
        DartType returnType =
            new InterfaceType(targetClass, typeArguments ?? const <DartType>[]);
  
        redirecteeType = new FunctionType(
            targetFunctionType.positionalParameters, returnType,
            namedParameters: targetFunctionType.namedParameters,
            typeParameters: targetFunctionType.typeParameters,
            requiredParameterCount: targetFunctionType.requiredParameterCount);
      } else {
        redirecteeType = targetFunctionType;
      }
  
      // Substitute if necessary.
      redirecteeType = substitution == null
          ? redirecteeType
          : (substitution.substituteType(redirecteeType.withoutTypeParameters)
              as FunctionType);
  
      return hasProblem ? null : redirecteeType;
    }
  
    String computeRedirecteeName(ConstructorReferenceBuilder redirectionTarget) {
  
negative.code:       //   class B implements A {}
        //
        target = targetBuilder.member.function;
      } else {
        unhandled("${redirectionTarget.target}", "computeRedirecteeType",
            charOffset, fileUri);
      }
  
      List<DartType> typeArguments =
  