Take inheritance into account when computing the elements accessible by mirrors.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
-  /// A reverse map from name to *all* elements with that name, not
-  /// just instance members of instantiated classes.
-  final Map<String, Link<Element>> allElementsByName
-      = new Map<String, Link<Element>>();
-
-  void ensureAllElementsByName() {
-    if (!allElementsByName.isEmpty) return;
-
-    void addMemberByName(Element element) {
-      element = element.declaration;
-      String name = element.name;
-      ScopeContainerElement container = null;
-      if (element.isLibrary) {
-        LibraryElement library = element;
-        container = library;
-        // TODO(ahe): Is this right?  Is this necessary?
-        name = library.getLibraryOrScriptName();
-      } else if (element.isClass) {
-        ClassElement cls = element;
-        cls.ensureResolved(compiler);
-        container = cls;
-        for (var link = cls.computeTypeParameters(compiler);
-             !link.isEmpty;
-             link = link.tail) {
-          addMemberByName(link.head.element);
-        }
-      }
-      allElementsByName[name] = allElementsByName.putIfAbsent(
-          name, () => const Link<Element>()).prepend(element);
-      if (container != null) {
-        container.forEachLocalMember(addMemberByName);
-      }
-    }
-
-    compiler.libraryLoader.libraries.forEach(addMemberByName);
-  }
-
   String get name => 'Enqueue';
 
   EnqueueTask(Compiler compiler)
     : resolution = new ResolutionEnqueuer(
           compiler, compiler.backend.createItemCompilationContext),
       codegen = new CodegenEnqueuer(
           compiler, compiler.backend.createItemCompilationContext),
       super(compiler) {
     codegen.task = this;
     resolution.task = this;
 
     codegen.nativeEnqueuer = compiler.backend.nativeCodegenEnqueuer(codegen);
     resolution.nativeEnqueuer =
         compiler.backend.nativeResolutionEnqueuer(resolution);
   }
 }
 
 abstract class Enqueuer {
   final String name;
   final Compiler compiler; // TODO(ahe): Remove this dependency.
   final ItemCompilationContextCreator itemCompilationContextCreator;
   final Map<String, Link<Element>> instanceMembersByName
       = new Map<String, Link<Element>>();
   final Map<String, Link<Element>> instanceFunctionsByName
       = new Map<String, Link<Element>>();
   final Set<ClassElement> seenClasses = new Set<ClassElement>();
+  Set<ClassElement> recentClasses = new Setlet<ClassElement>();
   final Universe universe = new Universe();
 
+  static final TRACE_MIRROR_ENQUEUING =
+      const bool.fromEnvironment("TRACE_MIRROR_ENQUEUING");
+
   bool queueIsClosed = false;
   EnqueueTask task;
   native.NativeEnqueuer nativeEnqueuer;  // Set by EnqueueTask
 
-  bool hasEnqueuedEverything = false;
+  bool hasEnqueuedReflectiveElements = false;
   bool hasEnqueuedReflectiveStaticFields = false;
 
   Enqueuer(this.name, this.compiler, this.itemCompilationContextCreator);
 
   Queue<WorkItem> get queue;
   bool get queueIsEmpty => queue.isEmpty;
 
   /// Returns [:true:] if this enqueuer is the resolution enqueuer.
   bool get isResolutionQueue => false;
 
   /// Returns [:true:] if [member] has been processed by this enqueuer.
   bool isProcessed(Element member);
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     internalAddToWorkList(element);
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
    */
   void internalAddToWorkList(Element element);
 
-  void registerInstantiatedType(InterfaceType type, Registry registry) {
+  void registerInstantiatedType(InterfaceType type, Registry registry,
+                                {mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       registry.registerDependency(cls);
       cls.ensureResolved(compiler);
       universe.instantiatedTypes.add(type);
       if (!cls.isAbstract
           // We can't use the closed-world assumption with native abstract
           // classes; a native abstract class may have non-abstract subclasses
           // not declared to the program.  Instances of these classes are
           // indistinguishable from the abstract class.
-          || cls.isNative) {
+          || cls.isNative
+          // Likewise, if this registration comes from the mirror system,
+          // all bets are off.
+          // TODO(herhut): Track classes required by mirrors seperately.
+          || mirrorUsage) {
         universe.instantiatedClasses.add(cls);
       }
       onRegisterInstantiatedClass(cls);
     });
   }
 
-  void registerInstantiatedClass(ClassElement cls, Registry registry) {
+  void registerInstantiatedClass(ClassElement cls, Registry registry,
+                                 {mirrorUsage: false}) {
     cls.ensureResolved(compiler);
-    registerInstantiatedType(cls.rawType, registry);
+    registerInstantiatedType(cls.rawType, registry, mirrorUsage: mirrorUsage);
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     task.measure(() {
       // Run through the classes and see if we need to compile methods.
       for (ClassElement classElement in universe.instantiatedClasses) {
         for (ClassElement currentClass = classElement;
              currentClass != null;
              currentClass = currentClass.superclass) {
           processInstantiatedClass(currentClass);
@@ skipping 111 matching lines @@
     task.measure(() {
       if (seenClasses.contains(cls)) return;
       // The class must be resolved to compute the set of all
       // supertypes.
       cls.ensureResolved(compiler);
 
       void processClass(ClassElement cls) {
         if (seenClasses.contains(cls)) return;
 
         seenClasses.add(cls);
+        recentClasses.add(cls);
         cls.ensureResolved(compiler);
         cls.implementation.forEachMember(processInstantiatedClassMember);
         if (isResolutionQueue) {
           compiler.resolver.checkClass(cls);
         }
         // We only tell the backend once that [cls] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
         compiler.backend.registerInstantiatedClass(
             cls, this, compiler.globalDependencies);
@@ skipping 28 matching lines @@
       registerNewSelector(selector, universe.invokedGetters);
     });
   }
 
   void registerInvokedSetter(Selector selector) {
     task.measure(() {
       registerNewSelector(selector, universe.invokedSetters);
     });
   }
 
-  void pretendElementWasUsed(Element element, Registry registry) {
-    if (!compiler.backend.isNeededForReflection(element)) return;
-    if (Elements.isUnresolved(element)) {
-      // Ignore.
-    } else if (element.isSynthesized
-               && element.library.isPlatformLibrary) {
-      // TODO(ahe): Work-around for http://dartbug.com/11205.
-    } else if (element.isConstructor) {
-      ClassElement cls = element.declaration.enclosingClass;
-      registerInstantiatedType(cls.rawType, registry);
-      registerStaticUse(element.declaration);
-    } else if (element.isClass) {
-      ClassElement cls = element.declaration;
-      registerInstantiatedClass(cls, registry);
-      // Make sure that even abstract classes are considered instantiated.
-      universe.instantiatedClasses.add(cls);
-    } else if (element.impliesType) {
-      // Don't enqueue typedefs, and type variables.
-    } else if (Elements.isStaticOrTopLevel(element)) {
-      registerStaticUse(element.declaration);
-    } else if (element.isInstanceMember) {
-      Selector selector = new Selector.fromElement(element, compiler);
-      registerSelectorUse(selector);
-      if (element.isField) {
-        Selector selector =
-            new Selector.setter(element.name, element.library);
-        registerInvokedSetter(selector);
+  /**
+   * Decides whether an element should be included to satisfy requirements
+   * of the mirror system. [includedEnclosing] provides a hint whether the
+   * enclosing element was included.
+   *
+   * The actual implementation depends on the current compiler phase.
+   */
+  bool shouldIncludeElementDueToMirrors(Element element,
+                                        {bool includedEnclosing});
+
+  void logEnqueueReflectiveAction(action, [msg = ""]) {
+    if (TRACE_MIRROR_ENQUEUING) {
+      print("MIRROR_ENQUEUE (${isResolutionQueue ? "R" : "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;
+      registerInstantiatedType(cls.rawType, 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) {
+    if (shouldIncludeElementDueToMirrors(element,
+            includedEnclosing: enclosingWasIncluded)
+        // Do not enqueue typedefs.
+        && !element.impliesType) {
+      logEnqueueReflectiveAction(element);
+      if (Elements.isStaticOrTopLevel(element)) {
+        registerStaticUse(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
+        Selector selector = new Selector.fromElement(element, compiler);
+        registerSelectorUse(selector);
+        if (element.isField) {
+          Selector selector =
+              new Selector.setter(element.name, element.library);
+          registerInvokedSetter(selector);
+        }
       }
     }
   }
 
-  void enqueueEverything() {
-    if (hasEnqueuedEverything) return;
-    compiler.log('Enqueuing everything');
-    task.ensureAllElementsByName();
-    for (Link link in task.allElementsByName.values) {
-      for (Element element in link) {
-        pretendElementWasUsed(element, compiler.mirrorDependencies);
+  /// 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;
+      registerInstantiatedClass(decl, 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);
+      });
+      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 =
+        compiler.backend.classesRequiredForReflection;
+    for (ClassElement cls in classes) {
+      if (compiler.backend.referencedFromMirrorSystem(cls)) {
+        logEnqueueReflectiveAction(cls);
+        registerInstantiatedClass(cls, compiler.mirrorDependencies,
+            mirrorUsage: true);
       }
     }
-    hasEnqueuedEverything = true;
-    hasEnqueuedReflectiveStaticFields = 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.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 = seenClasses.toSet();
+      compiler.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) {
-      pretendElementWasUsed(element, compiler.mirrorDependencies);
+      enqueueReflectiveMember(element, true);
     }
   }
 
   processLink(Map<String, Link<Element>> map,
               String memberName,
               bool f(Element e)) {
     Link<Element> members = map[memberName];
     if (members != null) {
       // [f] might add elements to [: map[memberName] :] during the loop below
       // so we create a new list for [: map[memberName] :] and prepend the
@@ skipping 138 matching lines @@
     universe.closurizedMembers.add(element);
   }
 
   void registerIfGeneric(Element element, Registry registry) {
     if (element.computeType(compiler).containsTypeVariables) {
       compiler.backend.registerGenericClosure(element, this, registry);
       universe.genericClosures.add(element);
     }
   }
 
-  void registerClosure(Element element, Registry registry) {
+  void registerClosure(FunctionElement element, Registry registry) {
+    universe.allClosures.add(element);
     registerIfGeneric(element, registry);
   }
 
   void forEach(f(WorkItem work)) {
     do {
-      while (!queue.isEmpty) {
+      while (queue.isNotEmpty) {
         // TODO(johnniwinther): Find an optimal process order.
         f(queue.removeLast());
       }
-      onQueueEmpty();
-    } while (!queue.isEmpty);
+      List recents = recentClasses.toList(growable: false);
+      recentClasses.clear();
+      if (!onQueueEmpty(recents)) recentClasses.addAll(recents);
+    } while (queue.isNotEmpty || recentClasses.isNotEmpty);
   }
 
-  void onQueueEmpty() {
-    compiler.backend.onQueueEmpty(this);
+  /// [onQueueEmpty] is called whenever the queue is drained. [recentClasses]
+  /// contains the set of all classes seen for the first time since
+  /// [onQueueEmpty] was called last. A return value of [true] indicates that
+  /// the [recentClasses] have been processed and may be cleared. If [false] is
+  /// returned, [onQueueEmpty] will be called once the queue is empty again (or
+  /// still empty) and [recentClasses] will be a superset of the current value.
+  bool onQueueEmpty(Iterable<ClassElement> recentClasses) {
+    return compiler.backend.onQueueEmpty(this, recentClasses);
   }
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
   void _logSpecificSummary(log(message));
 
@@ skipping 39 matching lines @@
     resolvedElements.add(element);
   }
 
   /// Returns [:true:] if [element] has actually been used.
   bool isLive(Element element) {
     if (seenClasses.contains(element)) return true;
     if (hasBeenResolved(element)) return true;
     return false;
   }
 
+  /**
+   * Decides whether an element should be included to satisfy requirements
+   * of the mirror system.
+   *
+   * During resolution, we have to resort to matching elements against the
+   * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
+   * yet.
+   */
+  bool shouldIncludeElementDueToMirrors(Element element,
+                                        {bool includedEnclosing}) {
+    return includedEnclosing || compiler.backend.requiredByMirrorSystem(element);
+  }
+
   void internalAddToWorkList(Element element) {
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     if (hasBeenResolved(element)) return;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Resolution work list is closed. Trying to add $element.");
     }
 
     compiler.world.registerUsedElement(element);
@@ skipping 58 matching lines @@
    */
   void addDeferredAction(Element element, DeferredAction action) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Resolution work list is closed. "
           "Trying to add deferred action for $element");
     }
     deferredTaskQueue.add(new DeferredTask(element, action));
   }
 
-  void onQueueEmpty() {
+  bool onQueueEmpty(Iterable<ClassElement> recentClasses) {
     emptyDeferredTaskQueue();
-    super.onQueueEmpty();
+    return super.onQueueEmpty(recentClasses);
   }
 
   void emptyDeferredTaskQueue() {
     while (!deferredTaskQueue.isEmpty) {
       DeferredTask task = deferredTaskQueue.removeFirst();
       compiler.withCurrentElement(task.element, task.action);
     }
   }
 
   void registerJsCall(Send node, ResolverVisitor resolver) {
@@ skipping 15 matching lines @@
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         super('codegen enqueuer', compiler, itemCompilationContextCreator);
 
   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 compiler.backend.isAccessibleByReflection(element);
+  }
+
   void internalAddToWorkList(Element element) {
     if (compiler.hasIncrementalSupport) {
       newlyEnqueuedElements.add(element);
     }
     // Don't generate code for foreign elements.
     if (element.isForeign(compiler)) return;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
       if (!compiler.enableTypeAssertions
           || element.enclosingElement.isClosure) {
         return;
       }
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Codegen work list is closed. Trying to add $element");
     }
     CodegenWorkItem workItem = new CodegenWorkItem(
         element, itemCompilationContextCreator());
     queue.add(workItem);
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }