Add support for analyzing individual URIs.

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/names.dart' show
@@ skipping 50 matching lines @@
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
     : resolution = new ResolutionEnqueuer(
-          compiler, compiler.backend.createItemCompilationContext),
+          compiler, compiler.backend.createItemCompilationContext,
+          compiler.analyzeOnly && compiler.analyzeMain
+              ? const EnqueuerStrategy() : const TreeShakingEnqueuerStrategy()),
       codegen = new CodegenEnqueuer(
-          compiler, compiler.backend.createItemCompilationContext),
+          compiler, compiler.backend.createItemCompilationContext,
+          const TreeShakingEnqueuerStrategy()),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
 
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 
   void forgetElement(Element element) {
@@ skipping 20 matching lines @@
   // TODO(johnniwinther): Collect checked types for checked mode separately to
   // support serialization.
   Iterable<DartType> get checkedTypes => const <DartType>[];
 
   Iterable<MethodElement> get closurizedFunctions => const <MethodElement>[];
 }
 
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
+  final EnqueuerStrategy strategy;
   final ItemCompilationContextCreator itemCompilationContextCreator;
   final Map<String, Set<Element>> instanceMembersByName
       = new Map<String, Set<Element>>();
   final Map<String, Set<Element>> instanceFunctionsByName
       = new Map<String, Set<Element>>();
   final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> recentClasses = new Setlet<ClassElement>();
   final Universe universe = new Universe();
 
   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;
 
-  Enqueuer(this.name, this.compiler, this.itemCompilationContextCreator);
+  Enqueuer(this.name,
+           this.compiler,
+           this.itemCompilationContextCreator,
+           this.strategy);
 
   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.
@@ skipping 45 matching lines @@
       processInstantiatedClass(cls);
       compiler.backend.registerInstantiatedType(type, registry);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
 
   void processInstantiatedClassMembers(ClassElement cls) {
-    cls.implementation.forEachMember(processInstantiatedClassMember);
+    strategy.processInstantiatedClass(this, cls);
   }
 
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
     if (!member.isInstanceMember) return;
     String memberName = member.name;
 
     if (member.isField) {
       // The obvious thing to test here would be "member.isNative",
@@ skipping 339 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);
+  }
+
+  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, compiler.globalDependencies);
         }
         if (member.isField && member.enclosingClass.isNative) {
           if (selector.isGetter || selector.isCall) {
             nativeEnqueuer.registerFieldLoad(member);
@@ skipping 28 matching lines @@
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void registerStaticUse(Element element) {
     if (element == null) return;
+    strategy.processStaticUse(this, element);
+  }
+
+  void registerStaticUseInternal(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     if (Elements.isStaticOrTopLevel(element) && element.isField) {
       universe.registerStaticFieldUse(element);
     }
     addToWorkList(element);
     compiler.backend.registerStaticUse(element, this);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
@@ skipping 125 matching lines @@
 
   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;
 
   ResolutionEnqueuer(Compiler compiler,
-                     ItemCompilationContext itemCompilationContextCreator())
-      : super('resolution enqueuer', compiler, itemCompilationContextCreator),
+                     ItemCompilationContext itemCompilationContextCreator(),
+                     EnqueuerStrategy strategy)
+      : super('resolution enqueuer',
+              compiler,
+              itemCompilationContextCreator,
+              strategy),
         resolvedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
         deferredTaskQueue = new Queue<DeferredTask>();
 
   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) {
@@ skipping 142 matching lines @@
   final Map<Element, js.Expression> generatedCode =
       new Map<Element, js.Expression>();
 
   final Set<Element> newlyEnqueuedElements;
 
   final Set<UniverseSelector> newlySeenSelectors;
 
   bool enabledNoSuchMethod = false;
 
   CodegenEnqueuer(Compiler compiler,
-                  ItemCompilationContext itemCompilationContextCreator())
+                  ItemCompilationContext itemCompilationContextCreator(),
+                  EnqueuerStrategy strategy)
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         newlySeenSelectors = compiler.cacheStrategy.newSet(),
-        super('codegen enqueuer', compiler, itemCompilationContextCreator);
+        super('codegen enqueuer', compiler, itemCompilationContextCreator,
+              strategy);
 
   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.
@@ skipping 81 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }
+
+/// 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 selector for a call site in live code.
+  void processSelector(Enqueuer enqueuer, UniverseSelector selector) {}
+}
+
+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);
+  }
+
+  @override
+  void processSelector(Enqueuer enqueuer, UniverseSelector selector) {
+    enqueuer.handleUnseenSelectorInternal(selector);
+  }
+}