Use WorldImpact for element dependencies in deferred_load

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;
 import '../common/resolution.dart' show
     Feature,
     ListLiteralUse,
     MapLiteralUse,
-    ResolutionWorldImpact;
+    ResolutionImpact;
 import '../common/registry.dart' show
     Registry;
 import '../compiler.dart' show
     Compiler;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../enqueue.dart' show
     ResolutionEnqueuer;
 import '../elements/elements.dart';
 import '../tree/tree.dart';
@@ skipping 66 matching lines @@
 
   @override
   void registerStaticInvocation(Element element) {
     registerDependency(element);
     world.registerStaticUse(element);
   }
 
   String toString() => 'EagerRegistry for ${mapping.analyzedElement}';
 }
 
-class _ResolutionWorldImpact implements ResolutionWorldImpact {
+class _ResolutionWorldImpact implements ResolutionImpact {
   final Registry registry;
   // 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<MethodElement> _closurizedFunctions;
   Setlet<LocalFunctionElement> _closures;
   Setlet<Feature> _features;
   // TODO(johnniwinther): This seems to be a union of other sets.
   Setlet<DartType> _requiredTypes;
   Setlet<MapLiteralUse> _mapLiterals;
   Setlet<ListLiteralUse> _listLiterals;
   Setlet<DartType> _typeLiterals;
   Setlet<String> _constSymbolNames;
 
   _ResolutionWorldImpact(Compiler compiler, TreeElementMapping mapping)
       : this.registry = new EagerRegistry(compiler, mapping);
 
   void registerDependency(Element element) {
+    assert(element != null);
     registry.registerDependency(element);
   }
 
   void registerDynamicGetter(UniverseSelector selector) {
+    assert(selector != null);
     if (_dynamicGetters == null) {
       _dynamicGetters = new Setlet<UniverseSelector>();
     }
     _dynamicGetters.add(selector);
   }
 
   @override
   Iterable<UniverseSelector> get dynamicGetters {
     return _dynamicGetters != null
         ? _dynamicGetters : const <UniverseSelector>[];
   }
 
   void registerDynamicInvocation(UniverseSelector selector) {
+    assert(selector != null);
     if (_dynamicInvocations == null) {
       _dynamicInvocations = new Setlet<UniverseSelector>();
     }
     _dynamicInvocations.add(selector);
   }
 
   @override
   Iterable<UniverseSelector> get dynamicInvocations {
     return _dynamicInvocations != null
         ? _dynamicInvocations : const <UniverseSelector>[];
   }
 
   void registerDynamicSetter(UniverseSelector selector) {
+    assert(selector != null);
     if (_dynamicSetters == null) {
       _dynamicSetters = new Setlet<UniverseSelector>();
     }
     _dynamicSetters.add(selector);
   }
 
   @override
   Iterable<UniverseSelector> get dynamicSetters {
     return _dynamicSetters != null
         ? _dynamicSetters : const <UniverseSelector>[];
   }
 
   void registerInstantiatedType(InterfaceType type) {
+    assert(type != null);
     if (_instantiatedTypes == null) {
       _instantiatedTypes = new Setlet<InterfaceType>();
     }
     _instantiatedTypes.add(type);
   }
 
   @override
   Iterable<InterfaceType> get instantiatedTypes {
     return _instantiatedTypes != null
         ? _instantiatedTypes : const <InterfaceType>[];
   }
 
   void registerTypeLiteral(DartType type) {
+    assert(type != null);
     if (_typeLiterals == null) {
       _typeLiterals = new Setlet<DartType>();
     }
     _typeLiterals.add(type);
   }
 
   @override
   Iterable<DartType> get typeLiterals {
     return _typeLiterals != null
         ? _typeLiterals : const <DartType>[];
   }
 
   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 {
     return _mapLiterals != null
         ? _mapLiterals : const <MapLiteralUse>[];
   }
 
   void registerListLiteral(ListLiteralUse listLiteralUse) {
+    assert(listLiteralUse != null);
     if (_listLiterals == null) {
       _listLiterals = new Setlet<ListLiteralUse>();
     }
     _listLiterals.add(listLiteralUse);
   }
 
   @override
   Iterable<ListLiteralUse> get listLiterals {
     return _listLiterals != null
         ? _listLiterals : const <ListLiteralUse>[];
   }
 
   void registerStaticUse(Element element) {
+    assert(element != null);
     if (_staticUses == null) {
       _staticUses = new Setlet<Element>();
     }
     _staticUses.add(element);
   }
 
   @override
   Iterable<Element> get staticUses {
     return _staticUses != null ? _staticUses : const <Element>[];
   }
 
   void registerIsCheck(DartType type) {
+    assert(type != null);
     if (_isChecks == null) {
       _isChecks = new Setlet<DartType>();
     }
     _isChecks.add(type);
   }
 
   @override
   Iterable<DartType> get isChecks {
     return _isChecks != null
         ? _isChecks : const <DartType>[];
@@ skipping 522 matching lines @@
   @override
   void registerInstantiatedType(InterfaceType type) {
     registry.registerInstantiatedType(type);
   }
 
   @override
   DartType resolveTypeFromString(Node node, String typeName) {
     return visitor.resolveTypeFromString(node, typeName);
   }
 }