cps-ir: Add support for intercepted calls.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import 'tree_ir_nodes.dart';
+import '../js_backend/js_backend.dart';
 
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
  * non-exit continuation `Cont(v, body)` is translated into a direct-style call
  * whose value is bound in the continuation body:
  *
  * `LetVal(v, Invoke(fun, args), body)`
  *
@@ skipping 133 matching lines @@
       phiTempVar = new Variable(node.element, null);
       body = visit(node.body);
     }
 
     return new FunctionDefinition(node.element, parameters,
         body, node.localConstants, node.defaultParameterValues);
   }
 
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
     return new List<Expression>.generate(args.length,
-         (int index) => getVariableReference(args[index]));
+         (int index) => getVariableReference(args[index]),
+         growable: false);
   }
 
   List<Variable> translatePhiArguments(List<cps_ir.Reference> args) {
     return new List<Variable>.generate(args.length,
          (int index) => getVariableReference(args[index]));
   }
 
   Statement buildContinuationAssignment(
       cps_ir.Parameter parameter,
       Expression argument,
@@ skipping 135 matching lines @@
   Statement visitInvokeStatic(cps_ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeMethod(cps_ir.InvokeMethod node) {
     Expression receiver = getVariableReference(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
+    if (node.isIntercepted) {
+      // When this call is intercepted, the receiver is not actually an object,
+      // but a prototype that implements the intercepted data types operations.
+      // The value must be given as the first argument to the interceptor.
+      cps_ir.Interceptor interceptor = node.receiver.definition;
+      Expression target = getVariableReference(interceptor.input);
+      arguments = new List<Expression>.generate(arguments.length + 1,
+          (int index) => index == 0 ? target : arguments [index - 1],
+          growable: false);
+    }
     Expression invoke = new InvokeMethod(receiver, node.selector, arguments);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeSuperMethod(cps_ir.InvokeSuperMethod node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeSuperMethod(node.selector, arguments);
     return continueWithExpression(node.continuation, invoke);
   }
 
@@ skipping 142 matching lines @@
       // The successor will be filled in by visitLetPrim.
       return new FunctionDeclaration(getVariable(node), def, null);
     } else {
       return new FunctionExpression(def);
     }
   }
 
   Expression visitParameter(cps_ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
-    compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
+    compiler.internalError(compiler.currentElement,
+        'Unexpected IR node: $node');
     return null;
   }
 
   Expression visitContinuation(cps_ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
     // visited.
-    compiler.internalError(compiler.currentElement, 'Unexpected IR node.');
+    compiler.internalError(compiler.currentElement,
+        'Unexpected IR node: $node.');
     return null;
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
     return getVariableReference(node.value);
   }
 
   dart2js.Selector get identicalSelector {
     return new dart2js.Selector.call('identical', null, 2);
   }
 
   Expression visitIdentical(cps_ir.Identical node) {
     return new InvokeStatic(
         compiler.identicalFunction,
         identicalSelector,
         <Expression>[getVariableReference(node.left),
                      getVariableReference(node.right)]);
   }
+
+  Expression visitInterceptor(cps_ir.Interceptor node) {
+    JavaScriptBackend backend = compiler.backend;
+    Element getInterceptor = backend.getInterceptorMethod;

[sigurdm, 2014/12/16 11:44:56]

I think we should go via Glue here.

[karlklose, 2014/12/16 12:04:03]

Done.

+    backend.registerUseInterceptor(compiler.enqueuer.codegen);
+    return new InvokeStatic(
+        getInterceptor,
+        new dart2js.Selector.fromElement(getInterceptor),
+        <Expression>[getVariableReference(node.input)]);
+  }
 }