anchor.diff:        //   class B implements A {}
         //
         target = targetBuilder.member.function;
  -      isConstructor = targetBuilder.isConstructor;
  -      if (isConstructor) {
  -        targetClass = targetBuilder.member.enclosingClass;
  -      }
       } else {
  -      return null;
  +      unhandled("${redirectionTarget.target}", "computeRedirecteeType",
  +          charOffset, fileUri);
       }
   
       List<DartType> typeArguments =
  
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:   }
  
    // Computes the function type of a given redirection target. Returns [null] if
    // the type of the target could not be computed.
    FunctionType computeRedirecteeType(KernelRedirectingFactoryBuilder factory,
        TypeEnvironment typeEnvironment) {
      ConstructorReferenceBuilder redirectionTarget = factory.redirectionTarget;
      FunctionNode target;
      if (redirectionTarget.target == null) return null;
      if (redirectionTarget.target is KernelFunctionBuilder) {
        KernelFunctionBuilder targetBuilder = redirectionTarget.target;
        target = targetBuilder.function;
      } else if (redirectionTarget.target is DillMemberBuilder &&
          (redirectionTarget.target.isConstructor ||
              redirectionTarget.target.isFactory)) {
  