Correctly infer the return context while compiling a factory constructor.

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 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.
+    returnType = Substitution
+        .fromPairs(
+            constructor.enclosingClass.typeParameters,
+            constructor.function.functionType.typeParameters
+                .map((p) => new TypeParameterType(p))
+                .toList())
+        .substituteType(returnType);
+  }
+  return returnType;
+}
+
 List<DartType> getExplicitTypeArguments(Arguments arguments) {
   if (arguments is KernelArguments) {
     return arguments._hasExplicitTypeArguments ? arguments.types : null;
   } else {
     // This code path should only be taken in situations where there are no
     // type arguments at all, e.g. calling a user-definable operator.
     assert(arguments.types.isEmpty);
     return null;
   }
 }
@@ skipping 308 matching lines @@
   KernelFactoryConstructorInvocation(Procedure target, 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;
-    var returnType = target.enclosingClass.thisType;
-    if (target.enclosingClass.typeParameters.isNotEmpty) {
-      // target.enclosingClass.typeParameters is not the same as
-      // target.function.functionType.typeParameters, so we have to substitute.
-      // TODO(paulberrry): it would be easier if we could just use
-      // target.function.functionType.returnType, but that's `dynamic` for
-      // factory constructors.  Investigate whether this can be changed.
-      returnType = Substitution
-          .fromPairs(
-              target.enclosingClass.typeParameters,
-              target.function.functionType.typeParameters
-                  .map((p) => new TypeParameterType(p))
-                  .toList())
-          .substituteType(returnType);
-    }
+    InterfaceType returnType = computeFactoryConstructorReturnType(target);
     var inferredType = inferrer.inferInvocation(typeContext, typeNeeded,
         fileOffset, target.function.functionType, returnType, arguments);
     inferrer.listener.constructorInvocationExit(this, inferredType);
     return inferredType;
   }
 }
 
 /// Concrete shadow object representing a field in kernel form.
 class KernelField extends Field {
   bool _implicitlyTyped = true;
@@ skipping 1018 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);
   }
 }