cps-ir: Add support for intercepted calls.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 // TODO(karlklose): share the [ParentVisitor].
 import '../../cps_ir/optimizers.dart';
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
+import '../../elements/elements.dart' show ClassElement;
+import '../../js_backend/codegen/glue.dart';
+import '../../dart2jslib.dart' show Selector;
 
 /// Rewrites the initial CPS IR to make Dart semantics explicit and inserts
 /// special nodes that respect JavaScript behavior.
 ///
 /// Performs the following rewrites:
 ///  - rewrite [IsTrue] in a [Branch] to do boolean conversion.
 class UnsugarVisitor extends RecursiveVisitor {
-  const UnsugarVisitor();
+  Glue _glue;
+
+  UnsugarVisitor(this._glue);
 
   void rewrite(FunctionDefinition function) {
     // Set all parent pointers.
     new ParentVisitor().visit(function);
     visit(function);
   }
 
   @override
   visit(Node node) {
     Node result = node.accept(this);
     return result != null ? result : node;
   }
 
   Constant get trueConstant {
     return new Constant(
         new PrimitiveConstantExpression(
             new TrueConstantValue()));
   }
 
+  processInvokeMethod(InvokeMethod node) {
+    Selector selector = node.selector;
+    if (!_glue.isInterceptedSelector(selector)) return;
+
+    if (!selector.isCall && !selector.isOperator) {
+      // TODO(karlklose): handle special selectors.
+      return;
+    }
+
+    Set<ClassElement> interceptedClasses =
+        _glue.getInterceptedClassesOn(selector);
+    _glue.registerSpecializedGetInterceptor(interceptedClasses);
+    InteriorNode parent = node.parent;
+    Primitive receiver = node.receiver.definition;
+    Primitive intercepted = new Interceptor(receiver, interceptedClasses);
+    List<Reference<Primitive>> arguments =
+        new List<Reference<Primitive>>.generate(node.arguments.length + 1,
+        (int index) {
+          return index == 0 ? new Reference<Primitive>(receiver)
+                            : node.arguments[index - 1];
+    });
+    LetPrim newNode = new LetPrim(intercepted,
+        new InvokeMethod.internal(new Reference<Primitive>(intercepted),
+            selector,
+            new Reference<Continuation>(node.continuation.definition),
+            arguments));
+    node.continuation.unlink();
+    node.receiver.unlink();
+    parent.body = newNode;
+  }
+
   processBranch(Branch node) {
     // TODO(karlklose): implement the checked mode part of boolean conversion.
     InteriorNode parent = node.parent;
     IsTrue condition = node.condition;
     Primitive t = trueConstant;
     Primitive i = new Identical(condition.value.definition, t);
     LetPrim newNode = new LetPrim(t,
         new LetPrim(i,
             new Branch(new IsTrue(i),
                 node.trueContinuation.definition,
                 node.falseContinuation.definition)));
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 }