Revert "Revert "Use interceptor convention for methods declared on native classes.""

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 681 matching lines @@
    */
   final Set<Selector> usedInterceptors;
 
   /**
    * A collection of selectors that must have a one shot interceptor
    * generated.
    */
   final Map<String, Selector> oneShotInterceptors;
 
   /**
-   * 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.
+   * 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;
+  // TODO(sra): Not all methods in the Set always require an interceptor.  A
+  // method may be mixed into a true interceptor *and* a plain class. For the
+  // method to work on the interceptor class it needs to use the explicit
+  // receiver.  This constrains the call on a known plain receiver to pass the
+  // explicit receiver.  https://code.google.com/p/dart/issues/detail?id=8942
 
   /**
    * 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;
@@ skipping 43 matching lines @@
     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) {
+  bool isInterceptorClass(ClassElement element) {
     if (element == null) return false;
+    if (element.isNative()) return true;
     return interceptedClasses.contains(element);
   }
 
   void addInterceptedSelector(Selector selector) {
     usedInterceptors.add(selector);
   }
 
   String registerOneShotInterceptor(Selector selector) {
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
     String name = namer.getOneShotInterceptorName(selector, classes);
@@ skipping 31 matching lines @@
    * [name]. Returns [:null:] if there is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(SourceString name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
     return interceptedClassesCache.putIfAbsent(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) {
-        result.add(element.getEnclosingClass());
+        ClassElement classElement = element.getEnclosingClass();
+        result.add(classElement);
       }
       return result;
     });
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(
         operatorEqfunction.getEnclosingClass());
   }
 
@@ skipping 61 matching lines @@
     mapLiteralClass =
         compiler.coreLibrary.find(const SourceString('LinkedHashMap'));
     constMapLiteralClass =
         compiler.findHelper(const SourceString('ConstantMap'));
 
     specialOperatorEqClasses
         ..add(jsNullClass)
         ..add(jsNumberClass);
   }
 
+  void addInterceptorsForNativeClassMembers(
+      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);
+    }
+  }
+
   void addInterceptors(ClassElement cls,
                        Enqueuer enqueuer,
                        TreeElements elements) {
     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);
         },
@@ skipping 76 matching lines @@
       addInterceptors(jsFunctionClass, enqueuer, elements);
     } else if (cls == compiler.boolClass) {
       addInterceptors(jsBoolClass, enqueuer, elements);
     } else if (cls == compiler.nullClass) {
       addInterceptors(jsNullClass, enqueuer, elements);
     } else if (cls == compiler.numClass) {
       addInterceptors(jsIntClass, enqueuer, elements);
       addInterceptors(jsDoubleClass, enqueuer, elements);
       addInterceptors(jsNumberClass, enqueuer, elements);
     } else if (cls == compiler.mapClass) {
+    } else if (cls.isNative()) {
+      addInterceptorsForNativeClassMembers(cls, enqueuer);
     }
 
     if (compiler.enableTypeAssertions) {
       // We need to register is checks for assignments to fields.
       cls.forEachLocalMember((Element member) {
         if (!member.isInstanceMember() || !member.isField()) return;
         DartType type = member.computeType(compiler);
         enqueuer.registerIsCheck(type, elements);
       });
     }
@@ skipping 637 matching lines @@
   ClassElement get constListImplementation => jsArrayClass;
   ClassElement get fixedListImplementation => jsFixedArrayClass;
   ClassElement get growableListImplementation => jsExtendableArrayClass;
   ClassElement get mapImplementation => mapLiteralClass;
   ClassElement get constMapImplementation => constMapLiteralClass;
   ClassElement get functionImplementation => jsFunctionClass;
   ClassElement get typeImplementation => typeLiteralClass;
   ClassElement get boolImplementation => jsBoolClass;
   ClassElement get nullImplementation => jsNullClass;
 }