Set return type of factory constructors properly.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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.kernel_procedure_builder;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
+        Class,
         Constructor,
         ConstructorInvocation,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
         FunctionNode,
         Initializer,
         LocalInitializer,
         Member,
         Name,
         NamedExpression,
         Procedure,
         ProcedureKind,
         RedirectingInitializer,
         Statement,
         StaticInvocation,
         StringLiteral,
         SuperInitializer,
         TypeParameter,
+        TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VoidType,
         setParents;
 
-import 'package:kernel/type_algebra.dart' show containsTypeVariable, substitute;
+import 'package:kernel/type_algebra.dart'
+    show Substitution, containsTypeVariable, substitute;
 
 import '../errors.dart' show internalError;
 
 import '../messages.dart' show warning;
 
 import '../loader.dart' show Loader;
 
 import 'kernel_builder.dart'
     show
         Builder,
@@ skipping 68 matching lines @@
         if (formal.isRequired) {
           result.requiredParameterCount++;
         }
       }
     }
     if (returnType != null) {
       result.returnType = returnType.build(library);
     }
     if (!isConstructor && !isInstanceMember && parent is ClassBuilder) {
       List<TypeParameter> typeParameters = parent.target.typeParameters;
+      if (kind == ProcedureKind.Factory) {

[ahe, 2017/06/01 09:10:08]

This I have a different solution for.

+        Class class_ = parent.target;
+        if (typeParameters.isEmpty) {
+          result.returnType = class_.thisType;
+        } else {
+          // Factory constructors get their own copy of type parameters, so we
+          // have to substitute.
+          result.returnType = Substitution
+              .fromPairs(
+                  class_.typeParameters,
+                  result.typeParameters
+                      .map((p) => new TypeParameterType(p))
+                      .toList())
+              .substituteType(class_.thisType);
+        }
+      }
       if (typeParameters.isNotEmpty) {
         Map<TypeParameter, DartType> substitution;
         DartType removeTypeVariables(DartType type) {
           if (substitution == null) {
             substitution = <TypeParameter, DartType>{};
             for (TypeParameter parameter in typeParameters) {
               substitution[parameter] = const DynamicType();
             }
           }
           warning(fileUri, charOffset,
@@ skipping 227 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }