Better dependency tracking

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;
+  DependencyInformation get dependencyInfo;

[sra1, 2014/07/30 21:43:48]

I would remove this from the enqueuers and do it all in CodegenRegistry.

[Ty Overby (Google), 2014/08/01 16:39:38]

Done.

 
   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));
-    if (internalAddToWorkList(element)) {
-      compilationInfo.addsToWorkList(compiler.currentElement, element);
-    }
+    internalAddToWorkList(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.
    */
   bool internalAddToWorkList(Element element);
 
   void registerInstantiatedType(InterfaceType type, Registry registry,
@@ skipping 95 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 50 matching lines @@
       }
     });
   }
 
   void registerNewSelector(Element context,
                            Selector selector,
                            Map<String, Set<Selector>> selectorsMap) {
     String name = selector.name;
     Set<Selector> selectors =
         selectorsMap.putIfAbsent(name, () => new Setlet<Selector>());
+    dependencyInfo.elementUsesSelector(context, selector);

[sra1, 2014/07/30 21:43:48]

If we move this to CodegenRegistry, we can get rid of the [context] parameters
in these functions.

[Ty Overby (Google), 2014/08/01 16:39:37]

Done.

     if (!selectors.contains(selector)) {
       selectors.add(selector);
       handleUnseenSelector(context, name, selector);
     }
   }
 
   void registerInvocation(Element context, Selector selector) {
     task.measure(() {
       registerNewSelector(context, selector, universe.invokedNames);
     });
@@ skipping 198 matching lines @@
   }
 
   processInstanceFunctions(String n, bool f(Element e)) {
     processLink(instanceFunctionsByName, n, f);
   }
 
   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 164 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;
+  DependencyInformation dependencyInfo;
 
   ResolutionEnqueuer(Compiler compiler,
                      ItemCompilationContext itemCompilationContextCreator())
       : super('resolution enqueuer', compiler, itemCompilationContextCreator),
         resolvedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
         deferredTaskQueue = new Queue<DeferredTask>() {
-    compilationInfo = new CompilationInformation(this, compiler.dumpInfo);
+    dependencyInfo = new DependencyInformation(this, compiler.dumpInfo);
   }
 
   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 123 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;
+  DependencyInformation dependencyInfo;
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         super('codegen enqueuer', compiler, itemCompilationContextCreator) {
-    compilationInfo = new CompilationInformation(this, compiler.dumpInfo);
+    dependencyInfo = new DependencyInformation(this, compiler.dumpInfo);
   }
 
   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
@@ skipping 48 matching lines @@
         }
       }
     });
     return true;
   }
 
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }