Remove WorldImpact from caches when no longer needed.

pkg/compiler/lib/src/universe/world_impact.dart

 // Copyright (c) 2015, 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.universe.world_impact;
 
 import '../dart_types.dart' show
     DartType,
     InterfaceType;
 import '../elements/elements.dart' show
@@ skipping 16 matching lines @@
 
   Iterable<StaticUse> get staticUses => const <StaticUse>[];
 
   // TODO(johnniwinther): Replace this by called constructors with type
   // arguments.
   // TODO(johnniwinther): Collect all checked types for checked mode separately
   // to support serialization.
 
   Iterable<TypeUse> get typeUses => const <TypeUse>[];
 
+  void apply(WorldImpactVisitor visitor) {
+    staticUses.forEach(visitor.visitStaticUse);
+    dynamicUses.forEach(visitor.visitDynamicUse);
+    typeUses.forEach(visitor.visitTypeUse);
+  }
+
   String toString() => dump(this);
 
   static String dump(WorldImpact worldImpact) {
     StringBuffer sb = new StringBuffer();
     printOn(sb, worldImpact);
     return sb.toString();
   }
 
   static void printOn(StringBuffer sb, WorldImpact worldImpact) {
     void add(String title, Iterable iterable) {
@@ skipping 100 matching lines @@
       _staticUses.addAll(worldImpact.staticUses);
     }
     _staticUses.add(staticUse);
   }
 
   @override
   Iterable<StaticUse> get staticUses {
     return _staticUses != null ? _staticUses : worldImpact.staticUses;
   }
 
+  void apply(WorldImpactVisitor visitor) {
+    staticUses.forEach(visitor.visitStaticUse);
+    dynamicUses.forEach(visitor.visitDynamicUse);
+    typeUses.forEach(visitor.visitTypeUse);
+  }
+
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('TransformedWorldImpact($worldImpact)');
     WorldImpact.printOn(sb, this);
     return sb.toString();
   }
 }
+
+/// Constant used to denote a specific use of a [WorldImpact].
+class ImpactUseCase {
+  final String name;
+
+  const ImpactUseCase(this.name);
+
+  String toString() => 'ImpactUseCase($name)';
+}
+
+/// Strategy used for processing [WorldImpact] object in various use cases.
+class ImpactStrategy {
+  const ImpactStrategy();
+
+  /// Applies [impact] to [visitor] for the [impactUseCase] of [element].
+  void visitImpact(Element element,
+                   WorldImpact impact,
+                   WorldImpactVisitor visitor,
+                   ImpactUseCase impactUseCase) {
+    // Apply unconditionally.
+    impact.apply(visitor);
+  }
+
+  /// Notifies the strategy that no more impacts of [impactUseCase] will be
+  /// applied.
+  void onImpactUsed(ImpactUseCase impactUseCase) {
+    // Do nothing.
+  }
+}
+
+/// Visitor used to process the uses of a [WorldImpact].
+abstract class WorldImpactVisitor {
+  void visitStaticUse(StaticUse staticUse);
+  void visitDynamicUse(DynamicUse dynamicUse);
+  void visitTypeUse(TypeUse typeUse);
+}
+
+// TODO(johnniwinther): Remove these when we get anonymous local classes.
+typedef void VisitUse<U>(U use);
+
+class WorldImpactVisitorImpl implements WorldImpactVisitor {
+  final VisitUse<StaticUse> _visitStaticUse;
+  final VisitUse<DynamicUse> _visitDynamicUse;
+  final VisitUse<TypeUse> _visitTypeUse;
+
+  WorldImpactVisitorImpl(
+      {VisitUse<StaticUse> visitStaticUse,
+       VisitUse<DynamicUse> visitDynamicUse,
+       VisitUse<TypeUse> visitTypeUse})
+      : _visitStaticUse = visitStaticUse,
+        _visitDynamicUse = visitDynamicUse,
+        _visitTypeUse = visitTypeUse;
+
+  @override
+  void visitStaticUse(StaticUse use) {
+    if (_visitStaticUse != null) {
+      _visitStaticUse(use);
+    }
+  }
+
+  @override
+  void visitDynamicUse(DynamicUse use) {
+    if (_visitDynamicUse != null) {
+      _visitDynamicUse(use);
+    }
+  }
+
+  @override
+  void visitTypeUse(TypeUse use) {
+    if (_visitTypeUse != null) {
+      _visitTypeUse(use);
+    }
+  }
+}
+