Fix type inference of redirecting factory constructor invocations.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 1880 matching lines @@
     } else {
       name = "";
     }
     push(type);
     push(typeArguments ?? NullValue.TypeArguments);
     push(name);
   }
 
   @override
   Expression buildStaticInvocation(Member target, Arguments arguments,
-      {bool isConst: false, int charOffset: -1}) {
+      {bool isConst: false, int charOffset: -1, Member initialTarget}) {
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
-      return new KernelConstructorInvocation(target, arguments,
+      return new KernelConstructorInvocation(target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else if (target is Procedure && target.kind == ProcedureKind.Factory) {
-      return new KernelFactoryConstructorInvocation(target, arguments,
+      return new KernelFactoryConstructorInvocation(
+          target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else {
       return new KernelStaticInvocation(target, arguments, isConst: isConst)
         ..fileOffset = charOffset;
     }
   }
 
   @override
   bool checkArguments(FunctionNode function, Arguments arguments,
@@ skipping 77 matching lines @@
 
       if (typeArguments != null) {
         assert(arguments.types.isEmpty);
         KernelArguments.setExplicitArgumentTypes(arguments, typeArguments);
       }
 
       String errorName;
       if (type is ClassBuilder) {
         Builder b = type.findConstructorOrFactory(name, token.charOffset, uri);
         Member target;
+        Member initialTarget;
         if (b == null) {
           // Not found. Reported below.
         } else if (b.isConstructor) {
+          initialTarget = b.target;
           if (type.isAbstract) {
             push(evaluateArgumentsBefore(
                 arguments,
                 buildAbstractClassInstantiationError(
                     type.name, nameToken.charOffset)));
             return;
           } else {
-            target = b.target;
+            target = initialTarget;
           }
         } else if (b.isFactory) {
-          target = getRedirectionTarget(b.target);
+          initialTarget = b.target;
+          target = getRedirectionTarget(initialTarget);
           if (target == null) {
             push(buildCompileTimeError(
                 "Cyclic definition of factory '${name}'.",
                 nameToken.charOffset));
             return;
           }
         }
         if (target is Constructor ||
             (target is Procedure && target.kind == ProcedureKind.Factory)) {
           push(buildStaticInvocation(target, arguments,
               isConst: optional("const", token),
-              charOffset: nameToken.charOffset));
+              charOffset: nameToken.charOffset,
+              initialTarget: initialTarget));
           return;
         } else {
           errorName = debugName(type.name, name);
         }
       } else {
         errorName = debugName(getNodeName(type), name);
       }
       errorName ??= name;
       push(throwNoSuchMethodError(errorName, arguments, nameToken.charOffset));
     }();
@@ skipping 1143 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }