Cleanup after the interceptor refactoring work, and add a new SSA instruction for an interceptor, s…

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 677 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, List<Element>> interceptedElements;  
+  final Map<SourceString, Set<Element>> interceptedElements;  
 
   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, List<Element>>(),
+        interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypeInformation(compiler),
         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);
@@ skipping 14 matching lines @@
         || element == jsNullClass
         || element == jsFunctionClass
         || element == jsBoolClass
         || element == jsNumberClass;
   }
 
   void addInterceptedSelector(Selector selector) {
     usedInterceptors.add(selector);
   }
 
-  bool shouldInterceptSelector(Selector selector) {
-    List<Element> intercepted = interceptedElements[selector.name];
-    if (intercepted == null) return false;
+  /**
+   * 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) {

[ahe, 2012/11/22 13:26:11]

How about computing the reverse mapping?  This seems like a pretty expensive
operation.

[ngeoffray, 2012/11/22 13:37:59]

As discussed, we already have the reverse mapping, which is interceptedElements.
The loop is about finding elements that match the 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)) return true;
+      if (selector.applies(element, compiler)) {
+        result.add(element.getEnclosingClass());
+      }
     }
-    return false;
+    if (result.isEmpty) return null;
+    return result;
   }
 
   void initializeInterceptorElements() {
     objectInterceptorClass =
         compiler.findInterceptor(const SourceString('ObjectInterceptor'));
     getInterceptorMethod =
         compiler.findInterceptor(const SourceString('getInterceptor'));
     jsStringClass =
         compiler.findInterceptor(const SourceString('JSString'));
     jsArrayClass =
@@ skipping 16 matching lines @@
     jsStringClass.ensureResolved(compiler);
     jsStringLength =
         jsStringClass.lookupLocalMember(const SourceString('length'));
     listImplementation =
         compiler.coreLibrary.find(const SourceString('ListImplementation'));
   }
 
   void addInterceptors(ClassElement cls) {
     cls.ensureResolved(compiler);
     cls.forEachMember((ClassElement classElement, Element member) {
-      // TODO(ngeoffray): Support interceptors on Object methods.
-      if (classElement == compiler.objectClass) return;
-      List<Element> list = interceptedElements.putIfAbsent(
-          member.name, () => new List<Element>());
-      list.add(member);
-    }, includeSuperMembers: true);
+        Set<Element> set = interceptedElements.putIfAbsent(
+            member.name, () => new Set<Element>());
+        set.add(member);
+      },
+      includeSuperMembers: true);
   }
 
   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 || cls == listImplementation) {
       result = jsArrayClass;
     } else if (cls == compiler.intClass) {
       result = jsIntClass;
     } else if (cls == compiler.doubleClass) {
       result = jsDoubleClass;
     } else if (cls == compiler.functionClass) {
       result = jsFunctionClass;
     } else if (cls == compiler.boolClass) {
       result = jsBoolClass;
     }
 
     if (result == null) return;
     if (enqueuer.isResolutionQueue) addInterceptors(result);
     enqueuer.registerInstantiatedClass(result);
   }
 
   Element get cyclicThrowHelper {
     return compiler.findHelper(const SourceString("throwCyclicInit"));
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
-  Element getInterceptor(Selector selector) {
-    return interceptors.getStaticInterceptor(selector);
-  }
-
   void enqueueHelpers(Enqueuer world) {
     enqueueAllTopLevelFunctions(compiler.jsHelperLibrary, world);
 
     jsIndexingBehaviorInterface =
         compiler.findHelper(const SourceString('JavaScriptIndexingBehavior'));
     if (jsIndexingBehaviorInterface != null) {
       world.registerIsCheck(jsIndexingBehaviorInterface.computeType(compiler));
     }
 
     for (var helper in [const SourceString('Closure'),
@@ skipping 241 matching lines @@
     print("Inferred return types:");
     print("----------------------");
     dumpReturnTypes();
     print("");
     print("Inferred field types:");
     print("------------------------");
     fieldTypes.dump();
     print("");
   }
 }