Implement "one-shot" interceptors.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 650 matching lines @@
   FieldTypesRegistry fieldTypes;
 
   /**
    * A collection of selectors of intercepted method calls. The
    * emitter uses this set to generate the [:ObjectInterceptor:] class
    * whose members just forward the call to the intercepted receiver.
    */
   final Set<Selector> usedInterceptors;
 
   /**
+   * A collection of selectors that must have a one shot interceptor
+   * generated.
+   */
+  final Set<Selector> oneShotInterceptors;

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

One option would be to use a SelectorMap and make that support ordered
iteration. Let's think about that.

+
+  /**
    * The members of instantiated interceptor classes: maps a member
    * name to the list of members that have that name. This map is used
    * by the codegen to know whether a send must be intercepted or not.
    */
   final Map<SourceString, Set<Element>> interceptedElements;
 
   /**
    * A map of specialized versions of the [getInterceptorMethod].
    * Since [getInterceptorMethod] is a hot method at runtime, we're
    * always specializing it based on the incoming type. The keys in
@@ skipping 14 matching lines @@
     return <CompilerTask>[builder, optimizer, generator, emitter];
   }
 
   final RuntimeTypeInformation rti;
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap, bool disableEval)
       : namer = determineNamer(compiler),
         returnInfo = new Map<Element, ReturnInfo>(),
         invalidateAfterCodegen = new List<Element>(),
         usedInterceptors = new Set<Selector>(),
+        oneShotInterceptors = new Set<Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypeInformation(compiler),
         specializedGetInterceptors =
             new Map<String, Collection<ClassElement>>(),
         interceptedClasses = new LinkedHashMap<ClassElement, ClassElement>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
@@ skipping 11 matching lines @@
 
   bool isInterceptorClass(Element element) {
     if (element == null) return false;
     return interceptedClasses.containsKey(element);
   }
 
   void addInterceptedSelector(Selector selector) {
     usedInterceptors.add(selector);
   }
 
+  void addOneShotInterceptor(Selector selector) {
+    oneShotInterceptors.add(selector);
+  }
+
   /**
    * Returns a set of interceptor classes that contain a member whose
    * signature matches the given [selector]. Returns [:null:] if there
    * is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(Selector selector) {
     Set<Element> intercepted = interceptedElements[selector.name];
     if (intercepted == null) return null;
     Set<ClassElement> result = new Set<ClassElement>();
     for (Element element in intercepted) {
@@ skipping 56 matching lines @@
       cls.forEachMember((ClassElement classElement, Element member) {
           Set<Element> set = interceptedElements.putIfAbsent(
               member.name, () => new Set<Element>());
           set.add(member);
         },
         includeSuperMembers: true);
     }
     enqueuer.registerInstantiatedClass(cls);
   }
 
-  String registerSpecializedGetInterceptor(Set<ClassElement> classes) {
+  void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     compiler.enqueuer.codegen.registerInstantiatedClass(objectInterceptorClass);
+    String name = namer.getInterceptorName(getInterceptorMethod, classes);
     if (classes.contains(compiler.objectClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
-      String name = namer.getName(getInterceptorMethod);
       specializedGetInterceptors.putIfAbsent(name, () {
         // It is important to take the order provided by the map,
         // because we want the int type check to happen before the
         // double type check: the double type check covers the int
         // type check. Also we don't need to do a number type check
         // because that is covered by the double type check.
         List<ClassElement> keys = <ClassElement>[];
         interceptedClasses.forEach((ClassElement cls, _) {
           if (cls != jsNumberClass) keys.add(cls);
         });
         return keys;
       });
-      return namer.isolateAccess(getInterceptorMethod);
     } else {
-      String name = namer.getSpecializedName(getInterceptorMethod, classes);
       specializedGetInterceptors[name] = classes;
-      return '${namer.CURRENT_ISOLATE}.$name';
     }
   }
 
   void initializeNoSuchMethod() {
     // In case the emitter generates noSuchMethod calls, we need to
     // make sure all [noSuchMethod] methods know they might take a
     // [JsInvocationMirror] as parameter.
     HTypeList types = new HTypeList(1);
     types[0] = new HType.fromBoundedType(
         compiler.jsInvocationMirrorClass.computeType(compiler),
@@ skipping 345 matching lines @@
   }
 
   Element getSetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('setRuntimeTypeInfo'));
   }
 
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
 }