Make instance methods whose names collide with intercepted methods have the interceptor calling con…

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 624 matching lines @@
       new Map<Element, jsAst.Expression>();
 
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsFunctionClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
-  ClassElement objectInterceptorClass;
   Element jsArrayLength;
   Element jsStringLength;
   Element jsArrayRemoveLast;
   Element jsArrayAdd;
   Element jsStringSplit;
   Element jsStringConcat;
   Element jsStringToString;
   Element getInterceptorMethod;
+  Element interceptedNames;
   Element fixedLengthListConstructor;
   bool seenAnyClass = false;
 
   final Namer namer;
 
   /**
    * Interface used to determine if an object has the JavaScript
    * indexing behavior. The interface is only visible to specific
    * libraries.
    */
@@ skipping 34 matching lines @@
    * 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;
 
   /**
-   * Set of classes whose instances are intercepted. Implemented as a
-   * [LinkedHashMap] to preserve the insertion order.
-   * TODO(ngeoffray): No need to preserve order anymore.
+   * Set of classes whose methods are intercepted.
    */
-  final Map<ClassElement, ClassElement> interceptedClasses;
+  final Set<ClassElement> interceptedClasses;
 
   /**
    * Set of selectors that are used from within loops. Used by the
    * builder to allow speculative optimizations for functions without
    * loops themselves.
    */
   final Map<SourceString, Set<Selector>> selectorsCalledInLoop =
       new Map<SourceString, Set<Selector>>();
 
   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>(),
         usedInterceptors = new Set<Selector>(),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypeInformation(compiler),
         specializedGetInterceptors =
             new Map<String, Collection<ClassElement>>(),
-        interceptedClasses = new LinkedHashMap<ClassElement, ClassElement>(),
+        interceptedClasses = new Set<ClassElement>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         // TODO(8522): Restore --disallow-unsafe-eval.
         ? null // 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 interceptedClasses.containsKey(element);
+    return interceptedClasses.contains(element);
   }
 
   void addInterceptedSelector(Selector selector) {
     usedInterceptors.add(selector);
   }
 
   String registerOneShotInterceptor(Selector selector) {
-    Set<ClassElement> classes = getInterceptedClassesOn(selector);
+    Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
     String name = namer.getOneShotInterceptorName(selector, classes);
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
       oneShotInterceptors[name] = selector;
     }
     return name;
   }
 
-  final Map<Selector, Set<ClassElement>> interceptedClassesCache =
-      new Map<Selector, Set<ClassElement>>();
-  final Map<Selector, Set<ClassElement>> interceptedClassesNonNullCache =
-      new Map<Selector, Set<ClassElement>>();
+  bool isInterceptedMethod(Element element) {
+    return element.isInstanceMember()
+        && interceptedElements[element.name] != null;
+  }
+
+  bool isInterceptedName(SourceString name) {
+    return interceptedElements[name] != null;
+  }
+
+  final Map<SourceString, Set<ClassElement>> interceptedClassesCache =
+      new Map<SourceString, Set<ClassElement>>();
 
   /**
-   * Returns a set of interceptor classes that contain a member whose
-   * signature matches the given [selector]. Returns [:null:] if there
-   * is no class.
+   * Returns a set of interceptor classes that contain a member named
+   * [name[. Returns [:null:] if there is no class.

[sra1, 2013/02/27 05:13:28]

[name]

[ngeoffray, 2013/02/28 10:39:42]

Done.

    */
-  Set<ClassElement> getInterceptedClassesOn(Selector selector,
-                                            {bool canBeNull: true}) {
-    Set<Element> intercepted = interceptedElements[selector.name];
+  Set<ClassElement> getInterceptedClassesOn(SourceString name) {
+    Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
-    // Pick the right cache and query it.
-    Map<Selector, Set<ClassElement>> cache = canBeNull
-        ? interceptedClassesCache
-        : interceptedClassesNonNullCache;
-    if (cache.containsKey(selector)) return cache[selector];
+    if (interceptedClassesCache.containsKey(name)) {
+      return interceptedClassesCache[name];
+    }
     // Populate the cache by running through all the elements and
     // determine if the given selector applies to them.
     Set<ClassElement> result = new Set<ClassElement>();
     for (Element element in intercepted) {
-      ClassElement enclosing = element.getEnclosingClass();
-      // We have to treat null as a bottom type, so we use the untyped
-      // applies method for those elements that are implemented on the
-      // null class.
-      bool applies = (enclosing == jsNullClass)
-          ? canBeNull && selector.appliesUntyped(element, compiler)
-          : selector.applies(element, compiler);
-      if (applies) result.add(enclosing);
+      result.add(element.getEnclosingClass());
     }
-    if (result.isEmpty) result = null;
-    cache[selector] = result;
-    assert(cache.containsKey(selector));
+    interceptedClassesCache[name] = result;
     return result;
   }
 
   void initializeInterceptorElements() {
-    objectInterceptorClass =
-        compiler.findInterceptor(const SourceString('ObjectInterceptor'));
     getInterceptorMethod =
         compiler.findInterceptor(const SourceString('getInterceptor'));
+    interceptedNames =
+        compiler.findInterceptor(const SourceString('interceptedNames'));
     List<ClassElement> classes = [
+      compiler.objectClass,
       jsStringClass = compiler.findInterceptor(const SourceString('JSString')),
       jsArrayClass = compiler.findInterceptor(const SourceString('JSArray')),
       // The int class must be before the double class, because the
       // emitter relies on this list for the order of type checks.
       jsIntClass = compiler.findInterceptor(const SourceString('JSInt')),
       jsDoubleClass = compiler.findInterceptor(const SourceString('JSDouble')),
       jsNumberClass = compiler.findInterceptor(const SourceString('JSNumber')),
       jsNullClass = compiler.findInterceptor(const SourceString('JSNull')),
       jsFunctionClass =
           compiler.findInterceptor(const SourceString('JSFunction')),
@@ skipping 11 matching lines @@
     jsStringLength = compiler.lookupElementIn(
         jsStringClass, const SourceString('length'));
     jsStringSplit = compiler.lookupElementIn(
         jsStringClass, const SourceString('split'));
     jsStringConcat = compiler.lookupElementIn(
         jsStringClass, const SourceString('concat'));
     jsStringToString = compiler.lookupElementIn(
         jsStringClass, const SourceString('toString'));
 
     for (ClassElement cls in classes) {
-      if (cls != null) interceptedClasses[cls] = null;
+      if (cls != null) interceptedClasses.add(cls);
     }
   }
 
   void addInterceptors(ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
           Set<Element> set = interceptedElements.putIfAbsent(
               member.name, () => new Set<Element>());
           set.add(member);
         },
         includeSuperMembers: true);
     }
     enqueuer.registerInstantiatedClass(cls);
   }
 
   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.
-      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;
-      });
+      specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
 
   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);
@@ skipping 603 matching lines @@
    *
    * Invariant: [element] must be a declaration element.
    */
   void eagerRecompile(Element element) {
     assert(invariant(element, element.isDeclaration));
     generatedCode.remove(element);
     generatedBailoutCode.remove(element);
     compiler.enqueuer.codegen.addToWorkList(element);
   }
 }