Move towards using WorldImpact for codegen

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 '../elements/elements.dart' show Element;
 import '../util/util.dart' show Setlet;
 import 'use.dart' show DynamicUse, StaticUse, TypeUse;
 
@@ skipping 43 matching lines @@
         iterable.forEach((e) => sb.write('\n  $e'));
       }
     }
 
     add('dynamic uses', worldImpact.dynamicUses);
     add('static uses', worldImpact.staticUses);
     add('type uses', worldImpact.typeUses);
   }
 }
 
-class WorldImpactBuilder {
+abstract class WorldImpactBuilder {
+  void registerDynamicUse(DynamicUse dynamicUse);
+  void registerTypeUse(TypeUse typeUse);
+  void registerStaticUse(StaticUse staticUse);
+}
+
+class WorldImpactBuilderImpl extends WorldImpact implements WorldImpactBuilder {
   // TODO(johnniwinther): Do we benefit from lazy initialization of the
   // [Setlet]s?
-  Setlet<DynamicUse> _dynamicUses;
-  Setlet<StaticUse> _staticUses;
-  Setlet<TypeUse> _typeUses;
+  Set<DynamicUse> _dynamicUses;
+  Set<StaticUse> _staticUses;
+  Set<TypeUse> _typeUses;
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     assert(dynamicUse != null);
     if (_dynamicUses == null) {
       _dynamicUses = new Setlet<DynamicUse>();
     }
     _dynamicUses.add(dynamicUse);
   }
 
   Iterable<DynamicUse> get dynamicUses {
@@ skipping 18 matching lines @@
       _staticUses = new Setlet<StaticUse>();
     }
     _staticUses.add(staticUse);
   }
 
   Iterable<StaticUse> get staticUses {
     return _staticUses != null ? _staticUses : const <StaticUse>[];
   }
 }
 
+/// [WorldImpactBuilder] that can create and collect a sequence of
+/// [WorldImpact]s.
+class StagedWorldImpactBuilder implements WorldImpactBuilder {
+  final bool collectImpacts;
+  WorldImpactBuilderImpl _currentBuilder;
+  List<WorldImpactBuilderImpl> _builders = <WorldImpactBuilderImpl>[];
+
+  StagedWorldImpactBuilder({this.collectImpacts: false});
+
+  void _ensureBuilder() {
+    if (_currentBuilder == null) {
+      _currentBuilder = new WorldImpactBuilderImpl();
+      if (collectImpacts) {
+        _builders.add(_currentBuilder);
+      }
+    }
+  }
+
+  @override
+  void registerTypeUse(TypeUse typeUse) {
+    _ensureBuilder();
+    _currentBuilder.registerTypeUse(typeUse);
+  }
+
+  @override
+  void registerDynamicUse(DynamicUse dynamicUse) {
+    _ensureBuilder();
+    _currentBuilder.registerDynamicUse(dynamicUse);
+  }
+
+  @override
+  void registerStaticUse(StaticUse staticUse) {
+    _ensureBuilder();
+    _currentBuilder.registerStaticUse(staticUse);
+  }
+
+  /// Returns the [WorldImpact] built so far with this builder. The builder
+  /// is reset, and if [collectImpacts] is `true` the impact is cached for
+  /// [worldImpacts].
+  WorldImpact flush() {
+    if (_currentBuilder == null) return const WorldImpact();
+    WorldImpact worldImpact = _currentBuilder;
+    _currentBuilder = null;
+    return worldImpact;
+  }
+
+  /// If [collectImpacts] is `true` this returns all [WorldImpact]s built with
+  /// this builder.
+  Iterable<WorldImpact> get worldImpacts => _builders;
+}
+
 /// Mutable implementation of [WorldImpact] used to transform
 /// [ResolutionImpact] or [CodegenImpact] to [WorldImpact].
-class TransformedWorldImpact implements WorldImpact {
+class TransformedWorldImpact implements WorldImpact, WorldImpactBuilder {
   final WorldImpact worldImpact;
 
   Setlet<StaticUse> _staticUses;
   Setlet<TypeUse> _typeUses;
   Setlet<DynamicUse> _dynamicUses;
 
   TransformedWorldImpact(this.worldImpact);
 
   @override
   Iterable<DynamicUse> get dynamicUses {
@@ skipping 112 matching lines @@
     }
   }
 
   @override
   void visitTypeUse(TypeUse use) {
     if (_visitTypeUse != null) {
       _visitTypeUse(use);
     }
   }
 }