dart2js cps: Copy calling convention for InvokeMethodDirectly.

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

 // Copyright (c) 2013, 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 dart2js.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 616 matching lines @@
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur at the end of [arguments] list, in normalized order.
 class InvokeMethodDirectly extends InvocationPrimitive {
   Reference<Primitive> receiver;
   final FunctionElement target;
   final Selector selector;
   final List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
-  CallingConvention callingConvention = CallingConvention.Normal;
+  CallingConvention callingConvention;
 
   Reference<Primitive> get dartReceiverReference {
     return callingConvention == CallingConvention.Intercepted
         ? arguments[0]
         : receiver;
   }
 
   Primitive get dartReceiver => dartReceiverReference.definition;
 
   Reference<Primitive> dartArgumentReference(int n) {
     return callingConvention == CallingConvention.Normal
         ? arguments[n]
         : arguments[n + 1];
   }
 
   Primitive dartArgument(int n) => dartArgumentReference(n).definition;
 
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
                        List<Primitive> arguments,
-                       this.sourceInformation)
+                       this.sourceInformation,
+                       {this.callingConvention: CallingConvention.Normal})
       : this.receiver = new Reference<Primitive>(receiver),
         this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, this);
@@ skipping 1860 matching lines @@
     return new InvokeMethod(getCopy(node.receiver), node.selector, node.mask,
         getList(node.arguments),
         sourceInformation: node.sourceInformation,
         callingConvention: node.callingConvention);
   }
 
   Definition visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     return new InvokeMethodDirectly(getCopy(node.receiver), node.target,
         node.selector,
         getList(node.arguments),
-        node.sourceInformation);
+        node.sourceInformation,
+        callingConvention: node.callingConvention);
   }
 
   Definition visitInvokeConstructor(InvokeConstructor node) {
     return new InvokeConstructor(node.dartType, node.target, node.selector,
         getList(node.arguments),
         node.sourceInformation);
   }
 
   Definition visitTypeCast(TypeCast node) {
     return new TypeCast(getCopy(node.value), node.dartType,
@@ skipping 284 matching lines @@
     plug(new Branch.loose(_definitions.getCopy(node.condition),
         _copies[node.trueContinuation.definition],
         _copies[node.falseContinuation.definition])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }