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;
 
+  static const String genericMethodTypeParametersName = r"$typeParameters";
+
   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;
+  }
+
+  bool isGenericMethod(FunctionNode node) {
+    if (node.parent is Constructor) {

[karlklose, 2017/03/15 15:20:22]

If you stored `node.parent` in a local variable, type promotion would make the
cast (`as`) unnecessary.

Maybe:

if (node.parent is Member) {
  Member member = node.parent;
  if (member is Constructor ||
      member is Procedure && member.kind == ProcedureKind.Factory) {
    return member.enclosingClass.typeParameters <
         node.typeParameters.length;
  }
} else {
  return node.typeParameters.isNotEmtpy;
}

[Dmitry Stefantsov, 2017/03/16 09:30:42]

Yes, I agree with a small remark. The if-else operator should be transformed
into single-branched if-operator, and the return statement from the 'else'
branch should be put on its own line after the single-branched if-operator.
Otherwise, the case of a non-constructor and non-factory member is not covered.

+      return (node.parent as Member).enclosingClass.typeParameters.length <
+          node.typeParameters.length;
+    }
+    if (node.parent is Procedure &&
+        (node.parent as Procedure).kind == ProcedureKind.Factory) {
+      return (node.parent as Member).enclosingClass.typeParameters.length <
+          node.typeParameters.length;
+    }
+    if (node.typeParameters.length > 0) {
+      return true;
+    }
+    return false;
+  }
+
+  void addTypeArgumentToGenericInvocation(InvocationExpression expression) {
+    if (expression.arguments.types.length > 0) {
+      ListLiteral genericMethodTypeParameters = new ListLiteral(
+          expression.arguments.types
+              .map(createRuntimeType)
+              .toList(growable: false),
+          typeArgument: rtiLibrary.typeType);
+      expression.arguments.named.add(new NamedExpression(
+          genericMethodTypeParametersName, genericMethodTypeParameters)
+        ..parent = expression.arguments);
+    }
+  }
+
+  void addTypeArgumentToGenericDeclaration(FunctionNode node) {
+    if (isGenericMethod(node)) {
+      VariableDeclaration genericMethodTypeParameters = new VariableDeclaration(
+          genericMethodTypeParametersName,
+          type: new InterfaceType(
+              builder.coreTypes.listClass, <DartType>[rtiLibrary.typeType]));
+      genericMethodTypeParameters.parent = node;
+      node.namedParameters.insert(0, genericMethodTypeParameters);
+    }
+  }
 }