dart2js cps: Use definitions by default, not references.

pkg/compiler/lib/src/cps_ir/inline.dart

 // Copyright (c) 2015, 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 cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 219 matching lines @@
     if (argument != null &&
         argument.definition.hasExactlyOneUse &&
         parameter.hasNoUses) {
       --size;
     }
   }
 
   static int sizeOf(InvocationPrimitive invoke, FunctionDefinition function) {
     SizeVisitor visitor = new SizeVisitor();
     visitor.visit(function);
-    visitor.countArgument(invoke.receiver, function.thisParameter);
-    for (int i = 0; i < invoke.arguments.length; ++i) {
-      visitor.countArgument(invoke.arguments[i], function.parameters[i]);
+    visitor.countArgument(invoke.receiverRef, function.thisParameter);
+    for (int i = 0; i < invoke.argumentRefs.length; ++i) {
+      visitor.countArgument(invoke.argumentRefs[i], function.parameters[i]);
     }
     return visitor.size;
   }
 
   // Inlining a function incurs a cost equal to the number of primitives and
   // non-jump tail expressions.
   // TODO(kmillikin): Tune the size computation and size bound.
   processLetPrim(LetPrim node) => ++size;
   processLetMutable(LetMutable node) => ++size;
   processBranch(Branch node) => ++size;
@@ skipping 76 matching lines @@
   }
 
   TypeMask abstractType(Reference<Primitive> ref) {
     return ref.definition.type ?? typeSystem.dynamicType;
   }
 
   /// Build the IR term for the function that adapts a call site targeting a
   /// function that takes optional arguments not passed at the call site.
   FunctionDefinition buildAdapter(InvokeMethod node, FunctionElement target) {
     Parameter thisParameter = new Parameter(new ThisParameterLocal(target))
-        ..type = node.receiver.definition.type;
+        ..type = node.receiver.type;
     List<Parameter> parameters = new List<Parameter>.generate(
-        node.arguments.length,
+        node.argumentRefs.length,
         (int index) {
           // TODO(kmillikin): Use a hint for the parameter names.
           return new Parameter(null)
-              ..type = node.arguments[index].definition.type;
+              ..type = node.argument(index).type;
         });
     Continuation returnContinuation = new Continuation.retrn();
     CpsFragment cps = new CpsFragment();
 
     FunctionSignature signature = target.functionSignature;
     int requiredParameterCount = signature.requiredParameterCount;
     if (node.callingConvention == CallingConvention.Intercepted ||
         node.callingConvention == CallingConvention.DummyIntercepted) {
       ++requiredParameterCount;
     }
@@ skipping 81 matching lines @@
     }
 
     if (isBlacklisted(target)) return null;
 
     if (invoke.callingConvention == CallingConvention.OneShotIntercepted) {
       // One-shot interceptor calls with a known target are only inserted on
       // uncommon code paths, so they should not be inlined.
       return null;
     }
 
-    Reference<Primitive> dartReceiver = invoke.dartReceiverReference;
+    Reference<Primitive> dartReceiver = invoke.dartReceiverRef;
     TypeMask abstractReceiver =
         dartReceiver == null ? null : abstractType(dartReceiver);
     // The receiver is non-null in a method body, unless the receiver is known
     // to be `null` (isEmpty covers `null` and unreachable).
     TypeMask abstractReceiverInMethod = abstractReceiver == null
         ? null
         : abstractReceiver.isEmpty
             ? abstractReceiver
             : abstractReceiver.nonNullable();
     List<TypeMask> abstractArguments =
-        invoke.arguments.map(abstractType).toList();
+        invoke.argumentRefs.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
         abstractReceiverInMethod,
         abstractArguments);
 
     // Negative inlining result in the cache.
     if (cachedResult == InliningCache.NO_INLINE) return null;
 
     Primitive finish(FunctionDefinition function) {
       _fragment = new CpsFragment(invoke.sourceInformation);
-      Primitive receiver = invoke.receiver?.definition;
-      List<Primitive> arguments =
-          invoke.arguments.map((Reference ref) => ref.definition).toList();
+      Primitive receiver = invoke.receiver;
+      List<Primitive> arguments = invoke.arguments.toList();
       // Add a null check to the inlined function body if necessary.  The
       // cached function body does not contain the null check.
       if (dartReceiver != null && abstractReceiver.isNullable) {
         Primitive check = nullReceiverGuard(
             invoke, _fragment, dartReceiver.definition, abstractReceiver);
         if (invoke.callingConvention == CallingConvention.Intercepted) {
           arguments[0] = check;
         } else {
           receiver = check;
         }
@@ skipping 30 matching lines @@
         return doNotInline();
       } else {
         function = buildAdapter(invoke, target);
       }
     } else {
       function = compileToCpsIr(target);
       void setValue(Variable variable, Reference<Primitive> value) {
         variable.type = value.definition.type;
       }
       if (invoke.callingConvention == CallingConvention.Intercepted) {
-        setValue(function.thisParameter, invoke.receiver);
+        setValue(function.thisParameter, invoke.receiverRef);
         function.parameters[0].type = abstractReceiverInMethod;
-        for (int i = 1; i < invoke.arguments.length; ++i) {
-          setValue(function.parameters[i], invoke.arguments[i]);
+        for (int i = 1; i < invoke.argumentRefs.length; ++i) {
+          setValue(function.parameters[i], invoke.argumentRefs[i]);
         }
       } else {
-        if (invoke.receiver != null) {
+        if (invoke.receiverRef != null) {
           function.thisParameter.type = abstractReceiverInMethod;
         }
-        for (int i = 0; i < invoke.arguments.length; ++i) {
-          setValue(function.parameters[i], invoke.arguments[i]);
+        for (int i = 0; i < invoke.argumentRefs.length; ++i) {
+          setValue(function.parameters[i], invoke.argumentRefs[i]);
         }
       }
       optimizeBeforeInlining(function);
     }
 
     // Inline calls in the body.
     _inliner.rewrite(function, callStructure);
 
     // Compute the size.
     // TODO(kmillikin): Tune the size bound.
@@ skipping 78 matching lines @@
         (enclosingClass == backend.helpers.jsNumberClass ||
          enclosingClass == backend.helpers.jsDoubleClass ||
          enclosingClass == backend.helpers.jsIntClass)) {
       // These should be handled by operator specialization.
       return true;
     }
     if (target == backend.helpers.stringInterpolationHelper) return true;
     return false;
   }
 }