Remove calls to registerDependency from within resolution.

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

 
 // Copyright (c) 2012, 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.common.resolution;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
@@ skipping 211 matching lines @@
 
   @override
   Iterable<UniverseSelector> get dynamicSetters {
     return _dynamicSetters != null
         ? _dynamicSetters : worldImpact.dynamicSetters;
   }
 
   @override
   Iterable<DartType> get isChecks => worldImpact.isChecks;
 
-  @override
-  Iterable<Element> get staticUses {
-    if (_staticUses == null) {
-      return worldImpact.staticUses;
-    }
-    return _staticUses;
-  }
-
   _unsupported(String message) => throw new UnsupportedError(message);
 
   void registerDynamicGetter(UniverseSelector selector) {
     if (_dynamicGetters == null) {
       _dynamicGetters = new Setlet<UniverseSelector>();
       _dynamicGetters.addAll(worldImpact.dynamicGetters);
     }
     _dynamicGetters.add(selector);
   }
 
   void registerDynamicInvocation(UniverseSelector selector) {
     if (_dynamicInvocations == null) {
       _dynamicInvocations = new Setlet<UniverseSelector>();
       _dynamicInvocations.addAll(worldImpact.dynamicInvocations);
     }
     _dynamicInvocations.add(selector);
   }
 
   void registerDynamicSetter(UniverseSelector selector) {
     if (_dynamicSetters == null) {
       _dynamicSetters = new Setlet<UniverseSelector>();
       _dynamicSetters.addAll(worldImpact.dynamicSetters);
     }
     _dynamicSetters.add(selector);
   }
 
   void registerInstantiatedType(InterfaceType type) {
-    // TODO(johnniwinther): Remove this when dependency tracking is done on
-    // the world impact itself.
-    worldImpact.registerDependency(type.element);
     if (_instantiatedTypes == null) {
       _instantiatedTypes = new Setlet<InterfaceType>();
+      _instantiatedTypes.addAll(worldImpact.instantiatedTypes);
     }
     _instantiatedTypes.add(type);
   }
 
   @override
   Iterable<InterfaceType> get instantiatedTypes {
     return _instantiatedTypes != null
-        ? _instantiatedTypes : const <InterfaceType>[];
+        ? _instantiatedTypes : worldImpact.instantiatedTypes;
   }
 
   @override
   Iterable<DartType> get typeLiterals {
     return worldImpact.typeLiterals;
   }
 
   void registerStaticUse(Element element) {
-    // TODO(johnniwinther): Remove this when dependency tracking is done on
-    // the world impact itself.
-    worldImpact.registerDependency(element);
     if (_staticUses == null) {
       _staticUses = new Setlet<Element>();
+      _staticUses.addAll(worldImpact.staticUses);
     }
     _staticUses.add(element);
   }
 
   @override
+  Iterable<Element> get staticUses {
+    return _staticUses != null ? _staticUses : worldImpact.staticUses;
+  }
+
+  @override
   Iterable<LocalFunctionElement> get closures => worldImpact.closures;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('TransformedWorldImpact($worldImpact)');
     sb.write(super.toString());
     return sb.toString();
   }
 }
 
@@ skipping 14 matching lines @@
   WorldImpact getWorldImpact(Element element);
   WorldImpact computeWorldImpact(Element element);
 }
 
 // TODO(johnniwinther): Rename to `Parser` or `ParsingContext`.
 abstract class Parsing {
   DiagnosticReporter get reporter;
   void parsePatchClass(ClassElement cls);
   measure(f());
 }