Use entities in most of MirrorsData

pkg/compiler/lib/src/js_backend/mirrors_analysis.dart

 // Copyright (c) 2016, 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.mirrors_handler;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
@@ skipping 278 matching lines @@
   }
 
   /**
    * 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 _shouldIncludeLibraryDueToMirrors(LibraryElement element,
       {bool includedEnclosing}) {
     return includedEnclosing ||
-        _backend.mirrorsData.requiredByMirrorSystem(element);
+        _backend.mirrorsData.isLibraryRequiredByMirrorSystem(element);
+  }
+
+  bool _shouldIncludeClassDueToMirrors(ClassElement element,
+      {bool includedEnclosing}) {
+    return includedEnclosing ||
+        _backend.mirrorsData.isClassRequiredByMirrorSystem(element);
+  }
+
+  bool _shouldIncludeMemberDueToMirrors(MemberElement element,
+      {bool includedEnclosing}) {
+    return includedEnclosing ||
+        _backend.mirrorsData.isMemberRequiredByMirrorSystem(element);
   }
 
   /// Enqueue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveConstructor(ConstructorElement constructor,
       {bool enclosingWasIncluded}) {
     assert(constructor.isDeclaration);
-    if (_shouldIncludeElementDueToMirrors(constructor,
+    if (_shouldIncludeMemberDueToMirrors(constructor,
         includedEnclosing: enclosingWasIncluded)) {
       if (constructor.isFromEnvironmentConstructor) return;
       _logEnqueueReflectiveAction(constructor);
       ClassElement cls = constructor.enclosingClass;
       impactBuilder
           .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       impactBuilder.registerStaticUse(new StaticUse.mirrorUse(constructor));
     }
   }
 
   /// Enqueue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void _enqueueReflectiveMember(
       MemberElement element, bool enclosingWasIncluded) {
     assert(element.isDeclaration);
-    if (_shouldIncludeElementDueToMirrors(element,
+    if (_shouldIncludeMemberDueToMirrors(element,
         includedEnclosing: enclosingWasIncluded)) {
       _logEnqueueReflectiveAction(element);
       if (Elements.isStaticOrTopLevel(element)) {
         impactBuilder.registerStaticUse(new StaticUse.mirrorUse(element));
       } 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);
         impactBuilder.registerDynamicUse(dynamicUse);
         if (element.isField) {
           DynamicUse dynamicUse = new DynamicUse(
               new Selector.setter(element.memberName.setter), null);
           impactBuilder.registerDynamicUse(dynamicUse);
         }
       }
     }
   }
 
   /// Enqueue 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<ClassEntity> recents,
       {bool enclosingWasIncluded}) {
     assert(cls.isDeclaration);
     if (cls.library.isInternalLibrary || cls.isInjected) return;
-    bool includeClass = _shouldIncludeElementDueToMirrors(cls,
+    bool includeClass = _shouldIncludeClassDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
       _logEnqueueReflectiveAction(cls, "register");
       ClassElement declaration = cls.declaration;
       declaration.ensureResolved(_resolution);
       impactBuilder.registerTypeUse(
           new TypeUse.mirrorInstantiation(declaration.rawType));
     }
     // If the class is never instantiated, we know nothing of it can possibly
     // be reflected upon.
@@ skipping 38 matching lines @@
       }
     }
   }
 
   /// Enqueue all local members of the library [lib] if they are required for
   /// reflection.
   void _enqueueReflectiveElementsInLibrary(
       LibraryElement lib, Iterable<ClassEntity> recents) {
     assert(lib.isDeclaration);
     bool includeLibrary =
-        _shouldIncludeElementDueToMirrors(lib, includedEnclosing: false);
+        _shouldIncludeLibraryDueToMirrors(lib, includedEnclosing: false);
     lib.forEachLocalMember((Element member) {
       if (member.isInjected) return;
       if (member.isClass) {
         ClassElement cls = member;
         cls.ensureResolved(_resolution);
         do {
           _enqueueReflectiveElementsInClass(cls, recents,
               enclosingWasIncluded: includeLibrary);
           cls = cls.superclass;
         } while (cls != null && cls.isUnnamedMixinApplication);
@@ skipping 29 matching lines @@
       _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((ClassEntity _cls) {
         ClassElement cls = _cls;
         _enqueueReflectiveElementsInClass(cls, recents,
-            enclosingWasIncluded: _shouldIncludeElementDueToMirrors(cls.library,
+            enclosingWasIncluded: _shouldIncludeLibraryDueToMirrors(cls.library,
                 includedEnclosing: false));
       });
       _logEnqueueReflectiveAction("!DONE enqueueRecents");
     }
   }
 
   /// Enqueue the static fields that have been marked as used by reflective
   /// usage through `MirrorsUsed`.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveStaticFields(Iterable<Element> elements) {
     if (hasEnqueuedReflectiveStaticFields) return;
     hasEnqueuedReflectiveStaticFields = true;
     for (Element element in elements) {
       _enqueueReflectiveMember(element, true);
     }
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 
   String toString() => '$annotatedElement:${constant.toStructuredText()}';
 }