Remove calls to registerDependency from within resolution.

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 61 matching lines @@
     world.registerGetOfStaticFunction(element);
   }
 
   @override
   void registerInstantiation(InterfaceType type) {
     world.registerInstantiatedType(type);
   }
 
   @override
   void registerStaticInvocation(Element element) {
-    registerDependency(element);
     world.registerStaticUse(element);
   }
 
   String toString() => 'EagerRegistry for ${mapping.analyzedElement}';
 }
 
-class _ResolutionWorldImpact implements ResolutionImpact {
-  final Registry registry;
+class _ResolutionWorldImpact extends ResolutionImpact {
+  final String name;
   // 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);
-  }
+  _ResolutionWorldImpact(this.name);
 
   void registerDynamicGetter(UniverseSelector selector) {
     assert(selector != null);
     if (_dynamicGetters == null) {
       _dynamicGetters = new Setlet<UniverseSelector>();
     }
     _dynamicGetters.add(selector);
   }
 
   @override
@@ skipping 197 matching lines @@
       _features = new Setlet<Feature>();
     }
     _features.add(feature);
   }
 
   @override
   Iterable<Feature> get features {
     return _features != null ? _features : const <Feature>[];
   }
 
-  String toString() => '$registry';
+  String toString() => '_ResolutionWorldImpact($name)';
 }
 
 /// [ResolutionRegistry] collects all resolution information. It stores node
 /// related information in a [TreeElements] mapping and registers calls with
 /// [Backend], [World] and [Enqueuer].
 // TODO(johnniwinther): Split this into an interface and implementation class.
 class ResolutionRegistry extends Registry {
   final Compiler compiler;
   final TreeElementMapping mapping;
   final _ResolutionWorldImpact worldImpact;
 
   ResolutionRegistry(Compiler compiler, TreeElementMapping mapping)
       : this.compiler = compiler,
         this.mapping = mapping,
-        this.worldImpact = new _ResolutionWorldImpact(compiler, mapping);
+        this.worldImpact = new _ResolutionWorldImpact(
+            mapping.analyzedElement.toString());
 
   bool get isForResolution => true;
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   World get universe => compiler.world;
 
   Backend get backend => compiler.backend;
 
   String toString() => 'ResolutionRegistry for ${mapping.analyzedElement}';
@@ skipping 164 matching lines @@
 
   //////////////////////////////////////////////////////////////////////////////
   //  Various Backend/Enqueuer/World registration.
   //////////////////////////////////////////////////////////////////////////////
 
   void registerStaticUse(Element element) {
     worldImpact.registerStaticUse(element);
   }
 
   void registerImplicitSuperCall(FunctionElement superConstructor) {
-    registerDependency(superConstructor);
+    registerStaticUse(superConstructor);
   }
 
   // TODO(johnniwinther): Remove this.
   // Use [registerInstantiatedType] of `rawType` instead.
   @deprecated
   void registerInstantiatedClass(ClassElement element) {
     element.ensureResolved(compiler.resolution);
     registerInstantiatedType(element.rawType);
   }
 
@@ skipping 150 matching lines @@
   void registerMixinUse(MixinApplicationElement mixinApplication,
                         ClassElement mixin) {
     universe.registerMixinUse(mixinApplication, mixin);
   }
 
   void registerThrowExpression() {
     worldImpact.registerFeature(Feature.THROW_EXPRESSION);
   }
 
   void registerStaticInvocation(Element element) {
-    // TODO(johnniwinther): Increase precision of [registerStaticUse] and
-    // [registerDependency].
+    // TODO(johnniwinther): Increase precision of [registerStaticUse].
     if (element == null) return;
     registerStaticUse(element);
   }
 
   void registerInstantiation(InterfaceType type) {
     registerInstantiatedType(type);
   }
 
   void registerAssert(bool hasMessage) {
     worldImpact.registerFeature(
@@ skipping 53 matching lines @@
   @override
   void registerInstantiatedType(InterfaceType type) {
     registry.registerInstantiatedType(type);
   }
 
   @override
   DartType resolveTypeFromString(Node node, String typeName) {
     return visitor.resolveTypeFromString(node, typeName);
   }
 }