dart2js cps: Keep interceptors in a separate field.

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 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
@@ skipping 47 matching lines @@
   ///         'currentNode': node,
   ///         'caller': someContinuation
   ///       });
   ///       throw 'Node was not in environment';
   ///     }
   ///
   /// If two strings map to the same node, it will be given both annotations.
   ///
   /// Avoid using nodes as keys if there is a chance that two keys are the
   /// same node.
-  String debugString([Map annotations]) {
+  String debugString([Map annotations = const {}]) {
     return new SExpressionStringifier()
         .withAnnotations(annotations)
+        .withTypes()
         .visit(this);
   }
 
   /// Prints the result of [debugString].
-  void debugPrint([Map annotations]) {
+  void debugPrint([Map annotations = const {}]) {
     print(debugString(annotations));
   }
 }
 
 /// Expressions can be evaluated, and may diverge, throw, and/or have
 /// side-effects.
 ///
 /// Evaluation continues by stepping into a sub-expression, invoking a
 /// continuation, or throwing an exception.
 ///
@@ skipping 323 matching lines @@
 
   void setParentPointers() {}
 }
 
 /// A function definition, consisting of parameters and a body.
 ///
 /// There is an explicit parameter for the `this` argument, and a return
 /// continuation to invoke when returning from the function.
 class FunctionDefinition extends InteriorNode {
   final ExecutableElement element;
-  final Parameter thisParameter;
+  Parameter interceptorParameter;
+  final Parameter receiverParameter;
   final List<Parameter> parameters;
   final Continuation returnContinuation;
   Expression body;
 
-  FunctionDefinition(this.element, this.thisParameter, this.parameters,
-      this.returnContinuation, this.body);
+  FunctionDefinition(this.element, this.receiverParameter, this.parameters,
+      this.returnContinuation, this.body, {this.interceptorParameter});
 
   accept(BlockVisitor visitor) => visitor.visitFunctionDefinition(this);
 
   void setParentPointers() {
-    if (thisParameter != null) thisParameter.parent = this;
+    if (interceptorParameter != null) interceptorParameter.parent = this;
+    if (receiverParameter != null) receiverParameter.parent = this;
     _setParentsOnNodes(parameters, this);
     returnContinuation.parent = this;
     if (body != null) body.parent = this;
   }
 }
 
 // ----------------------------------------------------------------------------
 //                            PRIMITIVES
 // ----------------------------------------------------------------------------
 
@@ skipping 43 matching lines @@
   /// JS receiver is the Dart receiver, there are no extra arguments.
   ///
   /// Compiles to a one-shot interceptor, e.g: `J.bar$1(foo, x)`
   OneShotIntercepted,
 }
 
 /// Base class of function invocations.
 ///
 /// This class defines the common interface of function invocations.
 abstract class InvocationPrimitive extends UnsafePrimitive {
+  Reference<Primitive> get interceptorRef => null;
+  Primitive get interceptor => interceptorRef?.definition;
+
   Reference<Primitive> get receiverRef => null;
   Primitive get receiver => receiverRef?.definition;
 
   List<Reference<Primitive>> get argumentRefs;
   Primitive argument(int n) => argumentRefs[n].definition;
   Iterable<Primitive> get arguments => _dereferenceList(argumentRefs);
 
-  Reference<Primitive> get dartReceiverRef => null;
-  Primitive get dartReceiver => dartReceiverRef?.definition;
-
   CallingConvention get callingConvention => CallingConvention.Normal;
 
-  Reference<Primitive> dartArgumentReference(int n) {
-    switch (callingConvention) {
-      case CallingConvention.Normal:
-      case CallingConvention.OneShotIntercepted:
-        return argumentRefs[n];
-
-      case CallingConvention.Intercepted:
-      case CallingConvention.DummyIntercepted:
-        return argumentRefs[n + 1];
-    }
-  }
-
-  Primitive dartArgument(int n) => dartArgumentReference(n).definition;
-
-  int get dartArgumentsLength =>
-      argumentRefs.length -
-      (callingConvention == CallingConvention.Intercepted ||
-          callingConvention == CallingConvention.DummyIntercepted ? 1 : 0);
-
   SourceInformation get sourceInformation;
 }
 
 /// 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
@@ skipping 23 matching lines @@
 /// Invoke a method on an object.
 ///
 /// This includes getters, setters, operators, and index getter/setters.
 ///
 /// Tearing off a method is treated like a getter invocation (getters and
 /// tear-offs cannot be distinguished at compile-time).
 ///
 /// The [selector] records the names of named arguments. The value of named
 /// arguments occur at the end of the [arguments] list, in normalized order.
 class InvokeMethod extends InvocationPrimitive {
+  Reference<Primitive> interceptorRef;
   Reference<Primitive> receiverRef;
   Selector selector;
   TypeMask mask;
   final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
+  CallingConvention _callingConvention;
 
-  CallingConvention callingConvention = CallingConvention.Normal;
-
-  Reference<Primitive> get dartReceiverRef {
-    return callingConvention == CallingConvention.Intercepted
-        ? argumentRefs[0]
-        : receiverRef;
-  }
+  CallingConvention get callingConvention => _callingConvention;
 
   InvokeMethod(
       Primitive receiver, this.selector, this.mask, List<Primitive> arguments,
       {this.sourceInformation,
-      this.callingConvention: CallingConvention.Normal})
+       CallingConvention callingConvention,
+       Primitive interceptor})
       : this.receiverRef = new Reference<Primitive>(receiver),
-        this.argumentRefs = _referenceList(arguments);
+        this.argumentRefs = _referenceList(arguments),
+        this.interceptorRef = _optionalReference(interceptor),
+        this._callingConvention = callingConvention ??
+            (interceptor != null
+                ? CallingConvention.Intercepted
+                : CallingConvention.Normal);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
+    interceptorRef?.parent = this;
     receiverRef.parent = this;
     _setParentsOnList(argumentRefs, this);
   }
+
+  void makeIntercepted(Primitive interceptor) {
+    interceptorRef?.unlink();
+    interceptorRef = new Reference<Primitive>(interceptor)..parent = this;
+    _callingConvention = CallingConvention.Intercepted;
+  }
+
+  void makeOneShotIntercepted() {
+    interceptorRef?.unlink();
+    interceptorRef = null;
+    _callingConvention = CallingConvention.OneShotIntercepted;
+  }
+
+  void makeDummyIntercepted() {
+    interceptorRef?.unlink();
+    interceptorRef = null;
+    _callingConvention = CallingConvention.DummyIntercepted;
+  }
 }
 
 /// Invoke [target] on [receiver], bypassing dispatch and override semantics.
 ///
 /// That is, if [receiver] is an instance of a class that overrides [target]
 /// with a different implementation, the overriding implementation is bypassed
 /// and [target]'s implementation is invoked.
 ///
 /// As with [InvokeMethod], this can be used to invoke a method, operator,
 /// getter, setter, or index getter/setter.
 ///
 /// If it is known that [target] does not use its receiver argument, then
 /// [receiver] may refer to a null constant primitive. This happens for direct
 /// invocations to intercepted methods, where the effective receiver is instead
 /// passed as a formal parameter.
 ///
 /// TODO(sra): Review. A direct call to a method that is mixed into a native
 /// class will still require an explicit argument.
 ///
 /// 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> interceptorRef;
   Reference<Primitive> receiverRef;
   final FunctionElement target;
   final Selector selector;
   final List<Reference<Primitive>> argumentRefs;
   final SourceInformation sourceInformation;
 
-  CallingConvention callingConvention;
-
-  Reference<Primitive> get dartReceiverRef {
-    return callingConvention == CallingConvention.Intercepted
-        ? argumentRefs[0]
-        : receiverRef;
-  }
-
   InvokeMethodDirectly(Primitive receiver, this.target, this.selector,
       List<Primitive> arguments, this.sourceInformation,
-      {this.callingConvention: CallingConvention.Normal})
+      {Primitive interceptor})
       : this.receiverRef = new Reference<Primitive>(receiver),
-        this.argumentRefs = _referenceList(arguments);
+        this.argumentRefs = _referenceList(arguments),
+        this.interceptorRef = _optionalReference(interceptor);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 
   bool get hasValue => true;
 
   void setParentPointers() {
+    interceptorRef?.parent = this;
     receiverRef.parent = this;
     _setParentsOnList(argumentRefs, this);
   }
 
   bool get isConstructorBodyCall => target is ConstructorBodyElement;
   bool get isTearOff => selector.isGetter && !target.isGetter;
+
+  void makeIntercepted(Primitive interceptor) {
+    interceptorRef?.unlink();
+    interceptorRef = new Reference<Primitive>(interceptor)..parent = this;
+  }
 }
 
 /// Non-const call to a constructor.
 ///
 /// The [target] may be a generative constructor (forwarding or normal)
 /// or a non-redirecting factory.
 ///
 /// All optional arguments declared by [target] are passed in explicitly, and
 /// occur in the [arguments] list, in normalized order.
 ///
@@ skipping 1606 matching lines @@
 class DeepRecursiveVisitor implements Visitor {
   const DeepRecursiveVisitor();
 
   visit(Node node) => node.accept(this);
 
   processReference(Reference ref) {}
 
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
-    if (node.thisParameter != null) visit(node.thisParameter);
+    if (node.interceptorParameter != null) visit(node.interceptorParameter);
+    if (node.receiverParameter != null) visit(node.receiverParameter);
     node.parameters.forEach(visit);
     visit(node.body);
   }
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visit);
     if (node.body != null) visit(node.body);
   }
@@ skipping 37 matching lines @@
   processInvokeContinuation(InvokeContinuation node) {}
   visitInvokeContinuation(InvokeContinuation node) {
     processInvokeContinuation(node);
     processReference(node.continuationRef);
     node.argumentRefs.forEach(processReference);
   }
 
   processInvokeMethod(InvokeMethod node) {}
   visitInvokeMethod(InvokeMethod node) {
     processInvokeMethod(node);
+    if (node.interceptorRef != null) {
+      processReference(node.interceptorRef);
+    }
     processReference(node.receiverRef);
     node.argumentRefs.forEach(processReference);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {}
   visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     processInvokeMethodDirectly(node);
+    if (node.interceptorRef != null) {
+      processReference(node.interceptorRef);
+    }
     processReference(node.receiverRef);
     node.argumentRefs.forEach(processReference);
   }
 
   processInvokeConstructor(InvokeConstructor node) {}
   visitInvokeConstructor(InvokeConstructor node) {
     processInvokeConstructor(node);
     node.argumentRefs.forEach(processReference);
   }
 
@@ skipping 268 matching lines @@
       if (cont.isReturnContinuation) {
         traverseContinuation(cont);
       } else {
         _processBlock(traverseContinuation(cont));
       }
     });
   }
 
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
-    if (node.thisParameter != null) visit(node.thisParameter);
+    if (node.interceptorParameter != null) visit(node.interceptorParameter);
+    if (node.receiverParameter != null) visit(node.receiverParameter);
     node.parameters.forEach(visit);
     visit(node.body);
   }
 
   visitContinuation(Continuation cont) {
     if (cont.isReturnContinuation) {
       traverseContinuation(cont);
     } else {
       int initialHeight = _stack.length;
       Expression body = traverseContinuation(cont);
@@ skipping 128 matching lines @@
 
   Definition visitInvokeStatic(InvokeStatic node) {
     return new InvokeStatic(node.target, node.selector,
         getList(node.argumentRefs), node.sourceInformation);
   }
 
   Definition visitInvokeMethod(InvokeMethod node) {
     return new InvokeMethod(getCopy(node.receiverRef), node.selector, node.mask,
         getList(node.argumentRefs),
         sourceInformation: node.sourceInformation,
-        callingConvention: node.callingConvention);
+        callingConvention: node.callingConvention,
+        interceptor: getCopyOrNull(node.interceptorRef));
   }
 
   Definition visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     return new InvokeMethodDirectly(getCopy(node.receiverRef), node.target,
         node.selector, getList(node.argumentRefs), node.sourceInformation,
-        callingConvention: node.callingConvention);
+        interceptor: getCopyOrNull(node.interceptorRef));
   }
 
   Definition visitInvokeConstructor(InvokeConstructor node) {
     return new InvokeConstructor(
         node.dartType,
         node.target,
         node.selector,
         getList(node.argumentRefs),
         node.sourceInformation)..allocationSiteType = node.allocationSiteType;
   }
@@ skipping 205 matching lines @@
       _first = savedFirst;
       _current = null;
     });
   }
 
   FunctionDefinition copy(FunctionDefinition node) {
     assert(_first == null && _current == null);
     _first = _current = null;
     // Definitions are copied where they are bound, before processing
     // expressions in the scope of their binding.
-    Parameter thisParameter = node.thisParameter == null
+    Parameter thisParameter = node.receiverParameter == null
         ? null
-        : _definitions.copy(node.thisParameter);
+        : _definitions.copy(node.receiverParameter);
+    Parameter interceptorParameter = node.interceptorParameter == null
+        ? null
+        : _definitions.copy(node.interceptorParameter);
     List<Parameter> parameters =
         node.parameters.map(_definitions.copy).toList();
     // Though the return continuation's parameter does not have any uses,
     // we still make a proper copy to ensure that hints, type, etc. are
     // copied.
     Parameter returnParameter =
         _definitions.copy(node.returnContinuation.parameters.first);
     Continuation returnContinuation =
         _copies[node.returnContinuation] = new Continuation([returnParameter]);
 
     visit(node.body);
     FunctionDefinition copy = new FunctionDefinition(
-        node.element, thisParameter, parameters, returnContinuation, _first);
+        node.element, thisParameter, parameters, returnContinuation, _first,
+        interceptorParameter: interceptorParameter);
     _first = _current = null;
     return copy;
   }
 
   Node visit(Node node) => node.accept(this);
 
   Expression traverseLetCont(LetCont node) {
     // Continuations are copied where they are bound, before processing
     // expressions in the scope of their binding.
     List<Continuation> continuations = node.continuations.map((Continuation c) {
@@ skipping 48 matching lines @@
     plug(new Branch.loose(
         _definitions.getCopy(node.conditionRef),
         _copies[node.trueContinuation],
         _copies[node.falseContinuation])..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }