Refactor enqueuers

pkg/compiler/lib/src/js_backend/enqueuer.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.js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
@@ skipping 40 matching lines @@
   final EnqueuerStrategy strategy;
   final Map<String, Set<Element>> instanceMembersByName =
       new Map<String, Set<Element>>();
   final Map<String, Set<Element>> instanceFunctionsByName =
       new Map<String, Set<Element>>();
   final Set<ClassElement> _processedClasses = new Set<ClassElement>();
   Set<ClassElement> recentClasses = new Setlet<ClassElement>();
   final CodegenWorldBuilderImpl _universe =
       new CodegenWorldBuilderImpl(const TypeMaskStrategy());
 
-  static final TRACE_MIRROR_ENQUEUING =
-      const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
 
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer; // Set by EnqueueTask
 
-  bool hasEnqueuedReflectiveElements = false;
-  bool hasEnqueuedReflectiveStaticFields = false;
 
   WorldImpactVisitor impactVisitor;
 
   CodegenEnqueuer(Compiler compiler, this.strategy)
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         newlySeenSelectors = compiler.cacheStrategy.newSet(),
         this.name = 'codegen enqueuer',
         this._compiler = compiler {
     impactVisitor = new _EnqueuerImpactVisitor(this);
   }
 
   CodegenWorldBuilder get universe => _universe;
 
   Backend get backend => _compiler.backend;
 
   CompilerOptions get options => _compiler.options;
 
-  Registry get globalDependencies => _compiler.globalDependencies;
-
-  Registry get mirrorDependencies => _compiler.mirrorDependencies;
-
   ClosedWorld get _world => _compiler.closedWorld;
 
   bool get queueIsEmpty => queue.isEmpty;
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   QueueFilter get filter => _compiler.enqueuerFilter;
 
   DiagnosticReporter get reporter => _compiler.reporter;
@@ skipping 31 matching lines @@
       _compiler.dumpInfoTask
           .registerDependency(_compiler.currentElement, element);
     }
   }
 
   void applyImpact(WorldImpact worldImpact, {Element impactSource}) {
     _compiler.impactStrategy
         .visitImpact(impactSource, worldImpact, impactVisitor, impactUse);
   }
 
-  void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false}) {
+  void registerInstantiatedType(InterfaceType type) {
+    _registerInstantiatedType(type);
+  }
+
+  void _registerInstantiatedType(InterfaceType type,
+      {bool mirrorUsage: false, bool nativeUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       bool isNative = backend.isNative(cls);
       _universe.registerTypeInstantiation(type,
           isNative: isNative,
           byMirrors: mirrorUsage, onImplemented: (ClassElement cls) {
-        backend.registerImplementedClass(cls, this, globalDependencies);
+        backend.registerImplementedClass(cls, this);
       });
+      if (nativeUsage) {
+        nativeEnqueuer.onInstantiatedType(type);
+      }
+      backend.registerInstantiatedType(type);
       // TODO(johnniwinther): Share this reasoning with [Universe].
       if (!cls.isAbstract || isNative || mirrorUsage) {
         processInstantiatedClass(cls);
       }
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
   }
@@ skipping 105 matching lines @@
               message: "Class $superclass has not been "
                        "processed in resolution."));
         */
 
         _processedClasses.add(superclass);
         recentClasses.add(superclass);
         superclass.implementation.forEachMember(processInstantiatedClassMember);
         // We only tell the backend once that [superclass] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
-        backend.registerInstantiatedClass(superclass, this, globalDependencies);
+        backend.registerInstantiatedClass(superclass, this);
       }
 
       ClassElement superclass = cls;
       while (superclass != null) {
         processClass(superclass);
         superclass = superclass.superclass;
       }
     });
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     task.measure(() {
       if (_universe.registerDynamicUse(dynamicUse)) {
         handleUnseenSelector(dynamicUse);
       }
     });
   }
 
-  void logEnqueueReflectiveAction(action, [msg = ""]) {
-    if (TRACE_MIRROR_ENQUEUING) {
-      print("MIRROR_ENQUEUE (C): $action $msg");
-    }
-  }
-
-  /// 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;
-      backend.registerInstantiatedType(cls.rawType, this, mirrorDependencies,
-          mirrorUsage: true);
-      registerStaticUse(new StaticUse.foreignUse(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) {
-    if (shouldIncludeElementDueToMirrors(element,
-        includedEnclosing: enclosingWasIncluded)) {
-      logEnqueueReflectiveAction(element);
-      if (element.isTypedef) {
-        // Do nothing.
-      } else if (Elements.isStaticOrTopLevel(element)) {
-        registerStaticUse(new StaticUse.foreignUse(element.declaration));
-      } else if (element.isInstanceMember) {
-        // We need to enqueue all members matching this one in subclasses, as
-        // well.
-        // TODO(herhut): Use TypedSelector.subtype for enqueueing
-        DynamicUse dynamicUse =
-            new DynamicUse(new Selector.fromElement(element), null);
-        registerDynamicUse(dynamicUse);
-        if (element.isField) {
-          DynamicUse dynamicUse = new DynamicUse(
-              new Selector.setter(
-                  new Name(element.name, element.library, isSetter: true)),
-              null);
-          registerDynamicUse(dynamicUse);
-        }
-      }
-    }
-  }
-
-  /// Enqeue the member [element] if it is required for reflection.
-  ///
-  /// [enclosingWasIncluded] provides a hint whether the enclosing element was
-  /// needed for reflection.
-  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;
-      backend.registerInstantiatedType(decl.rawType, this, 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);
-      });
-      cls.forEachClassMember((Member member) {
-        enqueueReflectiveMember(member.element, includeClass);
-      });
-    }
-  }
-
-  /// Enqeue special classes that might not be visible by normal means or that
-  /// would not normally be enqueued:
-  ///
-  /// [Closure] is treated specially as it is the superclass of all closures.
-  /// 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 = backend.classesRequiredForReflection;
-    for (ClassElement cls in classes) {
-      if (backend.referencedFromMirrorSystem(cls)) {
-        logEnqueueReflectiveAction(cls);
-        backend.registerInstantiatedType(cls.rawType, this, 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, includedEnclosing: false);
-    lib.forEachLocalMember((Element member) {
-      if (member.isInjected) return;
-      if (member.isClass) {
-        enqueueReflectiveElementsInClass(member, recents, includeLibrary);
-      } else {
-        enqueueReflectiveMember(member, includeLibrary);
-      }
-    });
-  }
-
-  /// Enqueue all elements that are matched by the mirrors used
-  /// annotation or, in lack thereof, all elements.
-  void enqueueReflectiveElements(Iterable<ClassElement> recents) {
-    if (!hasEnqueuedReflectiveElements) {
-      logEnqueueReflectiveAction("!START enqueueAll");
-      // First round of enqueuing, visit everything that is visible to
-      // also pick up static top levels, etc.
-      // Also, during the first round, consider all classes that have been seen
-      // as recently seen, as we do not know how many rounds of resolution might
-      // have run before tree shaking is disabled and thus everything is
-      // enqueued.
-      recents = _processedClasses.toSet();
-      reporter.log('Enqueuing everything');
-      for (LibraryElement lib in _compiler.libraryLoader.libraries) {
-        enqueueReflectiveElementsInLibrary(lib, recents);
-      }
-      enqueueReflectiveSpecialClasses();
-      hasEnqueuedReflectiveElements = true;
-      hasEnqueuedReflectiveStaticFields = true;
-      logEnqueueReflectiveAction("!DONE enqueueAll");
-    } else if (recents.isNotEmpty) {
-      // Keep looking at new classes until fixpoint is reached.
-      logEnqueueReflectiveAction("!START enqueueRecents");
-      recents.forEach((ClassElement cls) {
-        enqueueReflectiveElementsInClass(
-            cls,
-            recents,
-            shouldIncludeElementDueToMirrors(cls.library,
-                includedEnclosing: false));
-      });
-      logEnqueueReflectiveAction("!DONE enqueueRecents");
-    }
-  }
-
-  /// Enqueue the static fields that have been marked as used by reflective
-  /// usage through `MirrorsUsed`.
-  void enqueueReflectiveStaticFields(Iterable<Element> elements) {
-    if (hasEnqueuedReflectiveStaticFields) return;
-    hasEnqueuedReflectiveStaticFields = true;
-    for (Element element in elements) {
-      enqueueReflectiveMember(element, true);
-    }
-  }
-
   void processSet(
       Map<String, Set<Element>> map, String memberName, bool f(Element e)) {
     Set<Element> members = map[memberName];
     if (members == null) return;
     // [f] might add elements to [: map[memberName] :] during the loop below
     // so we create a new list for [: map[memberName] :] and prepend the
     // [remaining] members after the loop.
     map[memberName] = new Set<Element>();
     Set<Element> remaining = new Set<Element>();
     for (Element member in members) {
@@ skipping 45 matching lines @@
    */
   void registerStaticUse(StaticUse staticUse) {
     strategy.processStaticUse(this, staticUse);
   }
 
   void registerStaticUseInternal(StaticUse staticUse) {
     Element element = staticUse.element;
     assert(invariant(element, element.isDeclaration,
         message: "Element ${element} is not the declaration."));
     _universe.registerStaticUse(staticUse);
-    backend.registerStaticUse(element, forResolution: false);
+    backend.registerStaticUse(this, element);
     bool addElement = true;
     switch (staticUse.kind) {
       case StaticUseKind.STATIC_TEAR_OFF:
         backend.registerGetOfStaticFunction(this);
         break;
       case StaticUseKind.FIELD_GET:
       case StaticUseKind.FIELD_SET:
       case StaticUseKind.CLOSURE:
         // TODO(johnniwinther): Avoid this. Currently [FIELD_GET] and
         // [FIELD_SET] contains [BoxFieldElement]s which we cannot enqueue.
@@ skipping 15 matching lines @@
     }
     if (addElement) {
       addToWorkList(element);
     }
   }
 
   void registerTypeUse(TypeUse typeUse) {
     DartType type = typeUse.type;
     switch (typeUse.kind) {
       case TypeUseKind.INSTANTIATION:
-        registerInstantiatedType(type);
+        _registerInstantiatedType(type);
+        break;
+      case TypeUseKind.MIRROR_INSTANTIATION:
+        _registerInstantiatedType(type, mirrorUsage: true);
+        break;
+      case TypeUseKind.NATIVE_INSTANTIATION:
+        _registerInstantiatedType(type, nativeUsage: true);
         break;
       case TypeUseKind.IS_CHECK:
       case TypeUseKind.AS_CAST:
       case TypeUseKind.CATCH_TYPE:
         _registerIsCheck(type);
         break;
       case TypeUseKind.CHECKED_MODE_CHECK:
         if (options.enableTypeAssertions) {
           _registerIsCheck(type);
         }
         break;
       case TypeUseKind.TYPE_LITERAL:
         break;
     }
   }
 
   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) {
-    backend.registerCallMethodWithFreeTypeVariables(
-        element, this, globalDependencies);
+    backend.registerCallMethodWithFreeTypeVariables(element, this);
   }
 
   void registerClosurizedMember(TypedElement element) {
     assert(element.isInstanceMember);
     if (element.type.containsTypeVariables) {
-      backend.registerClosureWithFreeTypeVariables(
-          element, this, globalDependencies);
+      backend.registerClosureWithFreeTypeVariables(element, this);
     }
     backend.registerBoundClosure(this);
   }
 
   void forEach(void f(WorkItem work)) {
     do {
       while (queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         filter.processWorkItem(f, queue.removeLast());
       }
@@ skipping 37 matching lines @@
   bool enabledNoSuchMethod = false;
 
   static const ImpactUseCase IMPACT_USE =
       const ImpactUseCase('CodegenEnqueuer');
 
   ImpactUseCase get impactUse => IMPACT_USE;
 
   bool isProcessed(Element member) =>
       member.isAbstract || generatedCode.containsKey(member);
 
-  /**
-   * Decides whether an element should be included to satisfy requirements
-   * of the mirror system.
-   *
-   * For code generation, we rely on the precomputed set of elements that takes
-   * subtyping constraints into account.
-   */
-  bool shouldIncludeElementDueToMirrors(Element element,
-      {bool includedEnclosing}) {
-    return backend.isAccessibleByReflection(element);
-  }
-
   void registerNoSuchMethod(Element element) {
     if (!enabledNoSuchMethod && backend.enabledNoSuchMethod) {
       backend.enableNoSuchMethod(this);
       enabledNoSuchMethod = true;
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
@@ skipping 12 matching lines @@
 
   void handleUnseenSelector(DynamicUse dynamicUse) {
     if (options.hasIncrementalSupport) {
       newlySeenSelectors.add(dynamicUse);
     }
     _handleUnseenSelector(dynamicUse);
   }
 
   @override
   Iterable<Entity> get processedEntities => generatedCode.keys;
+
+  @override
+  Iterable<ClassElement> get processedClasses => _processedClasses;
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }
 
 class _EnqueuerImpactVisitor implements WorldImpactVisitor {
   final CodegenEnqueuer enqueuer;
 
   _EnqueuerImpactVisitor(this.enqueuer);
 
   @override
   void visitDynamicUse(DynamicUse dynamicUse) {
     enqueuer.registerDynamicUse(dynamicUse);
   }
 
   @override
   void visitStaticUse(StaticUse staticUse) {
     enqueuer.registerStaticUse(staticUse);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.registerTypeUse(typeUse);
   }
 }