Limit interceptedElements to instantiated members only.

pkg/compiler/lib/src/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 327 matching lines @@
   bool needToInitializeDispatchProperty = false;
 
   final Namer namer;
 
   /**
    * A collection of selectors that must have a one shot interceptor
    * generated.
    */
   final Map<jsAst.Name, 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;
+  /// All known intercepted members. Collected during resolution.
+  final Map<String, Set<Element>> _interceptedElements =
+      <String, Set<Element>>{};
+
+  /// Cache for all instantiated intercepted members for [interceptedElements].
+  Map<String, Set<Element>> _instantiatedInterceptedElements;
 
   /**
    * The members of mixin classes that are mixed into an instantiated
    * interceptor class.  This is a cached subset of [interceptedElements].
    *
    * Mixin methods are not specialized for the class they are mixed into.
    * Methods mixed into intercepted classes thus always make use of the explicit
    * receiver argument, even when mixed into non-interceptor classes.
    *
    * These members must be invoked with a correct explicit receiver even when
    * the receiver is not an intercepted class.
    */
-  final Map<String, Set<Element>> interceptedMixinElements =
+  final Map<String, Set<Element>> _interceptedMixinElements =
       new Map<String, 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.
    */
@@ skipping 128 matching lines @@
   final SourceInformationStrategy sourceInformationStrategy;
 
   final BackendHelpers helpers;
   final BackendImpacts impacts;
 
   JavaScriptBackend(Compiler compiler,
                     {bool generateSourceMap: true,
                      bool useStartupEmitter: false})
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<jsAst.Name, Selector>(),
-        interceptedElements = new Map<String, Set<Element>>(),
         rti = new _RuntimeTypes(compiler),
         rtiEncoder = new _RuntimeTypesEncoder(compiler),
         specializedGetInterceptors = new Map<jsAst.Name, Set<ClassElement>>(),
         annotations = new Annotations(compiler),
         this.sourceInformationStrategy =
             generateSourceMap
                 ? (useNewSourceInfo
                      ? const PositionSourceInformationStrategy()
                      : const StartEndSourceInformationStrategy())
                 : const JavaScriptSourceInformationStrategy(),
@@ skipping 313 matching lines @@
   }
 
   bool isInterceptedName(String name) {
     return interceptedElements[name] != null;
   }
 
   bool isInterceptedSelector(Selector selector) {
     return interceptedElements[selector.name] != null;
   }
 
+  /// 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.
+  Map<String, Set<Element>> get interceptedElements {
+    assert(compiler.enqueuer.resolution.queueIsClosed);
+    if (_instantiatedInterceptedElements == null) {
+      _instantiatedInterceptedElements = <String, Set<Element>>{};
+      _interceptedElements.forEach((String name, Set<Element> members) {
+        Set<Element> instantiatedMembers = new Set<Element>();
+        for (Element member in members) {
+          if (compiler.world.isInstantiated(member.enclosingClass)) {
+            instantiatedMembers.add(member);
+          }
+        }
+        if (instantiatedMembers.isNotEmpty) {
+          _instantiatedInterceptedElements[name] = instantiatedMembers;
+        }
+      });
+    }
+    return _instantiatedInterceptedElements;
+  }
+
   /**
    * 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, TypeMask mask) {
-    Set<Element> elements = interceptedMixinElements.putIfAbsent(
+    Set<Element> elements = _interceptedMixinElements.putIfAbsent(
         selector.name,
         () {
           Set<Element> elements = interceptedElements[selector.name];
           if (elements == null) return null;
           return elements
               .where((element) =>
                   classesMixedIntoInterceptedClasses.contains(
                       element.enclosingClass))
               .toSet();
         });
@@ skipping 98 matching lines @@
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Identifiers.call) {
           reporter.reportErrorMessage(
               member,
               MessageKind.CALL_NOT_SUPPORTED_ON_NATIVE_CLASS);
           return;
         }
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == coreClasses.objectClass) return;
-        Set<Element> set = interceptedElements.putIfAbsent(
-            member.name, () => new Set<Element>());
+        Set<Element> set = _interceptedElements.putIfAbsent(
+            member.name, () => new Setlet<Element>());
         set.add(member);
       },
       includeSuperAndInjectedMembers: true);
 
       // Walk superclass chain to find mixins.
       for (; cls != null; cls = cls.superclass) {
         if (cls.isMixinApplication) {
           MixinApplicationElement mixinApplication = cls;
           classesMixedIntoInterceptedClasses.add(mixinApplication.mixin);
         }
       }
     }
   }
 
   void addInterceptors(ClassElement cls,
                        Enqueuer enqueuer,
                        Registry registry) {
     if (enqueuer.isResolutionQueue) {
       _interceptedClasses.add(helpers.jsInterceptorClass);
       _interceptedClasses.add(cls);
       cls.ensureResolved(resolution);
       cls.forEachMember((ClassElement classElement, Element member) {
           // All methods on [Object] are shadowed by [Interceptor].
           if (classElement == coreClasses.objectClass) return;
-          Set<Element> set = interceptedElements.putIfAbsent(
-              member.name, () => new Set<Element>());
+          Set<Element> set = _interceptedElements.putIfAbsent(
+              member.name, () => new Setlet<Element>());
           set.add(member);
         },
         includeSuperAndInjectedMembers: true);
     }
     enqueueClass(enqueuer, cls, registry);
   }
 
   Set<ClassElement> get interceptedClasses {
     assert(compiler.enqueuer.resolution.queueIsClosed);
     return _interceptedClasses;
@@ skipping 2029 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }