Remove Registry arguments from Enqueuer.

pkg/compiler/lib/src/enqueue.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.enqueue;
 
 import 'dart:collection' show
     Queue;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/work.dart' show
     ItemCompilationContext,
     WorkItem;
 import 'common/tasks.dart' show
     CompilerTask,
     DeferredAction,
     DeferredTask;
-import 'common/registry.dart' show
-    Registry;
 import 'common/codegen.dart' show
     CodegenWorkItem;
 import 'common/resolution.dart' show
     ResolutionWorkItem;
 import 'compiler.dart' show
     Compiler;
 import 'dart_types.dart' show
     DartType,
     InterfaceType;
 import 'diagnostics/invariant.dart' show
@@ skipping 152 matching lines @@
     worldImpact.dynamicGetters.forEach(registerDynamicGetter);
     worldImpact.dynamicSetters.forEach(registerDynamicSetter);
     worldImpact.staticUses.forEach(registerStaticUse);
     // TODO(johnniwinther): Register [worldImpact.instantiatedTypes] when it
     // doesn't require a [Registry].
     worldImpact.checkedTypes.forEach(registerIsCheck);
     worldImpact.closurizedFunctions.forEach(registerGetOfStaticFunction);
   }
 
   // TODO(johnniwinther): Remove the need for passing the [registry].
-  void registerInstantiatedType(InterfaceType type, Registry registry,
+  void registerInstantiatedType(InterfaceType type,
                                 {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
-      registry.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.registerTypeInstantiation(
           type,
           byMirrors: mirrorUsage,
           onImplemented: (ClassElement cls) {
         compiler.backend.registerImplementedClass(
                     cls, this, compiler.globalDependencies);
       });
       processInstantiatedClass(cls);
-      compiler.backend.registerInstantiatedType(type, registry);
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
 
   void processInstantiatedClassMembers(ClassElement cls) {
     strategy.processInstantiatedClass(this, cls);
   }
@@ skipping 46 matching lines @@
         return;
       }
     } else if (member.isFunction) {
       FunctionElement function = member;
       function.computeType(compiler);
       if (function.name == Identifiers.noSuchMethod_) {
         registerNoSuchMethod(function);
       }
       if (function.name == Identifiers.call &&
           !cls.typeVariables.isEmpty) {
-        registerCallMethodWithFreeTypeVariables(
-            function, compiler.globalDependencies);
+        registerCallMethodWithFreeTypeVariables(function);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(function, compiler.world)) {
-        registerClosurizedMember(function, compiler.globalDependencies);
+        registerClosurizedMember(function);
         addToWorkList(function);
         return;
       }
       // Store the member in [instanceFunctionsByName] to catch
       // getters on the function.
       instanceFunctionsByName.putIfAbsent(memberName, () => new Set<Element>())
           .add(member);
       if (universe.hasInvocation(function, compiler.world)) {
         addToWorkList(function);
         return;
@@ skipping 104 matching lines @@
   /// Enqeue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveConstructor(ConstructorElement ctor,
                                     bool enclosingWasIncluded) {
     if (shouldIncludeElementDueToMirrors(ctor,
         includedEnclosing: enclosingWasIncluded)) {
       logEnqueueReflectiveAction(ctor);
       ClassElement cls = ctor.declaration.enclosingClass;
-      registerInstantiatedType(cls.rawType, compiler.mirrorDependencies,
+      compiler.backend.registerInstantiatedType(
+          cls.rawType,
+          this,
+          compiler.mirrorDependencies,
           mirrorUsage: true);
       registerStaticUse(ctor.declaration);
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveMember(Element element, bool enclosingWasIncluded) {
@@ skipping 30 matching lines @@
   void enqueueReflectiveElementsInClass(ClassElement cls,
                                         Iterable<ClassElement> recents,
                                         bool enclosingWasIncluded) {
     if (cls.library.isInternalLibrary || cls.isInjected) return;
     bool includeClass = shouldIncludeElementDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
       logEnqueueReflectiveAction(cls, "register");
       ClassElement decl = cls.declaration;
       decl.ensureResolved(compiler);
-      registerInstantiatedType(decl.rawType, compiler.mirrorDependencies,
+      compiler.backend.registerInstantiatedType(
+          decl.rawType,
+          this,
+          compiler.mirrorDependencies,
           mirrorUsage: true);
     }
     // If the class is never instantiated, we know nothing of it can possibly
     // be reflected upon.
     // TODO(herhut): Add a warning if a mirrors annotation cannot hit.
     if (recents.contains(cls.declaration)) {
       logEnqueueReflectiveAction(cls, "members");
       cls.constructors.forEach((Element element) {
         enqueueReflectiveConstructor(element, includeClass);
       });
@@ skipping 10 matching lines @@
   /// Although it is in an internal library, we mark it as reflectable. Note
   /// that none of its methods are reflectable, unless reflectable by
   /// inheritance.
   void enqueueReflectiveSpecialClasses() {
     Iterable<ClassElement> classes =
         compiler.backend.classesRequiredForReflection;
     for (ClassElement cls in classes) {
       if (compiler.backend.referencedFromMirrorSystem(cls)) {
         logEnqueueReflectiveAction(cls);
         cls.ensureResolved(compiler);
-        registerInstantiatedType(cls.rawType, compiler.mirrorDependencies,
+        compiler.backend.registerInstantiatedType(
+            cls.rawType,
+            this,
+            compiler.mirrorDependencies,
             mirrorUsage: true);
       }
     }
   }
 
   /// Enqeue all local members of the library [lib] if they are required for
   /// reflection.
   void enqueueReflectiveElementsInLibrary(LibraryElement lib,
                                           Iterable<ClassElement> recents) {
     bool includeLibrary = shouldIncludeElementDueToMirrors(lib,
@@ skipping 77 matching lines @@
   void handleUnseenSelector(UniverseSelector universeSelector) {
     strategy.processSelector(this, universeSelector);
   }
 
   void handleUnseenSelectorInternal(UniverseSelector universeSelector) {
     Selector selector = universeSelector.selector;
     String methodName = selector.name;
     processInstanceMembers(methodName, (Element member) {
       if (universeSelector.appliesUnnamed(member, compiler.world)) {
         if (member.isFunction && selector.isGetter) {
-          registerClosurizedMember(member, compiler.globalDependencies);
+          registerClosurizedMember(member);
         }
         if (member.isField && member.enclosingClass.isNative) {
           if (selector.isGetter || selector.isCall) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldStore(member);
           } else {
             assert(selector.isSetter);
             nativeEnqueuer.registerFieldStore(member);
             // We have to also handle loading from the field because we only get
             // one look at each member and there might be a load we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldLoad(member);
           }
         }
         addToWorkList(member);
         return true;
       }
       return false;
     });
     if (selector.isGetter) {
       processInstanceFunctions(methodName, (Element member) {
         if (universeSelector.appliesUnnamed(member, compiler.world)) {
-          registerClosurizedMember(member, compiler.globalDependencies);
+          registerClosurizedMember(member);
           return true;
         }
         return false;
       });
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 57 matching lines @@
 
   void registerIsCheck(DartType type) {
     type = universe.registerIsCheck(type, compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(!type.isTypeVariable ||
            !type.element.enclosingElement.isTypedef);
   }
 
-  void registerCallMethodWithFreeTypeVariables(
-      Element element,
-      Registry registry) {
+  void registerCallMethodWithFreeTypeVariables(Element element) {
     compiler.backend.registerCallMethodWithFreeTypeVariables(
-        element, this, registry);
+        element, this, compiler.globalDependencies);
     universe.callMethodsWithFreeTypeVariables.add(element);
   }
 
-  void registerClosurizedMember(TypedElement element, Registry registry) {
+  void registerClosurizedMember(TypedElement element) {
     assert(element.isInstanceMember);
-    registerClosureIfFreeTypeVariables(element, registry);
+    if (element.computeType(compiler).containsTypeVariables) {
+      compiler.backend.registerClosureWithFreeTypeVariables(
+          element, this, compiler.globalDependencies);
+    }
     compiler.backend.registerBoundClosure(this);
     universe.closurizedMembers.add(element);
   }
 
-  void registerClosureIfFreeTypeVariables(TypedElement element,
-                                          Registry registry) {
-    if (element.computeType(compiler).containsTypeVariables) {
-      compiler.backend.registerClosureWithFreeTypeVariables(
-          element, this, registry);
-      universe.closuresWithFreeTypeVariables.add(element);
-    }
-  }
-
-  void registerClosure(LocalFunctionElement element, Registry registry) {
+  void registerClosure(LocalFunctionElement element) {
     universe.allClosures.add(element);
-    registerClosureIfFreeTypeVariables(element, registry);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         filter.processWorkItem(f, queue.removeLast());
       }
       List recents = recentClasses.toList(growable: false);
       recentClasses.clear();
@@ skipping 349 matching lines @@
   @override
   void processStaticUse(Enqueuer enqueuer, Element element) {
     enqueuer.registerStaticUseInternal(element);
   }
 
   @override
   void processSelector(Enqueuer enqueuer, UniverseSelector selector) {
     enqueuer.handleUnseenSelectorInternal(selector);
   }
 }