Implement type arguments in redirecting factories.

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 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
+import 'package:kernel/type_algebra.dart' show Substitution;
+
 import '../fasta_codes.dart' as fasta;
 
 import '../fasta_codes.dart' show LocatedMessage, Message;
 
 import '../messages.dart' as messages show getLocationFromUri;
 
 import '../modifier.dart' show Modifier, constMask, finalMask;
 
 import '../parser/native_support.dart' show skipNativeClause;
 
@@ skipping 29 matching lines @@
 
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 
 import '../type_inference/type_inferrer.dart' show TypeInferrer;
 
 import '../type_inference/type_promotion.dart' show TypePromoter;
 
 import 'frontend_accessors.dart' show buildIsNull, makeBinary;
 
-import 'redirecting_factory_body.dart'
-    show
-        RedirectingFactoryBody,
-        getRedirectingFactoryBody,
-        getRedirectionTarget;
+import 'redirecting_factory_body.dart' show RedirectingFactoryBody;
 
 import 'utils.dart' show offsetForToken;
 
 import '../names.dart';
 
 import 'fasta_accessors.dart';
 
 import 'kernel_builder.dart';
 
 import 'kernel_shadow_ast.dart';
@@ skipping 2238 matching lines @@
             push(new KernelSyntheticExpression(evaluateArgumentsBefore(
                 arguments,
                 buildAbstractClassInstantiationError(
                     type.name, nameToken.charOffset))));
             return;
           } else {
             target = initialTarget;
           }
         } else if (b.isFactory) {
           initialTarget = b.target;
-          target = getRedirectionTarget(initialTarget);
-          if (target == null) {
-            push(deprecated_buildCompileTimeError(
-                "Cyclic definition of factory '${name}'.",
-                nameToken.charOffset));
-            return;
-          }
-          RedirectingFactoryBody body = getRedirectingFactoryBody(target);
+          RedirectingFactoryBody body =
+              RedirectingFactoryBody.getRedirectingFactoryBody(initialTarget);
           if (body != null) {
-            // If the redirection target is itself a redirecting factory, it
-            // means that it is unresolved. So we set target to null so we
-            // can generate a no-such-method error below.
-            assert(body.isUnresolved);
-            target = null;
-            errorName = body.unresolvedName;
+            target = body.target;
+            if (target == null) {
+              push(deprecated_buildCompileTimeError(
+                  "Cyclic definition of factory"
+                  " '${debugName(type.name, name)}'.",
+                  nameToken.charOffset));
+              return;
+            }
+            DartType targetType = body.returnType;
+            if (arguments.types.isNotEmpty) {
+              if (initialTarget.function.typeParameters.length !=
+                  arguments.types.length) {
+                // TODO(ahe): Report a problem here, try to unify with
+                // [buildStaticInvocation].
+                arguments.types.clear();
+              } else {
+                Substitution substitution = Substitution.fromPairs(
+                    initialTarget.function.typeParameters, arguments.types);
+                targetType = substitution.substituteType(targetType);
+                if (targetType is InterfaceType) {
+                  arguments = new KernelArguments(arguments.positional,
+                      types: targetType.typeArguments, named: arguments.named)
+                    ..fileOffset = arguments.fileOffset;
+                } else {
+                  arguments.types.clear();
+                }
+              }
+            }
+            body = RedirectingFactoryBody.getRedirectingFactoryBody(target);
+            if (body != null) {
+              // If the redirection target is itself a redirecting factory, it
+              // means that it is unresolved. So we set target to null so we
+              // can generate a no-such-method error below.
+              assert(body.isUnresolved);
+              target = null;
+              errorName = body.unresolvedName;
+            }
+          } else {
+            target = initialTarget;
           }
         }
         if (target is Constructor ||
             (target is Procedure && target.kind == ProcedureKind.Factory)) {
           push(buildStaticInvocation(target, arguments,
               isConst: optional("const", token) || optional("@", token),
               charOffset: nameToken.charOffset,
               initialTarget: initialTarget));
           return;
         } else {
@@ skipping 1472 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }