Move code for instantiating Invocation to Target.

pkg/kernel/lib/transformations/mixin_full_resolution.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.mixin_full_resolution;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../clone.dart';
 import '../core_types.dart';
+import '../target/targets.dart' show NoneTarget, Target;
 import '../type_algebra.dart';
 
 Program transformProgram(Program program) {
-  new MixinFullResolution().transform(program);
+  new MixinFullResolution(new NoneTarget(null)).transform(program);
   return program;
 }
 
 /// Replaces all mixin applications with regular classes, cloning all fields
 /// and procedures from the mixed-in class, cloning all constructors from the
 /// base class.
 ///
 /// Super calls (as well as super initializer invocations) are also resolved
 /// to their targets in this pass.
 class MixinFullResolution {
+  final Target vmTarget;

[Johnni Winther, 2017/05/22 12:33:12]

Rename [vmTarget] to [target]? (I assume MixinFullResolution should be reusable)

[ahe, 2017/05/22 13:30:59]

I've changed it to targetInfo. The word target is already in use in this file as
the target of invocation, that is, a member.

+
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
+  MixinFullResolution(this.vmTarget);
+
   void transform(Program program) {
     var transformedClasses = new Set<Class>();
 
     // Desugar all mixin application classes by copying in fields/methods from
     // the mixin and constructors from the base class.
     var processedClasses = new Set<Class>();
     for (var library in program.libraries) {
       if (library.isExternal) continue;
 
       for (var class_ in library.classes) {
         transformClass(processedClasses, transformedClasses, class_);
       }
     }
 
     hierarchy = new ClassHierarchy(program);
     coreTypes = new CoreTypes(program);
 
     // Resolve all super call expressions and super initializers.
     for (var library in program.libraries) {
       if (library.isExternal) continue;
 
       for (var class_ in library.classes) {
         final bool hasTransformedSuperclass =
             transformedClasses.contains(class_.superclass);
 
         for (var procedure in class_.procedures) {
           if (procedure.containsSuperCalls) {
             new SuperCallResolutionTransformer(
-                    hierarchy, coreTypes, class_.superclass)
+                    hierarchy, coreTypes, class_.superclass, vmTarget)
                 .visit(procedure);
           }
         }
         for (var constructor in class_.constructors) {
           if (constructor.containsSuperCalls) {
             new SuperCallResolutionTransformer(
-                    hierarchy, coreTypes, class_.superclass)
+                    hierarchy, coreTypes, class_.superclass, vmTarget)
                 .visit(constructor);
           }
           if (hasTransformedSuperclass && constructor.initializers.length > 0) {
             new SuperInitializerResolutionTransformer(class_.superclass)
                 .transformInitializers(constructor.initializers);
           }
         }
       }
     }
   }
@@ skipping 96 matching lines @@
     return new Constructor(function,
         name: superclassConstructor.name,
         initializers: <Initializer>[superInitializer]);
   }
 }
 
 class SuperCallResolutionTransformer extends Transformer {
   final ClassHierarchy hierarchy;
   final CoreTypes coreTypes;
   final Class lookupClass;
+  final Target vmTarget;
   Constructor _invocationMirrorConstructor; // cached
-  Procedure _listFrom; // cached
 
   SuperCallResolutionTransformer(
-      this.hierarchy, this.coreTypes, this.lookupClass);
+      this.hierarchy, this.coreTypes, this.lookupClass, this.vmTarget);
 
   TreeNode visit(TreeNode node) => node.accept(this);
 
   visitSuperPropertyGet(SuperPropertyGet node) {
     Member target = hierarchy.getDispatchTarget(lookupClass, node.name);
     if (target != null) {
       return new DirectPropertyGet(new ThisExpression(), target)
         ..fileOffset = node.fileOffset;
     } else {
       return _callNoSuchMethod(node.name.name, new Arguments.empty(), node,
@@ skipping 77 matching lines @@
   }
 
   /// Creates an "new _InvocationMirror(...)" invocation.
   ConstructorInvocation _createInvocation(String methodName,
       Arguments callArguments, bool isSuperInvocation, Expression receiver) {
     if (_invocationMirrorConstructor == null) {
       Class clazz = coreTypes.getClass('dart:core', '_InvocationMirror');
       _invocationMirrorConstructor = clazz.constructors[0];
     }
 
-    // The _InvocationMirror constructor takes the following arguments:
-    // * Method name (a string).
-    // * An arguments descriptor - a list consisting of:
-    //   - length of passed type argument vector, 0 if none passed.
-    //   - number of arguments (including receiver).
-    //   - number of positional arguments (including receiver).
-    //   - pairs (2 entries in the list) of
-    //     * named arguments name.
-    //     * index of named argument in arguments list.
-    // * A list of arguments, where the first ones are the positional arguments.
-    // * Whether it's a super invocation or not.
-
-    int typeArgsLen = 0; // TODO(regis): Type arguments of generic function.
-    int numPositionalArguments = callArguments.positional.length + 1;
-    int numArguments = numPositionalArguments + callArguments.named.length;
-    List<Expression> argumentsDescriptor = [
-      new IntLiteral(typeArgsLen),
-      new IntLiteral(numArguments),
-      new IntLiteral(numPositionalArguments)
-    ];
-    List<Expression> arguments = [];
-    arguments.add(receiver);
-    for (Expression pos in callArguments.positional) {
-      arguments.add(pos);
-    }
-    for (NamedExpression named in callArguments.named) {
-      argumentsDescriptor.add(new StringLiteral(named.name));
-      argumentsDescriptor.add(new IntLiteral(arguments.length));
-      arguments.add(named.value);
-    }
-
-    return new ConstructorInvocation(
-        _invocationMirrorConstructor,
-        new Arguments([
-          new StringLiteral(methodName),
-          _fixedLengthList(argumentsDescriptor),
-          _fixedLengthList(arguments),
-          new BoolLiteral(isSuperInvocation)
-        ]));
-  }
-
-  /// Create a fixed length list containing given expressions.
-  Expression _fixedLengthList(List<Expression> list) {
-    _listFrom ??= coreTypes.getMember('dart:core', 'List', 'from');
-    return new StaticInvocation(
-        _listFrom,
-        new Arguments([new ListLiteral(list)],
-            named: [new NamedExpression("growable", new BoolLiteral(false))],
-            types: [const DynamicType()]));
+    return vmTarget.instantiateInvocation(_invocationMirrorConstructor,
+        receiver, methodName, callArguments, -1, isSuperInvocation);
   }
 
   /// Check that a call to the targetFunction is legal given the arguments.
   ///
   /// I.e. check that the number of positional parameters and the names of the
   /// given named parameters represents a valid call to the function.
   bool _callIsLegal(FunctionNode targetFunction, Arguments arguments) {
     if ((targetFunction.requiredParameterCount > arguments.positional.length) ||
         (targetFunction.positionalParameters.length <
             arguments.positional.length)) {
@@ skipping 34 matching lines @@
           return null;
         }
       }
 
       throw new Exception(
           'Could not find a generative constructor named "${constructor.name}" '
           'in lookup class "${lookupClass.name}"!');
     }
   }
 }