Fix type inference of redirecting factory constructor invocations.

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

 // Copyright (c) 2017, 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 10 matching lines @@
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_algebra.dart';
 
+/// Computes the return type of a (possibly factory) constructor.
+InterfaceType computeConstructorReturnType(Member constructor) {
+  if (constructor is Constructor) {
+    return constructor.enclosingClass.thisType;
+  } else {
+    return computeFactoryConstructorReturnType(constructor);
+  }
+}
+
 /// Computes the return type of a factory constructor.
 ///
 /// Note that we can't just use `constructor.function.functionType.returnType`,
 /// because that's `dynamic` for factory constructors.  TODO(paulberry):
 /// investigate whether this can be changed.
 InterfaceType computeFactoryConstructorReturnType(Procedure constructor) {
   var returnType = constructor.enclosingClass.thisType;
   if (constructor.enclosingClass.typeParameters.isNotEmpty) {
     // target.enclosingClass.typeParameters is not the same as
     // target.function.functionType.typeParameters, so we have to substitute.
@@ skipping 196 matching lines @@
     staticType = type;
     var inferredType = typeNeeded ? type : null;
     inferrer.listener.conditionalExpressionExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [ConstructorInvocation].
 class KernelConstructorInvocation extends ConstructorInvocation
     implements KernelExpression {
-  KernelConstructorInvocation(Constructor target, Arguments arguments,
+  final Member _initialTarget;
+
+  KernelConstructorInvocation(
+      Constructor target, this._initialTarget, Arguments arguments,
       {bool isConst: false})
       : super(target, arguments, isConst: isConst);
 
-  KernelConstructorInvocation.byReference(
-      Reference targetReference, Arguments arguments)
-      : super.byReference(targetReference, arguments);
-
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.constructorInvocationEnter(this, typeContext) ||
             typeNeeded;
     var inferredType = inferrer.inferInvocation(
         typeContext,
         typeNeeded,
         fileOffset,
-        target.function.functionType,
-        target.enclosingClass.thisType,
+        _initialTarget.function.functionType,
+        computeConstructorReturnType(_initialTarget),
         arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Shadow object for [DirectMethodInvocation].
 class KernelDirectMethodInvocation extends DirectMethodInvocation
     implements KernelExpression {
   KernelDirectMethodInvocation(
@@ skipping 83 matching lines @@
     inferrer.listener.expressionStatementEnter(this);
     inferrer.inferExpression(expression, null, false);
     inferrer.listener.expressionStatementExit(this);
   }
 }
 
 /// Shadow object for [StaticInvocation] when the procedure being invoked is a
 /// factory constructor.
 class KernelFactoryConstructorInvocation extends StaticInvocation
     implements KernelExpression {
-  KernelFactoryConstructorInvocation(Procedure target, Arguments arguments,
+  final Member _initialTarget;
+
+  KernelFactoryConstructorInvocation(
+      Procedure target, this._initialTarget, Arguments arguments,
       {bool isConst: false})
       : super(target, arguments, isConst: isConst);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded =
         inferrer.listener.constructorInvocationEnter(this, typeContext) ||
             typeNeeded;
-    InterfaceType returnType = computeFactoryConstructorReturnType(target);
-    var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
-        fileOffset, target.function.functionType, returnType, arguments);
+    var inferredType = inferrer.inferInvocation(
+        typeContext,
+        typeNeeded,
+        fileOffset,
+        _initialTarget.function.functionType,
+        computeConstructorReturnType(_initialTarget),
+        arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a field in kernel form.
 class KernelField extends Field {
   bool _implicitlyTyped = true;
 
   FieldNode _fieldNode;
@@ skipping 1058 matching lines @@
           closureContext.isAsync
               ? inferrer.coreTypes.streamClass
               : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(
         expression, typeContext, closureContext != null);
     closureContext.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }