Remove requiredTypes

pkg/compiler/lib/src/resolution/registry.dart

 // Copyright (c) 2014, 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.resolution.registry;
 
 import '../common.dart';
 import '../common/backend_api.dart' show
     Backend,
     ForeignResolver;
@@ skipping 72 matching lines @@
   void registerStaticInvocation(Element element) {
     world.registerStaticUse(element);
   }
 
   String toString() => 'EagerRegistry for ${mapping.analyzedElement}';
 }
 
 class _ResolutionWorldImpact extends ResolutionImpact with WorldImpactBuilder {
   final String name;
   Setlet<Feature> _features;
-  // TODO(johnniwinther): This seems to be a union of other sets.
-  Setlet<DartType> _requiredTypes;
   Setlet<MapLiteralUse> _mapLiterals;
   Setlet<ListLiteralUse> _listLiterals;
   Setlet<String> _constSymbolNames;
 
   _ResolutionWorldImpact(this.name);
 
-  void registerRequiredType(DartType type) {
-    assert(type != null);
-    if (_requiredTypes == null) {
-      _requiredTypes = new Setlet<DartType>();
-    }
-    _requiredTypes.add(type);
-  }
-
-  @override
-  Iterable<DartType> get requiredTypes {
-    return _requiredTypes != null
-        ? _requiredTypes : const <DartType>[];
-  }
-
   void registerMapLiteral(MapLiteralUse mapLiteralUse) {
     assert(mapLiteralUse != null);
     if (_mapLiterals == null) {
       _mapLiterals = new Setlet<MapLiteralUse>();
     }
     _mapLiterals.add(mapLiteralUse);
   }
 
   @override
   Iterable<MapLiteralUse> get mapLiterals {
@@ skipping 237 matching lines @@
   //////////////////////////////////////////////////////////////////////////////
 
   void registerStaticUse(Element element) {
     worldImpact.registerStaticUse(element);
   }
 
   void registerImplicitSuperCall(FunctionElement superConstructor) {
     registerStaticUse(superConstructor);
   }
 
-  // TODO(johnniwinther): Remove this.
-  // Use [registerInstantiatedType] of `rawType` instead.
-  @deprecated
-  void registerInstantiatedClass(ClassElement element) {
-    element.ensureResolved(compiler.resolution);
-    registerInstantiatedType(element.rawType);
-  }
-
   void registerLazyField() {
     worldImpact.registerFeature(Feature.LAZY_FIELD);
   }
 
   void registerMetadataConstant(MetadataAnnotation metadata) {
     backend.registerMetadataConstant(metadata, metadata.annotatedElement, this);
   }
 
   void registerThrowRuntimeError() {
     worldImpact.registerFeature(Feature.THROW_RUNTIME_ERROR);
   }
 
   void registerCompileTimeError(ErroneousElement error) {
     worldImpact.registerFeature(Feature.COMPILE_TIME_ERROR);
   }
 
   void registerTypeVariableBoundCheck() {
     worldImpact.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
   }
 
   void registerThrowNoSuchMethod() {
     worldImpact.registerFeature(Feature.THROW_NO_SUCH_METHOD);
   }
 
   /// Register a checked mode check against [type].
   void registerCheckedModeCheck(DartType type) {
     worldImpact.registerCheckedModeCheckedType(type);
-    mapping.addRequiredType(type);
+  }
+
+  /// Register an on-catch clause of [type].
+  void registerOnCatchType(DartType type) {
+    worldImpact.registerOnCatchType(type);
   }
 
   /// Register an is-test or is-not-test of [type].
   void registerIsCheck(DartType type) {
     worldImpact.registerIsCheck(type);
-    mapping.addRequiredType(type);
   }
 
   /// Register an as-cast of [type].
   void registerAsCast(DartType type) {
     worldImpact.registerAsCast(type);
-    mapping.addRequiredType(type);
   }
 
   void registerClosure(LocalFunctionElement element) {
     worldImpact.registerClosure(element);
   }
 
   void registerSuperUse(Node node) {
     mapping.addSuperUse(node);
   }
 
@@ skipping 54 matching lines @@
   void registerConstSymbol(String name) {
     worldImpact.registerConstSymbolName(name);
   }
 
   void registerSymbolConstructor() {
     worldImpact.registerFeature(Feature.SYMBOL_CONSTRUCTOR);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     worldImpact.registerInstantiatedType(type);
-    mapping.addRequiredType(type);
   }
 
   void registerAbstractClassInstantiation() {
     worldImpact.registerFeature(Feature.ABSTRACT_CLASS_INSTANTIATION);
   }
 
-  void registerRequiredType(DartType type, Element enclosingElement) {
-    worldImpact.registerRequiredType(type);
-    mapping.addRequiredType(type);
-  }
-
   void registerStringInterpolation() {
     worldImpact.registerFeature(Feature.STRING_INTERPOLATION);
   }
 
   void registerFallThroughError() {
     worldImpact.registerFeature(Feature.FALL_THROUGH_ERROR);
   }
 
   void registerCatchStatement() {
     worldImpact.registerFeature(Feature.CATCH_STATEMENT);
@@ skipping 88 matching lines @@
   @override
   void registerInstantiatedType(InterfaceType type) {
     registry.registerInstantiatedType(type);
   }
 
   @override
   DartType resolveTypeFromString(Node node, String typeName) {
     return visitor.resolveTypeFromString(node, typeName);
   }
 }