Revert "Dummy receiver optimization"

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;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 146 matching lines @@
    * 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.
    */
   final Map<String, Set<Element>> interceptedElements;
-
-  /**
-   * The members of mixin classes that are mixed into an instantiated
-   * interceptor class.  This is a cached subset of [interceptedElements].
-   * These members must be invoked with a correct explicit receiver even when
-   * the receiver is not an intercepted class because the function uses the
-   * explicit interceptor parameter since it may be called on an intercepted
-   * class.
-   */
-  final Map<String, Set<Element>> interceptedMixinElements =
-      new Map<String, Set<Element>>();
+  // 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, Set<ClassElement>> specializedGetInterceptors;
@@ skipping 178 matching lines @@
   }
 
   bool isInterceptedName(String name) {
     return interceptedElements[name] != null;
   }
 
   bool isInterceptedSelector(Selector selector) {
     return interceptedElements[selector.name] != null;
   }
 
-  /**
-   * Returns `true` iff [selector] matches an element defined in a class mixed
-   * into an intercepted class.  These selectors are not eligible for the 'dummy
-   * explicit receiver' optimization.
-   */
-  bool isInterceptedMixinSelector(Selector selector) {
-    Set<Element> elements = interceptedMixinElements.putIfAbsent(
-        selector.name,
-        () {
-          Set<Element> elements = interceptedElements[selector.name];
-          if (elements == null) return null;
-          return elements
-              .where((element) =>
-                  classesMixedIntoNativeClasses.contains(
-                      element.getEnclosingClass()))
-              .toSet();
-        });
-
-    if (elements == null) return false;
-    if (elements.isEmpty) return false;
-    return elements.any((element) => selector.applies(element, compiler));
-  }
-
   final Map<String, Set<ClassElement>> interceptedClassesCache =
       new Map<String, Set<ClassElement>>();
 
   /**
    * Returns a set of interceptor classes that contain a member named
    * [name]. Returns [:null:] if there is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(String name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
@@ skipping 1466 matching lines @@
   void visitTrue(TrueConstant constant) => copy(constant);
 
   void visitFalse(FalseConstant constant) => copy(constant);
 
   void visitString(StringConstant constant) => copy(constant);
 
   void visitType(TypeConstant constant) => copy(constant);
 
   void visitInterceptor(InterceptorConstant constant) => copy(constant);
 
-  void visitDummyReceiver(DummyReceiverConstant constant) => copy(constant);
-
   void visitList(ListConstant constant) {
     copy(constant.entries);
     copy(constant);
   }
   void visitMap(MapConstant constant) {
     copy(constant.keys);
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }