Create specialized versions of getInterceptor.

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 617 matching lines @@
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsFunctionClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
   ClassElement objectInterceptorClass;
   Element jsArrayLength;
   Element jsStringLength;
   Element getInterceptorMethod;
-  Element arrayInterceptor;
-  Element boolInterceptor;
-  Element doubleInterceptor;
-  Element functionInterceptor;
-  Element intInterceptor;
-  Element nullInterceptor;
-  Element numberInterceptor;
-  Element stringInterceptor;
   bool _interceptorsAreInitialized = false;
 
   final Namer namer;
 
   /**
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
    */
   ClassElement jsIndexingBehaviorInterface;
@@ skipping 16 matching lines @@
    * emitter uses this set to generate the [:ObjectInterceptor:] class
    * whose members just forward the call to the intercepted receiver.
    */
   final Set<Selector> usedInterceptors;
 
   /**
    * 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;  
+  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
+   * the map are the names of these specialized versions. Note that
+   * the generic version that contains all possible type checks is
+   * also stored in this map.
+   */
+  final Map<String, Collection<ClassElement>> specializedGetInterceptors;

[ahe, 2012/11/27 14:29:45]

What is the key?

[ngeoffray, 2012/11/27 15:50:54]

It's in the comment above: the name of the specialized method.

+
+  /**
+   * Set of classes whose instances are intercepted.
+   */
+  final Set<ClassElement> interceptedClasses;
 
   List<CompilerTask> get tasks {
     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>(),
         interceptors = new Interceptors(compiler),
         usedInterceptors = new Set<Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypeInformation(compiler),
+        specializedGetInterceptors =
+            new Map<String, Collection<ClassElement>>(),
+        interceptedClasses = new Set<ClassElement>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
     argumentTypes = new ArgumentTypesRegistry(this);
     fieldTypes = new FieldTypesRegistry(this);
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
   bool isInterceptorClass(Element element) {
     if (element == null) return false;
-    return element == jsStringClass
-        || element == jsArrayClass
-        || element == jsIntClass
-        || element == jsDoubleClass
-        || element == jsNullClass
-        || element == jsFunctionClass
-        || element == jsBoolClass
-        || element == jsNumberClass;
+    return interceptedClasses.contains(element);
   }
 
   void addInterceptedSelector(Selector selector) {
     usedInterceptors.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) {
       if (selector.applies(element, compiler)) {
         result.add(element.getEnclosingClass());
       }
     }
     if (result.isEmpty) return null;
     return result;
   }
 
+  List<ClassElement> getListOfInterceptedClasses() {
+      return <ClassElement>[jsStringClass, jsArrayClass, jsIntClass,

[ahe, 2012/11/27 14:29:45]

I suggest you create this list in initializeInterceptorElements.  Like what I
did in CL 11421060.  This way you increase the chance that this list is in sync
with what is constructed in initializeInterceptorElements.

[ngeoffray, 2012/11/27 15:50:54]

Done.

+                            jsDoubleClass, jsNumberClass, jsNullClass,
+                            jsFunctionClass, jsBoolClass];
+  }
+
   void initializeInterceptorElements() {
     objectInterceptorClass =
         compiler.findInterceptor(const SourceString('ObjectInterceptor'));
     getInterceptorMethod =
         compiler.findInterceptor(const SourceString('getInterceptor'));
     jsStringClass =
         compiler.findInterceptor(const SourceString('JSString'));
     jsArrayClass =
         compiler.findInterceptor(const SourceString('JSArray'));
     jsNumberClass =
         compiler.findInterceptor(const SourceString('JSNumber'));
     jsIntClass =
         compiler.findInterceptor(const SourceString('JSInt'));
     jsDoubleClass =
         compiler.findInterceptor(const SourceString('JSDouble'));
     jsNullClass =
         compiler.findInterceptor(const SourceString('JSNull'));
     jsFunctionClass =
         compiler.findInterceptor(const SourceString('JSFunction'));
     jsBoolClass =
         compiler.findInterceptor(const SourceString('JSBool'));
     jsArrayClass.ensureResolved(compiler);
     jsArrayLength =
         jsArrayClass.lookupLocalMember(const SourceString('length'));
     jsStringClass.ensureResolved(compiler);
     jsStringLength =
         jsStringClass.lookupLocalMember(const SourceString('length'));
 
-    arrayInterceptor =
-        compiler.findInterceptor(const SourceString('arrayInterceptor'));
-    boolInterceptor =
-        compiler.findInterceptor(const SourceString('boolInterceptor'));
-    doubleInterceptor =
-        compiler.findInterceptor(const SourceString('doubleInterceptor'));
-    functionInterceptor =
-        compiler.findInterceptor(const SourceString('functionInterceptor'));
-    intInterceptor =
-        compiler.findInterceptor(const SourceString('intInterceptor'));
-    nullInterceptor =
-        compiler.findInterceptor(const SourceString('nullInterceptor'));
-    stringInterceptor =
-        compiler.findInterceptor(const SourceString('stringInterceptor'));
-    numberInterceptor =
-        compiler.findInterceptor(const SourceString('numberInterceptor'));
+    interceptedClasses.addAll(getListOfInterceptedClasses());
   }
 
   void addInterceptors(ClassElement cls) {
     cls.ensureResolved(compiler);
     cls.forEachMember((ClassElement classElement, Element member) {
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
       },
       includeSuperMembers: true);
   }
 
+  String registerSpecializedGetInterceptor(
+      Set<ClassElement> interceptedClasses) {
+    compiler.enqueuer.codegen.registerInstantiatedClass(objectInterceptorClass);
+    if (interceptedClasses.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, () {

[ahe, 2012/11/27 14:29:45]

I don't understand why you do this.  Why shouldn't you unconditionally store the
complete list?

[ngeoffray, 2012/11/27 15:50:54]

Because I did not want to call getListOfInterceptedClasses multiple times. As
discussed, I added a TODO to implement the set of intercepted classes with a
bitset.

+        // It is important to take the order provided by this list,
+        // because we want the int type check to happen before the
+        // double type check: the double type check covers the int
+        // type check.
+        return getListOfInterceptedClasses();
+      });
+      return namer.isolateAccess(getInterceptorMethod);
+    } else {
+      String name = namer.getSpecializedName(getInterceptorMethod,
+                                             interceptedClasses);
+      specializedGetInterceptors[name] = interceptedClasses;
+      return '${namer.CURRENT_ISOLATE}.$name';
+    }
+  }
+
   void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
     ClassElement result = null;
     if (!_interceptorsAreInitialized) {
       initializeInterceptorElements();
       _interceptorsAreInitialized = true;
-      // The null interceptor and the function interceptor are
-      // currently always instantiated if a new class is instantiated.
-      // TODO(ngeoffray): do this elsewhere for the function
-      // interceptor?
-      if (jsNullClass != null) {
-        addInterceptors(jsNullClass);
-        enqueuer.registerInstantiatedClass(jsNullClass);
-      }
-      if (jsFunctionClass != null) {
-        addInterceptors(jsFunctionClass);
-        enqueuer.registerInstantiatedClass(jsFunctionClass);
-      }
-      enqueuer.addToWorkList(getInterceptorMethod);
     }
     if (cls == compiler.stringClass) {
       result = jsStringClass;
     } else if (cls == compiler.listClass) {
       result = jsArrayClass;
     } else if (cls == compiler.intClass) {
       result = jsIntClass;
+      enqueuer.registerInstantiatedClass(jsNumberClass);
     } else if (cls == compiler.doubleClass) {
       result = jsDoubleClass;
+      enqueuer.registerInstantiatedClass(jsNumberClass);
     } else if (cls == compiler.functionClass) {
       result = jsFunctionClass;
     } else if (cls == compiler.boolClass) {
       result = jsBoolClass;
+    } else if (cls == compiler.nullClass) {
+      result = jsNullClass;
     }
 
     if (result == null) return;
     if (enqueuer.isResolutionQueue) addInterceptors(result);
     enqueuer.registerInstantiatedClass(result);
   }
 
   Element get cyclicThrowHelper {
     return compiler.findHelper(const SourceString("throwCyclicInit"));
   }
@@ skipping 256 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }