Remove WorldImpact from caches when no longer needed.

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 40 matching lines @@
 import 'universe/selector.dart' show
     Selector;
 import 'universe/universe.dart';
 import 'universe/use.dart' show
     DynamicUse,
     StaticUse,
     StaticUseKind,
     TypeUse,
     TypeUseKind;
 import 'universe/world_impact.dart' show
-    WorldImpact;
+    ImpactUse,
+    WorldImpact,
+    WorldImpactVisitor;
 import 'util/util.dart' show
     Link,
     Setlet;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 38 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;
 
+  WorldImpactVisitor impactVisitor;
+
   Enqueuer(this.name,
            this.compiler,
            this.itemCompilationContextCreator,
-           this.strategy);
+           this.strategy) {
+    impactVisitor = new _EnqueuerImpactVisitor(this);
+  }
 
   // TODO(johnniwinther): Move this to [ResolutionEnqueuer].
   Resolution get resolution => compiler.resolution;
 
   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;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   /// Returns [:true:] if [member] has been processed by this enqueuer.
   bool isProcessed(Element member);
 
   bool isClassProcessed(ClassElement cls) => _processedClasses.contains(cls);
 
   Iterable<ClassElement> get processedClasses => _processedClasses;
 
+  ImpactUse get impactUse;
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     if (internalAddToWorkList(element) && compiler.dumpInfo) {
       // TODO(sigmund): add other missing dependencies (internals, selectors
       // enqueued after allocations), also enable only for the codegen enqueuer.
       compiler.dumpInfoTask.registerDependency(
           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.
    */
   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.dynamicUses.forEach(registerDynamicUse);
-    worldImpact.staticUses.forEach(registerStaticUse);
-    worldImpact.typeUses.forEach(registerTypeUse);
+    compiler.impactStrategy.visitImpact(
+        element, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
       bool isNative = compiler.backend.isNative(cls);
       universe.registerTypeInstantiation(
           type,
@@ skipping 551 matching lines @@
   final Set<AstElement> processedElements;
 
   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;
 
+  static const ImpactUse IMPACT_USE = const ImpactUse('ResolutionEnqueuer');
+
+  ImpactUse get impactUse => IMPACT_USE;
+
   ResolutionEnqueuer(Compiler compiler,
                      ItemCompilationContext itemCompilationContextCreator(),
                      EnqueuerStrategy strategy)
       : super('resolution enqueuer',
               compiler,
               itemCompilationContextCreator,
               strategy),
         processedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
         deferredTaskQueue = new Queue<DeferredTask>();
@@ skipping 135 matching lines @@
 class CodegenEnqueuer extends Enqueuer {
   final Queue<CodegenWorkItem> queue;
   final Map<Element, js.Expression> generatedCode = <Element, js.Expression>{};
 
   final Set<Element> newlyEnqueuedElements;
 
   final Set<DynamicUse> newlySeenSelectors;
 
   bool enabledNoSuchMethod = false;
 
+  static const ImpactUse IMPACT_USE = const ImpactUse('CodegenEnqueuer');
+
+  ImpactUse get impactUse => IMPACT_USE;
+
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator(),
                   EnqueuerStrategy strategy)
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         newlySeenSelectors = compiler.cacheStrategy.newSet(),
         super('codegen enqueuer', compiler, itemCompilationContextCreator,
               strategy);
 
   bool isProcessed(Element member) =>
@@ skipping 123 matching lines @@
   @override
   void processStaticUse(Enqueuer enqueuer, StaticUse staticUse) {
     enqueuer.registerStaticUseInternal(staticUse);
   }
 
   @override
   void processDynamicUse(Enqueuer enqueuer, DynamicUse dynamicUse) {
     enqueuer.handleUnseenSelectorInternal(dynamicUse);
   }
 }
+
+class _EnqueuerImpactVisitor implements WorldImpactVisitor {
+  final Enqueuer enqueuer;
+
+  _EnqueuerImpactVisitor(this.enqueuer);
+
+  @override
+  void visitDynamicUse(DynamicUse dynamicUse) {
+    enqueuer.registerDynamicUse(dynamicUse);
+  }
+
+  @override
+  void visitStaticUse(StaticUse staticUse) {
+    enqueuer.registerStaticUse(staticUse);
+  }
+
+  @override
+  void visitTypeUse(TypeUse typeUse) {
+    enqueuer.registerTypeUse(typeUse);
+  }
+}