Add StaticUse for more precise registration of statically known element use.

pkg/compiler/lib/src/enqueue.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.
 
 library dart2js.enqueue;
 
 import 'dart:collection' show
     Queue;
 
 import 'common.dart';
@@ skipping 33 matching lines @@
     Name,
     TypedElement,
     TypedefElement;
 import 'js/js.dart' as js;
 import 'native/native.dart' as native;
 import 'types/types.dart' show
     TypeMaskStrategy;
 import 'universe/selector.dart' show
     Selector;
 import 'universe/universe.dart';
+import 'universe/use.dart' show
+    StaticUse,
+    StaticUseKind;
 import 'universe/world_impact.dart' show
     WorldImpact;
 import 'util/util.dart' show
     Link,
     Setlet;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 90 matching lines @@
   /**
    * Adds [element] to the work list if it has not already been processed.
    *
    * Returns [true] if the element was actually added to the queue.
    */
   bool internalAddToWorkList(Element element);
 
   /// Apply the [worldImpact] of processing [element] to this enqueuer.
   void applyImpact(Element element, WorldImpact worldImpact) {
     // TODO(johnniwinther): Optimize the application of the world impact.
-    worldImpact.dynamicInvocations.forEach(registerDynamicInvocation);
-    worldImpact.dynamicGetters.forEach(registerDynamicGetter);
-    worldImpact.dynamicSetters.forEach(registerDynamicSetter);
+    worldImpact.dynamicUses.forEach(registerDynamicUse);
     worldImpact.staticUses.forEach(registerStaticUse);
     worldImpact.instantiatedTypes.forEach(registerInstantiatedType);
     worldImpact.isChecks.forEach(registerIsCheck);
     worldImpact.asCasts.forEach(registerIsCheck);
     if (compiler.enableTypeAssertions) {
       worldImpact.checkedModeChecks.forEach(registerIsCheck);
     }
     worldImpact.onCatchTypes.forEach(registerIsCheck);
-    worldImpact.closurizedFunctions.forEach(registerGetOfStaticFunction);
     worldImpact.closures.forEach(registerClosure);
   }
 
-  // TODO(johnniwinther): Remove the need for passing the [registry].
   void registerInstantiatedType(InterfaceType type,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
       universe.registerTypeInstantiation(
           type,
           isNative: compiler.backend.isNative(cls),
           byMirrors: mirrorUsage,
           onImplemented: (ClassElement cls) {
@@ skipping 149 matching lines @@
             superclass, this, compiler.globalDependencies);
       }
 
       while (cls != null) {
         processClass(cls);
         cls = cls.superclass;
       }
     });
   }
 
-  void registerInvocation(UniverseSelector selector) {
+  void registerDynamicUse(UniverseSelector selector) {
     task.measure(() {
-      if (universe.registerInvocation(selector)) {
+      if (universe.registerDynamicUse(selector)) {
         handleUnseenSelector(selector);
       }
     });
-  }
-
-  void registerInvokedGetter(UniverseSelector selector) {
-    task.measure(() {
-      if (universe.registerInvokedGetter(selector)) {
-        handleUnseenSelector(selector);
-      }
-    });
-  }
-
-  void registerInvokedSetter(UniverseSelector selector) {
-    task.measure(() {
-      if (universe.registerInvokedSetter(selector)) {
-        handleUnseenSelector(selector);
-      }
-    });
   }
 
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system. [includedEnclosing] provides a hint whether the
    * enclosing element was included.
    *
    * The actual implementation depends on the current compiler phase.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
@@ skipping 13 matching lines @@
                                     bool enclosingWasIncluded) {
     if (shouldIncludeElementDueToMirrors(ctor,
         includedEnclosing: enclosingWasIncluded)) {
       logEnqueueReflectiveAction(ctor);
       ClassElement cls = ctor.declaration.enclosingClass;
       compiler.backend.registerInstantiatedType(
           cls.rawType,
           this,
           compiler.mirrorDependencies,
           mirrorUsage: true);
-      registerStaticUse(ctor.declaration);
+      registerStaticUse(new StaticUse.foreignUse(ctor.declaration));
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveMember(Element element, bool enclosingWasIncluded) {
     if (shouldIncludeElementDueToMirrors(element,
             includedEnclosing: enclosingWasIncluded)) {
       logEnqueueReflectiveAction(element);
       if (element.isTypedef) {
         TypedefElement typedef = element;
         typedef.ensureResolved(resolution);
         compiler.world.allTypedefs.add(element);
       } else if (Elements.isStaticOrTopLevel(element)) {
-        registerStaticUse(element.declaration);
+        registerStaticUse(new StaticUse.foreignUse(element.declaration));
       } else if (element.isInstanceMember) {
         // We need to enqueue all members matching this one in subclasses, as
         // well.
         // TODO(herhut): Use TypedSelector.subtype for enqueueing
         UniverseSelector selector = new UniverseSelector(
             new Selector.fromElement(element), null);
-        registerSelectorUse(selector);
+        registerDynamicUse(selector);
         if (element.isField) {
           UniverseSelector selector = new UniverseSelector(
               new Selector.setter(new Name(
                   element.name, element.library, isSetter: true)), null);
-          registerInvokedSetter(selector);
+          registerDynamicUse(selector);
         }
       }
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveElementsInClass(ClassElement cls,
@@ skipping 125 matching lines @@
 
   processInstanceMembers(String n, bool f(Element e)) {
     processSet(instanceMembersByName, n, f);
   }
 
   processInstanceFunctions(String n, bool f(Element e)) {
     processSet(instanceFunctionsByName, n, f);
   }
 
   void handleUnseenSelector(UniverseSelector universeSelector) {
-    strategy.processSelector(this, universeSelector);
+    strategy.processDynamicUse(this, universeSelector);
   }
 
   void handleUnseenSelectorInternal(UniverseSelector universeSelector) {
     Selector selector = universeSelector.selector;
     String methodName = selector.name;
     processInstanceMembers(methodName, (Element member) {
       if (universeSelector.appliesUnnamed(member, compiler.world)) {
         if (member.isFunction && selector.isGetter) {
           registerClosurizedMember(member);
         }
@@ skipping 29 matching lines @@
         return false;
       });
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
-  void registerStaticUse(Element element) {
-    if (element == null) return;
-    strategy.processStaticUse(this, element);
+  void registerStaticUse(StaticUse staticUse) {
+    strategy.processStaticUse(this, staticUse);
   }
 
-  void registerStaticUseInternal(Element element) {
+  void registerStaticUseInternal(StaticUse staticUse) {
+    Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
-    if (Elements.isStaticOrTopLevel(element) && element.isField) {
-      universe.registerStaticFieldUse(element);
+    universe.registerStaticUse(staticUse);
+    compiler.backend.registerStaticUse(element, this);
+    bool addElement = true;
+    switch (staticUse.kind) {
+      case StaticUseKind.STATIC_TEAR_OFF:
+        compiler.backend.registerGetOfStaticFunction(this);
+        break;
+      case StaticUseKind.FIELD_GET:
+      case StaticUseKind.FIELD_SET:
+        // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
+        // [FIELD_SET] contains [BoxFieldElement]s which we cannot enqueue.
+        addElement = false;
+        break;
+      case StaticUseKind.SUPER_TEAR_OFF:
+      case StaticUseKind.GENERAL:
+        break;
     }
-    addToWorkList(element);
-    compiler.backend.registerStaticUse(element, this);
-  }
-
-  void registerGetOfStaticFunction(FunctionElement element) {
-    registerStaticUse(element);
-    compiler.backend.registerGetOfStaticFunction(this);
-    universe.staticFunctionsNeedingGetter.add(element);
-  }
-
-  void registerDynamicInvocation(UniverseSelector selector) {
-    assert(selector != null);
-    registerInvocation(selector);
-  }
-
-  void registerSelectorUse(UniverseSelector universeSelector) {
-    if (universeSelector.selector.isGetter) {
-      registerInvokedGetter(universeSelector);
-    } else if (universeSelector.selector.isSetter) {
-      registerInvokedSetter(universeSelector);
-    } else {
-      registerInvocation(universeSelector);
+    if (addElement) {
+      addToWorkList(element);
     }
   }
 
-  void registerDynamicGetter(UniverseSelector selector) {
-    registerInvokedGetter(selector);
-  }
-
-  void registerDynamicSetter(UniverseSelector selector) {
-    registerInvokedSetter(selector);
-  }
-
-  void registerGetterForSuperMethod(Element element) {
-    universe.methodsNeedingSuperGetter.add(element);
-  }
-
-  void registerFieldGetter(Element element) {
-    universe.fieldGetters.add(element);
-  }
-
-  void registerFieldSetter(Element element) {
-    universe.fieldSetters.add(element);
-  }
-
   void registerIsCheck(DartType type) {
     type = universe.registerIsCheck(type, compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(!type.isTypeVariable ||
            !type.element.enclosingElement.isTypedef);
   }
 
   void registerCallMethodWithFreeTypeVariables(Element element) {
@@ skipping 334 matching lines @@
 }
 
 /// Strategy used by the enqueuer to populate the world.
 // TODO(johnniwinther): Merge this interface with [QueueFilter].
 class EnqueuerStrategy {
   const EnqueuerStrategy();
 
   /// Process a class instantiated in live code.
   void processInstantiatedClass(Enqueuer enqueuer, ClassElement cls) {}
 
-  /// Process an element statically accessed in live code.
-  void processStaticUse(Enqueuer enqueuer, Element element) {}
+  /// Process a static use of and element in live code.
+  void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {}
 
   /// Process a selector for a call site in live code.
-  void processSelector(Enqueuer enqueuer, UniverseSelector selector) {}
+  void processDynamicUse(Enqueuer enqueuer, UniverseSelector dynamicUse) {}
 }
 
 class TreeShakingEnqueuerStrategy implements EnqueuerStrategy {
   const TreeShakingEnqueuerStrategy();
 
   @override
   void processInstantiatedClass(Enqueuer enqueuer, ClassElement cls) {
     cls.implementation.forEachMember(enqueuer.processInstantiatedClassMember);
   }
 
   @override
-  void processStaticUse(Enqueuer enqueuer, Element element) {
-    enqueuer.registerStaticUseInternal(element);
+  void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {
+    enqueuer.registerStaticUseInternal(staticUse);
   }
 
   @override
-  void processSelector(Enqueuer enqueuer, UniverseSelector selector) {
-    enqueuer.handleUnseenSelectorInternal(selector);
+  void processDynamicUse(Enqueuer enqueuer, UniverseSelector dynamicUse) {
+    enqueuer.handleUnseenSelectorInternal(dynamicUse);
   }
 }