dart2js cps: Generate interceptors at use-site and share afterwards.

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

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show ParentVisitor;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../io/source_information.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/universe.dart' show Selector;
@@ skipping 25 matching lines @@
 ///  - Add explicit receiver argument for methods that are called in interceptor
 ///    calling convention.
 ///  - Convert two-parameter exception handlers to one-parameter ones.
 class UnsugarVisitor extends RecursiveVisitor {
   Glue _glue;
   ParentVisitor _parentVisitor = new ParentVisitor();
 
   Parameter thisParameter;
   Parameter explicitReceiverParameter;
 
-  Map<Primitive, Interceptor> interceptors = <Primitive, Interceptor>{};
-
   // In a catch block, rethrow implicitly throws the block's exception
   // parameter.  This is the exception parameter when nested in a catch
   // block and null otherwise.
   Parameter _exceptionParameter = null;
 
   UnsugarVisitor(this._glue);
 
   bool methodUsesReceiverArgument(FunctionElement function) {
     assert(_glue.isInterceptedMethod(function));
     ClassElement clazz = function.enclosingClass.declaration;
@@ skipping 168 matching lines @@
     // Rethrow can only appear in a catch block.  It throws that block's
     // (wrapped) caught exception.
     Throw replacement = new Throw(_exceptionParameter);
     InteriorNode parent = node.parent;
     parent.body = replacement;
     replacement.parent = parent;
     // The original rethrow does not have any references that we need to
     // worry about unlinking.
   }
 
-  /// Returns an interceptor for the given value, capable of responding to
-  /// [selector].
-  ///
-  /// A single getInterceptor call will be created per primitive, bound
-  /// immediately after the primitive is bound.
-  ///
-  /// The type propagation pass will later narrow the set of interceptors
-  /// based on the input type, and the let sinking pass will propagate the
-  /// getInterceptor call closer to its use when this is profitable.
-  Primitive getInterceptorFor(Primitive prim, Selector selector,
-                              SourceInformation sourceInformation) {
-    if (prim == explicitReceiverParameter) {
+  processInvokeMethod(InvokeMethod node) {
+    Selector selector = node.selector;
+    if (!_glue.isInterceptedSelector(selector)) return;
+
+    Primitive receiver = node.receiver.definition;
+    Primitive newReceiver;
+
+    if (receiver == explicitReceiverParameter) {
       // If the receiver is the explicit receiver, we are calling a method in
-      // the same interceptor.
-      return thisParameter;
+      // the same interceptor:
+      //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
+      newReceiver = thisParameter;
+    } else {
+      LetCont contBinding = node.parent;
+      newReceiver = new Interceptor(receiver, node.sourceInformation)
+          ..interceptedClasses.addAll(_glue.getInterceptedClassesOn(selector));
+      if (receiver.hint != null) {
+        newReceiver.hint = new InterceptorEntity(receiver.hint);
+      }
+      insertLetPrim(newReceiver, contBinding);
     }
-    assert(prim is! Interceptor);
-    Interceptor interceptor = interceptors[prim];
-    if (interceptor == null) {
-      interceptor = new Interceptor(prim, sourceInformation);
-      interceptors[prim] = interceptor;
-      InteriorNode parent = prim.parent;
-      insertLetPrim(interceptor, parent.body);
-      if (prim.hint != null) {
-        interceptor.hint = new InterceptorEntity(prim.hint);
-      }
-    }
-    // Add the interceptor classes that can respond to the given selector.
-    interceptor.interceptedClasses.addAll(
-        _glue.getInterceptedClassesOn(selector));
-    return interceptor;
-  }
-
-  processInvokeMethod(InvokeMethod node) {
-    if (_glue.isInterceptedSelector(node.selector)) {
-      // Rewrite `x.foo()` => `INTERCEPTOR.foo(x, ..)`.
-      Primitive receiver = node.receiver.definition;
-      Primitive newReceiver = 
-          getInterceptorFor(receiver, node.selector, node.sourceInformation);
-      node.arguments.insert(0, node.receiver);
-      node.receiver = new Reference<Primitive>(newReceiver);
-    }
+    node.arguments.insert(0, node.receiver);
+    node.receiver = new Reference<Primitive>(newReceiver);
   }
 
   processInvokeMethodDirectly(InvokeMethodDirectly node) {
-    if (_glue.isInterceptedMethod(node.target)) {
-      // Rewrite `x.foo()` => `INTERCEPTOR.foo(x, ..)`.
-      Primitive receiver = node.receiver.definition;
-      Primitive newReceiver = 
-          getInterceptorFor(receiver, node.selector, node.sourceInformation);
-      node.arguments.insert(0, node.receiver);
-      node.receiver = new Reference<Primitive>(newReceiver);
+    if (!_glue.isInterceptedMethod(node.target)) return;
+
+    Selector selector = node.selector;
+    Primitive receiver = node.receiver.definition;
+    Primitive newReceiver;
+
+    if (receiver == explicitReceiverParameter) {
+      // If the receiver is the explicit receiver, we are calling a method in
+      // the same interceptor:
+      //  Change 'receiver.foo()'  to  'this.foo(receiver)'.
+      newReceiver = thisParameter;
+    } else {
+      LetCont contBinding = node.parent;
+      newReceiver = new Interceptor(receiver, node.sourceInformation)
+        ..interceptedClasses.addAll(_glue.getInterceptedClassesOn(selector));
+      if (receiver.hint != null) {
+        newReceiver.hint = new InterceptorEntity(receiver.hint);
+      }
+      insertLetPrim(newReceiver, contBinding);
     }
+    node.arguments.insert(0, node.receiver);
+    node.receiver = new Reference<Primitive>(newReceiver);
   }
 
   processBranch(Branch node) {
     // TODO(karlklose): implement the checked mode part of boolean conversion.
     InteriorNode parent = node.parent;
     IsTrue condition = node.condition;
 
     // Do not rewrite conditions that are foreign code.
     // It is redundant, and causes infinite recursion (if not optimized)
     // in the implementation of identical, which itself contains a condition.
@@ skipping 21 matching lines @@
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }