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 150 matching lines @@
   /**
    * 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;
   // 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

[floitsch, 2013/12/18 19:20:12]

Update comment.

[sra1, 2013/12/19 03:28:15]

Done.

 
   /**
+   * 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<SourceString, Set<Element>> interceptedMixinElements =
+      new Map<SourceString, Set<Element>>();
+
+  /**
    * 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 176 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 1482 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }