Redo "Information about which functions require other functions is gathered in the enqueuer."

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 31 matching lines @@
   static final TRACE_MIRROR_ENQUEUING =
       const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
 
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer;  // Set by EnqueueTask
 
   bool hasEnqueuedReflectiveElements = false;
   bool hasEnqueuedReflectiveStaticFields = false;
 
+  CompilationInformation get compilationInfo;
+
   Enqueuer(this.name, this.compiler, this.itemCompilationContextCreator);
 
   Queue<WorkItem> get queue;
   bool get queueIsEmpty => queue.isEmpty;
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   QueueFilter get filter => compiler.enqueuerFilter;
 
   /// Returns [:true:] if [member] has been processed by this enqueuer.
   bool isProcessed(Element member);
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
-    internalAddToWorkList(element);
+    if (internalAddToWorkList(element)) {
+      compilationInfo.addsToWorkList(compiler.currentElement, element);
+    }
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
+   *
+   * Returns [true] if the element was actually added to the queue.
    */
-  void internalAddToWorkList(Element element);
+  bool internalAddToWorkList(Element element);
 
   void registerInstantiatedType(InterfaceType type, Registry registry,
                                 {mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       registry.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.instantiatedTypes.add(type);
       if (!cls.isAbstract
           // We can't use the closed-world assumption with native abstract
@@ skipping 87 matching lines @@
         registerClosurizedMember(member, compiler.globalDependencies);
         addToWorkList(member);
         return;
       }
       // Store the member in [instanceFunctionsByName] to catch
       // getters on the function.
       Link<Element> members = instanceFunctionsByName.putIfAbsent(
           memberName, () => const Link<Element>());
       instanceFunctionsByName[memberName] = members.prepend(member);
       if (universe.hasInvocation(member, compiler)) {
+        compilationInfo.enqueues(getContext(), member);
         addToWorkList(member);
         return;
       }
     } else if (member.kind == ElementKind.GETTER) {
       if (universe.hasInvokedGetter(member, compiler)) {
         addToWorkList(member);
         return;
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
@@ skipping 11 matching lines @@
     // The element is not yet used. Add it to the list of instance
     // members to still be processed.
     Link<Element> members = instanceMembersByName.putIfAbsent(
         memberName, () => const Link<Element>());
     instanceMembersByName[memberName] = members.prepend(member);
   }
 
   void enableNoSuchMethod(Element element) {}
   void enableIsolateSupport() {}
 
+  Element getContext() => compiler.currentElement;
+
   void onRegisterInstantiatedClass(ClassElement cls) {
     task.measure(() {
       if (seenClasses.contains(cls)) return;
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(compiler);
 
       void processClass(ClassElement cls) {
         if (seenClasses.contains(cls)) return;
 
@@ skipping 11 matching lines @@
             cls, this, compiler.globalDependencies);
       }
       processClass(cls);
       for (Link<DartType> supertypes = cls.allSupertypes;
            !supertypes.isEmpty; supertypes = supertypes.tail) {
         processClass(supertypes.head.element);
       }
     });
   }
 
-  void registerNewSelector(Selector selector,
+  void registerNewSelector(Element context,
+                           Selector selector,
                            Map<String, Set<Selector>> selectorsMap) {
     String name = selector.name;
     Set<Selector> selectors =
         selectorsMap.putIfAbsent(name, () => new Setlet<Selector>());
     if (!selectors.contains(selector)) {
       selectors.add(selector);
-      handleUnseenSelector(name, selector);
+      handleUnseenSelector(context, name, selector);
     }
   }
 
-  void registerInvocation(Selector selector) {
+  void registerInvocation(Element context, Selector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedNames);
+      registerNewSelector(context, selector, universe.invokedNames);
     });
   }
 
-  void registerInvokedGetter(Selector selector) {
+  void registerInvokedGetter(Element context, Selector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedGetters);
+      registerNewSelector(context, selector, universe.invokedGetters);
     });
   }
 
-  void registerInvokedSetter(Selector selector) {
+  void registerInvokedSetter(Element context, Selector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedSetters);
+      registerNewSelector(context, selector, universe.invokedSetters);
     });
   }
 
   /**
    * 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.
    */
@@ skipping 32 matching lines @@
         // Do not enqueue typedefs.
         && !element.impliesType) {
       logEnqueueReflectiveAction(element);
       if (Elements.isStaticOrTopLevel(element)) {
         registerStaticUse(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
         Selector selector = new Selector.fromElement(element, compiler);
-        registerSelectorUse(selector);
+        registerSelectorUse(element, selector);
         if (element.isField) {
           Selector selector =
               new Selector.setter(element.name, element.library);
-          registerInvokedSetter(selector);
+          registerInvokedSetter(element, 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 116 matching lines @@
   }
 
   processInstanceMembers(String n, bool f(Element e)) {
     processLink(instanceMembersByName, n, f);
   }
 
   processInstanceFunctions(String n, bool f(Element e)) {
     processLink(instanceFunctionsByName, n, f);
   }
 
-  void handleUnseenSelector(String methodName, Selector selector) {
+  void handleUnseenSelector(Element context,
+                            String methodName,
+                            Selector selector) {
     processInstanceMembers(methodName, (Element member) {
+      compilationInfo.enqueues(context, member);
       if (selector.appliesUnnamed(member, compiler)) {
         if (member.isFunction && selector.isGetter) {
           registerClosurizedMember(member, compiler.globalDependencies);
         }
         if (member.isField && member.enclosingClass.isNative) {
           if (selector.isGetter || selector.isCall) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
@@ skipping 36 matching lines @@
     addToWorkList(element);
     compiler.backend.registerStaticUse(element, this);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     compiler.backend.registerGetOfStaticFunction(this);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
-  void registerDynamicInvocation(Selector selector) {
+  void registerDynamicInvocation(Element context, Selector selector) {
     assert(selector != null);
-    registerInvocation(selector);
+    registerInvocation(context, selector);
   }
 
-  void registerSelectorUse(Selector selector) {
+  void registerSelectorUse(Element context, Selector selector) {
     if (selector.isGetter) {
-      registerInvokedGetter(selector);
+      registerInvokedGetter(context, selector);
     } else if (selector.isSetter) {
-      registerInvokedSetter(selector);
+      registerInvokedSetter(context, selector);
     } else {
-      registerInvocation(selector);
+      registerInvocation(context, selector);
     }
   }
 
-  void registerDynamicGetter(Selector selector) {
-    registerInvokedGetter(selector);
+  void registerDynamicGetter(Element context, Selector selector) {
+    registerInvokedGetter(context, selector);
   }
 
-  void registerDynamicSetter(Selector selector) {
-    registerInvokedSetter(selector);
+  void registerDynamicSetter(Element context, Selector selector) {
+    registerInvokedSetter(context, selector);
   }
 
   void registerGetterForSuperMethod(Element element) {
     universe.methodsNeedingSuperGetter.add(element);
   }
 
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
 
@@ skipping 87 matching lines @@
   final Set<AstElement> resolvedElements;
 
   final Queue<ResolutionWorkItem> queue;
 
   /**
    * A deferred task queue for the resolution phase which is processed
    * when the resolution queue has been emptied.
    */
   final Queue<DeferredTask> deferredTaskQueue;
 
+  CompilationInformation compilationInfo;
+
   ResolutionEnqueuer(Compiler compiler,
                      ItemCompilationContext itemCompilationContextCreator())
       : super('resolution enqueuer', compiler, itemCompilationContextCreator),
         resolvedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
-        deferredTaskQueue = new Queue<DeferredTask>();
+        deferredTaskQueue = new Queue<DeferredTask>() {
+    compilationInfo = new CompilationInformation(this);
+  }
 
   bool get isResolutionQueue => true;
 
   bool isProcessed(Element member) => resolvedElements.contains(member);
 
   /// Returns `true` if [element] has been processed by the resolution enqueuer.
   bool hasBeenResolved(Element element) {
     return resolvedElements.contains(element.analyzableElement.declaration);
   }
 
@@ skipping 15 matching lines @@
    *
    * During resolution, we have to resort to matching elements against the
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
                                         {bool includedEnclosing}) {
     return includedEnclosing || compiler.backend.requiredByMirrorSystem(element);
   }
 
-  void internalAddToWorkList(Element element) {
+  bool internalAddToWorkList(Element element) {
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
-    if (hasBeenResolved(element)) return;
+    if (hasBeenResolved(element)) return false;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Resolution work list is closed. Trying to add $element.");
     }
 
     compiler.world.registerUsedElement(element);
 
     queue.add(new ResolutionWorkItem(element, itemCompilationContextCreator()));
 
     // Enable isolate support if we start using something from the isolate
@@ skipping 21 matching lines @@
       // that constructors know whether they need to generate code for
       // runtime type.
       compiler.enabledRuntimeType = true;
       // TODO(ahe): Record precise dependency here.
       compiler.backend.registerRuntimeType(this, compiler.globalDependencies);
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     }
 
     nativeEnqueuer.registerElement(element);
+    return true;
   }
 
   void enableIsolateSupport() {
     compiler.hasIsolateSupport = true;
     compiler.backend.enableIsolateSupport(this);
   }
 
   void enableNoSuchMethod(Element element) {
     if (compiler.enabledNoSuchMethod) return;
     if (compiler.backend.isDefaultNoSuchMethodImplementation(element)) return;
 
     Selector selector = compiler.noSuchMethodSelector;
     compiler.enabledNoSuchMethod = true;
-    compiler.backend.enableNoSuchMethod(this);
+    compiler.backend.enableNoSuchMethod(element, this);
   }
 
   /**
    * Adds an action to the deferred task queue.
    *
    * The action is performed the next time the resolution queue has been
    * emptied.
    *
    * The queue is processed in FIFO order.
    */
@@ skipping 28 matching lines @@
 }
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends Enqueuer {
   final Queue<CodegenWorkItem> queue;
   final Map<Element, js.Expression> generatedCode =
       new Map<Element, js.Expression>();
 
   final Set<Element> newlyEnqueuedElements;
 
+  CompilationInformation compilationInfo;
+
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
-        super('codegen enqueuer', compiler, itemCompilationContextCreator);
+        super('codegen enqueuer', compiler, itemCompilationContextCreator) {
+    compilationInfo = new CompilationInformation(this);
+  }
 
   bool isProcessed(Element member) =>
       member.isAbstract || generatedCode.containsKey(member);
 
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system.
    *
    * For code generation, we rely on the precomputed set of elements that takes
    * subtyping constraints into account.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
                                         {bool includedEnclosing}) {
     return compiler.backend.isAccessibleByReflection(element);
   }
 
-  void internalAddToWorkList(Element element) {
+  bool internalAddToWorkList(Element element) {
     if (compiler.hasIncrementalSupport) {
       newlyEnqueuedElements.add(element);
     }
     // Don't generate code for foreign elements.
-    if (element.isForeign(compiler)) return;
+    if (element.isForeign(compiler)) return false;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
       if (!compiler.enableTypeAssertions
           || element.enclosingElement.isClosure) {
-        return;
+        return false;
       }
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Codegen work list is closed. Trying to add $element");
     }
     CodegenWorkItem workItem = new CodegenWorkItem(
         element, itemCompilationContextCreator());
     queue.add(workItem);
+    return true;
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }
 
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
     enqueuer.task.measure(() {
       // Run through the classes and see if we need to compile methods.
       for (ClassElement classElement in enqueuer.universe.instantiatedClasses) {
         for (ClassElement currentClass = classElement;
              currentClass != null;
              currentClass = currentClass.superclass) {
           enqueuer.processInstantiatedClass(currentClass);
         }
       }
     });
     return true;
   }
 
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }