cps_ir: add refinement on "success" arguments for a set of whitelisted methods

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 491 matching lines @@
 
 /// Base class of function invocations.
 ///
 /// This class defines the common interface of function invocations.
 abstract class InvocationPrimitive extends UnsafePrimitive {
   Reference<Primitive> get receiver => null;
   List<Reference<Primitive>> get arguments;
   SourceInformation get sourceInformation;
 
   Reference<Primitive> get dartReceiverReference => null;
+  Primitive get dartReceiver => dartReceiverReference.definition;
+
   CallingConvention get callingConvention => CallingConvention.Normal;
+
+  Reference<Primitive> dartArgumentReference(int n) {
+    switch (callingConvention) {
+      case CallingConvention.Normal:
+      case CallingConvention.OneShotIntercepted:
+        return arguments[n];
+
+      case CallingConvention.Intercepted:
+      case CallingConvention.DummyIntercepted:
+        return arguments[n + 1];
+    }
+  }
+
+  Primitive dartArgument(int n) => dartArgumentReference(n).definition;
+
+  int get dartArgumentsLength =>

[Siggi Cherem (dart-lang), 2016/01/11 18:45:37]

FYI - I also added dartArgumentsLength to expose the actual number of arguments
as well.

+      arguments.length -
+      (callingConvention == CallingConvention.Intercepted ||
+          callingConvention == CallingConvention.DummyIntercepted ? 1 : 0);
 }
 
 /// Invoke a static function.
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur at the end of [arguments] list, in normalized order.
 ///
 /// Discussion:
 /// All information in the [selector] is technically redundant; it will likely
 /// be removed.
@@ skipping 40 matching lines @@
   final SourceInformation sourceInformation;
 
   CallingConvention callingConvention = CallingConvention.Normal;
 
   Reference<Primitive> get dartReceiverReference {
     return callingConvention == CallingConvention.Intercepted
         ? arguments[0]
         : receiver;
   }
 
-  Primitive get dartReceiver => dartReceiverReference.definition;
-
-  Reference<Primitive> dartArgumentReference(int n) {
-    switch (callingConvention) {
-      case CallingConvention.Normal:
-      case CallingConvention.OneShotIntercepted:
-        return arguments[n];
-
-      case CallingConvention.Intercepted:
-      case CallingConvention.DummyIntercepted:
-        return arguments[n + 1];
-    }
-  }
-
-  Primitive dartArgument(int n) => dartArgumentReference(n).definition;
-
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
   InvokeMethod(Primitive receiver,
                this.selector,
                this.mask,
                List<Primitive> arguments,
                {this.sourceInformation,
                 this.callingConvention: CallingConvention.Normal})
       : this.receiver = new Reference<Primitive>(receiver),
@@ skipping 36 matching lines @@
   final SourceInformation sourceInformation;
 
   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.callingConvention: CallingConvention.Normal})
       : this.receiver = new Reference<Primitive>(receiver),
         this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
@@ skipping 2129 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());
   }
 }