cps-ir: Add support for intercepted calls.

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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 175 matching lines @@
 
 /// Invoke a method, operator, getter, setter, or index getter/setter.
 /// Converting a method to a function object is treated as a getter invocation.
 class InvokeMethod extends Expression implements Invoke {
   final Reference<Primitive> receiver;
   final Selector selector;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
 
   InvokeMethod(Primitive receiver,
-               this.selector,
+               Selector selector,
                Continuation cont,
                List<Primitive> args)
-      : receiver = new Reference<Primitive>(receiver),
-        continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
+      : this.internal(new Reference<Primitive>(receiver),
+                      selector,
+                      new Reference<Continuation>(cont),
+                      _referenceList(args));
+
+  InvokeMethod.internal(this.receiver,
+                        this.selector,
+                        this.continuation,
+                        this.arguments) {
     assert(selector != null);
     assert(selector.kind == SelectorKind.CALL ||
            selector.kind == SelectorKind.OPERATOR ||
            (selector.kind == SelectorKind.GETTER && arguments.isEmpty) ||
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
+  bool get isIntercepted => receiver.definition is Interceptor;
+
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 /// Invoke a method, operator, getter, setter, or index getter/setter from the
 /// super class in tail position.
 class InvokeSuperMethod extends Expression implements Invoke {
   final Selector selector;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
 
@@ skipping 227 matching lines @@
 
 class Identical extends Primitive {
   final Reference<Primitive> left;
   final Reference<Primitive> right;
   Identical(Primitive left, Primitive right)
       : left = new Reference<Primitive>(left),
         right = new Reference<Primitive>(right);
   accept(Visitor visitor) => visitor.visitIdentical(this);
 }
 
+class Interceptor extends Primitive {
+  final Reference<Primitive> input;
+  final Set<ClassElement> interceptedClasses;
+  Interceptor(Primitive input, this.interceptedClasses)
+      : this.input = new Reference<Primitive>(input);
+  accept(Visitor visitor) => visitor.visitInterceptor(this);
+}
+
 class Constant extends Primitive {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   values.ConstantValue get value => expression.value;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
@@ skipping 215 matching lines @@
   T visitGetClosureVariable(GetClosureVariable node) => visitPrimitive(node);
   T visitParameter(Parameter node) => visitPrimitive(node);
   T visitContinuation(Continuation node) => visitDefinition(node);
   T visitClosureVariable(ClosureVariable node) => visitDefinition(node);
 
   // Conditions.
   T visitIsTrue(IsTrue node) => visitCondition(node);
 
   // JavaScript specific nodes.
   T visitIdentical(Identical node) => visitPrimitive(node);
+  T visitInterceptor(Interceptor node) => visitPrimitive(node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 abstract class RecursiveVisitor extends Visitor {
   const RecursiveVisitor();
 
   // Ensures that RecursiveVisitor contains overrides for all relevant nodes.
   // As a rule of thumb, nodes with structure to traverse should be overridden
   // with the appropriate visits in this class (for example, visitLetCont),
@@ skipping 169 matching lines @@
     processReference(node.value);
   }
 
   // JavaScript specific nodes.
   processIdentical(Identical node) {}
   visitIdentical(Identical node) {
     processIdentical(node);
     processReference(node.left);
     processReference(node.right);
   }
+
+  processInterceptor(Interceptor node) {}
+  visitInterceptor(Interceptor node) {
+    processInterceptor(node);
+    processReference(node.input);
+  }
 }
 
 /// Keeps track of currently unused register indices.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
 
   /// Returns an index that is currently unused.
   int makeIndex() {
     if (freeStack.isEmpty) {
@@ skipping 164 matching lines @@
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
   // JavaScript specific nodes.
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
+
+  void visitInterceptor(Interceptor node) {
+    visitReference(node.input);
+  }
 }
-