Remove requiredTypes

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 22 matching lines @@
   Iterable<InterfaceType> get instantiatedTypes => const <InterfaceType>[];
 
   // TODO(johnniwinther): Collect checked types for checked mode separately to
   // support serialization.
   Iterable<DartType> get isChecks => const <DartType>[];
 
   Iterable<DartType> get checkedModeChecks => const <DartType>[];
 
   Iterable<DartType> get asCasts => const <DartType>[];
 
+  Iterable<DartType> get onCatchTypes => const <DartType>[];
+
   Iterable<MethodElement> get closurizedFunctions => const <MethodElement>[];
 
   Iterable<LocalFunctionElement> get closures => const <LocalFunctionElement>[];
 
   Iterable<DartType> get typeLiterals => const <DartType>[];
 
-  String toString() {
+  String toString() => dump(this);
+
+  static String dump(WorldImpact worldImpact) {
     StringBuffer sb = new StringBuffer();
-
+    printOn(sb, worldImpact);
+    return sb.toString();
+  }

[sigurdm, 2015/10/22 09:18:03]

empty line between members

[Johnni Winther, 2015/10/22 10:31:55]

Done.

+  static void printOn(StringBuffer sb, WorldImpact worldImpact) {

[sigurdm, 2015/10/22 09:18:03]

Why is this static?

[Johnni Winther, 2015/10/22 10:31:55]

So it can be required between for subclasses and subinterfaces.

     void add(String title, Iterable iterable) {
       if (iterable.isNotEmpty) {
         sb.write('\n $title:');
         iterable.forEach((e) => sb.write('\n  $e'));
       }
     }
 
-    add('dynamic invocations', dynamicInvocations);
-    add('dynamic getters', dynamicGetters);
-    add('dynamic setters', dynamicSetters);
-    add('static uses', staticUses);
-    add('instantiated types', instantiatedTypes);
-    add('is-checks', isChecks);
-    add('checked-mode checks', checkedModeChecks);
-    add('as-casts', asCasts);
-    add('closurized functions', closurizedFunctions);
-    add('closures', closures);
-    add('type literals', typeLiterals);
-
-    return sb.toString();
+    add('dynamic invocations', worldImpact.dynamicInvocations);
+    add('dynamic getters', worldImpact.dynamicGetters);
+    add('dynamic setters', worldImpact.dynamicSetters);
+    add('static uses', worldImpact.staticUses);
+    add('instantiated types', worldImpact.instantiatedTypes);
+    add('is-checks', worldImpact.isChecks);
+    add('checked-mode checks', worldImpact.checkedModeChecks);
+    add('as-casts', worldImpact.asCasts);
+    add('on-catch-types', worldImpact.onCatchTypes);
+    add('closurized functions', worldImpact.closurizedFunctions);
+    add('closures', worldImpact.closures);
+    add('type literals', worldImpact.typeLiterals);
   }
 }
 
 class WorldImpactBuilder {
   // TODO(johnniwinther): Do we benefit from lazy initialization of the
   // [Setlet]s?
   Setlet<UniverseSelector> _dynamicInvocations;
   Setlet<UniverseSelector> _dynamicGetters;
   Setlet<UniverseSelector> _dynamicSetters;
   Setlet<InterfaceType> _instantiatedTypes;
   Setlet<Element> _staticUses;
   Setlet<DartType> _isChecks;
   Setlet<DartType> _asCasts;
   Setlet<DartType> _checkedModeChecks;
+  Setlet<DartType> _onCatchTypes;
   Setlet<MethodElement> _closurizedFunctions;
   Setlet<LocalFunctionElement> _closures;
   Setlet<DartType> _typeLiterals;
 
   void registerDynamicGetter(UniverseSelector selector) {
     assert(selector != null);
     if (_dynamicGetters == null) {
       _dynamicGetters = new Setlet<UniverseSelector>();
     }
     _dynamicGetters.add(selector);
@@ skipping 98 matching lines @@
       _checkedModeChecks = new Setlet<DartType>();
     }
     _checkedModeChecks.add(type);
   }
 
   Iterable<DartType> get checkedModeChecks {
     return _checkedModeChecks != null
         ? _checkedModeChecks : const <DartType>[];
   }
 
+  void registerOnCatchType(DartType type) {
+    assert(type != null);
+    if (_onCatchTypes == null) {
+      _onCatchTypes = new Setlet<DartType>();
+    }
+    _onCatchTypes.add(type);
+  }
+
+  Iterable<DartType> get onCatchTypes {
+    return _onCatchTypes != null
+        ? _onCatchTypes : const <DartType>[];
+  }
+
   void registerClosurizedFunction(MethodElement element) {
     if (_closurizedFunctions == null) {
       _closurizedFunctions = new Setlet<MethodElement>();
     }
     _closurizedFunctions.add(element);
   }
 
   Iterable<MethodElement> get closurizedFunctions {
     return _closurizedFunctions != null
         ? _closurizedFunctions : const <MethodElement>[];
   }
 
   void registerClosure(LocalFunctionElement element) {
     if (_closures == null) {
       _closures = new Setlet<LocalFunctionElement>();
     }
     _closures.add(element);
   }
 
   Iterable<LocalFunctionElement> get closures {
     return _closures != null
         ? _closures : const <LocalFunctionElement>[];
   }
 }