Implement "one-shot" interceptors.

sdk/lib/_internal/compiler/implementation/ssa/codegen.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1481 matching lines @@
   }
 
   js.Call jsPropertyCall(js.Expression receiver,
                          String fieldName,
                          List<js.Expression> arguments) {
     return new js.Call(new js.PropertyAccess.field(receiver, fieldName),
                        arguments);
   }
 
   void visitInterceptor(HInterceptor node) {
-    String name =
-        backend.registerSpecializedGetInterceptor(node.interceptedClasses);
-    js.VariableUse interceptor = new js.VariableUse(name);
+    backend.registerSpecializedGetInterceptor(node.interceptedClasses);
+    String name = backend.namer.getInterceptorName(
+        backend.getInterceptorMethod, node.interceptedClasses);
+    var isolate = new js.VariableUse(backend.namer.CURRENT_ISOLATE);
     use(node.receiver);
     List<js.Expression> arguments = <js.Expression>[pop()];
-    push(new js.Call(interceptor, arguments), node);
+    push(jsPropertyCall(isolate, name, arguments), node);
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     SourceString name = node.selector.name;
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
     Element target = node.element;
 
@@ skipping 12 matching lines @@
         // list class is instantiated.
         world.registerInstantiatedClass(compiler.listClass);
       } else if (target == backend.jsStringConcat) {
         push(new js.Binary('+', object, arguments[0]), node);
         return;
       }
     }
 
     if (methodName == null) {
       methodName = backend.namer.invocationName(node.selector);
-      bool inLoop = node.block.enclosingLoopHeader != null;
-
-      Selector selector = getOptimizedSelectorFor(node, node.selector);
-      if (node.isInterceptorCall) {
-        backend.addInterceptedSelector(selector);
-      }
-      // Register this invocation to collect the types used at all call sites.
-      backend.registerDynamicInvocation(node, selector, types);
-
-      // If we don't know what we're calling or if we are calling a getter,
-      // we need to register that fact that we may be calling a closure
-      // with the same arguments.
-      if (target == null || target.isGetter()) {
-        // TODO(kasperl): If we have a typed selector for the call, we
-        // may know something about the types of closures that need
-        // the specific closure call method.
-        Selector call = new Selector.callClosureFrom(selector);
-        world.registerDynamicInvocation(call.name, call);
-      }
-
-      if (target != null) {
-        // If we know we're calling a specific method, register that
-        // method only.
-        if (inLoop) backend.builder.functionsCalledInLoop.add(target);
-        world.registerDynamicInvocationOf(target);
-      } else {
-        if (inLoop) backend.builder.selectorsCalledInLoop[name] = selector;
-        world.registerDynamicInvocation(name, selector);
-      }
+      registerMethodInvoke(node);
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
+  void visitOneShotInterceptor(HOneShotInterceptor node) {
+    List<js.Expression> arguments = visitArguments(node.inputs);
+    var isolate = new js.VariableUse(backend.namer.CURRENT_ISOLATE);
+    Selector selector = node.selector;
+    String methodName = backend.namer.oneShotInterceptorName(selector);
+    push(jsPropertyCall(isolate, methodName, arguments), node);
+    backend.registerSpecializedGetInterceptor(node.interceptedClasses);
+    backend.addOneShotInterceptor(selector);
+    if (selector.isGetter()) {
+      registerGetter(node);
+    } else if (selector.isSetter()) {
+      registerSetter(node);
+    } else {
+      registerMethodInvoke(node);
+    }
+  }
+
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
     // TODO(4434): For private members we need to use the untyped selector.
     if (defaultSelector.name.isPrivate()) return defaultSelector;
     // TODO(ngeoffray): Type intercepted calls.
     if (node.isInterceptorCall) return defaultSelector;
     // If [JSInvocationMirror.invokeOn] has been called, we must not create a
     // typed selector based on the receiver type.
     if (node.element == null && // Invocation is not exact.
         backend.compiler.enabledInvokeOn) {
       return defaultSelector;
     }
     HType receiverHType = types[node.inputs[0]];
     DartType receiverType = receiverHType.computeType(compiler);
     if (receiverType != null &&
         !identical(receiverType.kind, TypeKind.MALFORMED_TYPE)) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
+  void registerInvoke(HInvokeDynamic node) {
+    bool inLoop = node.block.enclosingLoopHeader != null;
+    SourceString name = node.selector.name;
+    if (inLoop) {
+      Element target = node.element;
+      if (target != null) {
+        backend.builder.functionsCalledInLoop.add(target);
+      } else {
+        backend.builder.selectorsCalledInLoop[name] = node.selector;
+      }
+    }
+
+    if (node.isInterceptorCall) {
+      backend.addInterceptedSelector(node.selector);
+    }
+  }
+
+  void registerMethodInvoke(HInvokeDynamic node) {
+    Selector selector = getOptimizedSelectorFor(node, node.selector);
+    // Register this invocation to collect the types used at all call sites.
+    backend.registerDynamicInvocation(node, selector, types);
+
+    // If we don't know what we're calling or if we are calling a getter,
+    // we need to register that fact that we may be calling a closure
+    // with the same arguments.
+    Element target = node.element;
+    if (target == null || target.isGetter()) {
+      // TODO(kasperl): If we have a typed selector for the call, we
+      // may know something about the types of closures that need
+      // the specific closure call method.
+      Selector call = new Selector.callClosureFrom(selector);
+      world.registerDynamicInvocation(call.name, call);
+    }
+
+    if (target != null) {
+      // If we know we're calling a specific method, register that
+      // method only.
+      world.registerDynamicInvocationOf(target);
+    } else {
+      SourceString name = node.selector.name;
+      world.registerDynamicInvocation(name, selector);
+    }
+    registerInvoke(node);
+  }
+
+  void registerSetter(HInvokeDynamic node) {
+    Selector selector = getOptimizedSelectorFor(node, node.selector);
+    world.registerDynamicSetter(selector.name, selector);
+    HType valueType;
+    if (node.isInterceptorCall) {

[kasperl, 2013/01/24 09:03:51]

Use ?: to avoid having an uninitialized valueType variable.

[ngeoffray, 2013/01/24 10:41:30]

Done.

+      valueType = types[node.inputs[2]];
+    } else {
+      valueType = types[node.inputs[1]];
+    }
+    backend.addedDynamicSetter(selector, valueType);
+    registerInvoke(node);
+  }
+
+  void registerGetter(HInvokeDynamic node) {
+    Selector getter = node.selector;
+    world.registerDynamicGetter(
+        getter.name, getOptimizedSelectorFor(node, getter));
+    world.registerInstantiatedClass(compiler.functionClass);
+    registerInvoke(node);
+  }
+
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     Selector setter = node.selector;
     String name = backend.namer.invocationName(setter);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
-    Selector selector = getOptimizedSelectorFor(node, setter);
-    world.registerDynamicSetter(setter.name, selector);
-    HType valueType;
-    if (node.isInterceptorCall) {
-      valueType = types[node.inputs[2]];
-      backend.addInterceptedSelector(setter);
-    } else {
-      valueType = types[node.inputs[1]];
-    }
-    backend.addedDynamicSetter(selector, valueType);
+    registerSetter(node);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     Selector getter = node.selector;
     String name = backend.namer.invocationName(getter);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
-    world.registerDynamicGetter(
-        getter.name, getOptimizedSelectorFor(node, getter));
-    if (node.isInterceptorCall) {
-      backend.addInterceptedSelector(getter);
-    }
-    world.registerInstantiatedClass(compiler.functionClass);
+    registerGetter(node);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(jsPropertyCall(pop(),
                         backend.namer.invocationName(call),
                         visitArguments(node.inputs)),
          node);
     world.registerDynamicInvocation(call.name, call);
@@ skipping 1365 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }