Compute correct return type for factory methods.

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 19 matching lines @@
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_algebra.dart';
 
 import '../errors.dart' show internalError;
 
 /// 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);
+    return constructor.function.returnType;
   }
 }
 
-/// 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 1870 matching lines @@
   }
 
   transformChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 
   visitChildren(v) {
     return internalError("Internal error: Unsupported operation.");
   }
 }