Pass type arguments as a list in generic methods invocations

pkg/kernel/lib/transformations/reify/transformation/transformer.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 kernel.transformations.reify.transformation.transformer;
 
 import '../analysis/program_analysis.dart';
 import 'package:kernel/ast.dart';
 import 'binding.dart' show RuntimeLibrary;
 import 'builder.dart' show RuntimeTypeSupportBuilder;
@@ skipping 85 matching lines @@
   ReifyVisitor(this.rtiLibrary, this.builder, this.knowledge,
       [this.libraryToTransform]);
 
   /// If not null, the transformation will only be applied to classes declared
   /// in this library.
   final Library libraryToTransform;
 
   // TODO(karlklose): find a way to get rid of this state in the visitor.
   TransformationContext context;
 
+  String get genericMethodTypeParametersName => "\$typeParameters";

[karlklose, 2017/02/24 12:07:23]

This could also be a constant.

[Dmitry Stefantsov, 2017/02/28 11:32:15]

Done.

+
   bool libraryShouldBeTransformed(Library library) {
     return libraryToTransform == null || libraryToTransform == library;
   }
 
   bool needsTypeInformation(Class cls) {
     return !isObject(cls) &&
         !rtiLibrary.contains(cls) &&
         libraryShouldBeTransformed(cls.enclosingLibrary);
   }
 
@@ skipping 57 matching lines @@
 
     Procedure target = invocation.target;
     if (target == rtiLibrary.reifyFunction) {
       /// Rewrite calls to reify(TypeLiteral) to a reified type.
       TypeLiteral literal = invocation.arguments.positional.single;
       return createRuntimeType(literal.type);
     } else if (target.kind == ProcedureKind.Factory) {
       // Intercept calls to factories of classes we do not transform
       return interceptInstantiation(invocation, target);
     }
+
+    addTypeArgumentToGenericInvocation(invocation);
+
     return invocation;
   }
 
   Library visitLibrary(Library library) {
     trace(library);
 
     if (libraryShouldBeTransformed(library)) {
       library.transformChildren(this);
     }
     return library;
@@ skipping 219 matching lines @@
 
     RuntimeTypeStorage access = context.runtimeTypeStorage;
     assert(access != RuntimeTypeStorage.none);
     return access == RuntimeTypeStorage.field ||
         access == RuntimeTypeStorage.inheritedField;
   }
 
   FunctionNode visitFunctionNode(FunctionNode node) {
     trace(node);
 
+    addTypeArgumentToGenericDeclaration(node);
+
     // If we have a [TransformationContext] with a runtime type field and we
     // translate a constructor or factory, we need a parameter that the code of
     // initializers or the factory body can use to access type arguments.
     // The parameter field in the context will be reset in the visit-method of
     // the parent.
     if (context != null && needsParameterForRuntimeType(node.parent)) {
       assert(context.parameter == null);
       // Create the parameter and insert it as the function's first parameter.
       context.parameter = new VariableDeclaration(
           rtiLibrary.runtimeTypeName.name,
@@ skipping 133 matching lines @@
   }
 
   Expression visitMapLiteral(MapLiteral node) {
     trace(node);
     node.transformChildren(this);
     return builder.callAttachType(
         node,
         new InterfaceType(builder.coreTypes.mapClass,
             <DartType>[node.keyType, node.valueType]));
   }
+
+  Expression visitMethodInvocation(MethodInvocation node) {
+    node.transformChildren(this);
+    addTypeArgumentToGenericInvocation(node);
+    return node;
+  }
+
+  void addTypeArgumentToGenericInvocation(InvocationExpression expression) {
+    if (expression.arguments.types.length > 0) {
+      ListLiteral genericMethodTypeParameters = new ListLiteral(new List.from(

[karlklose, 2017/02/24 12:07:23]

You could also call '.toList(growable: false)' on the result of map instead of
using the 'List.from' constructor.

[Dmitry Stefantsov, 2017/02/28 11:32:15]

Done.

+          expression.arguments.types
+              .map((DartType type) => createRuntimeType(type))),

[karlklose, 2017/02/24 12:07:23]

How about
  .map(createRuntimeType)
?

[Dmitry Stefantsov, 2017/02/28 11:32:15]

Sure! :)

+          typeArgument: rtiLibrary.typeType);
+      expression.arguments.named.add(new NamedExpression(
+          genericMethodTypeParametersName, genericMethodTypeParameters)..parent = expression.arguments);

[karlklose, 2017/02/24 12:07:23]

Long line, break before '..'. You could also run dartmt (either from command
line or inside the IDE) to avoid having these problems.

[Dmitry Stefantsov, 2017/02/28 11:32:15]

Done.

+    }
+  }
+
+  void addTypeArgumentToGenericDeclaration(FunctionNode node) {
+    VariableDeclaration genericMethodTypeParameters = new VariableDeclaration(
+        genericMethodTypeParametersName,
+        type: new InterfaceType(

[karlklose, 2017/02/24 12:07:23]

Not sure we need this type, but feel free to keep it.

[Dmitry Stefantsov, 2017/02/28 11:32:15]

OK

+            builder.coreTypes.listClass, <DartType>[rtiLibrary.typeType]));
+    genericMethodTypeParameters.parent = node;
+    node.namedParameters.insert(0, genericMethodTypeParameters);
+  }
 }