Split MirrorsData methods and MirrorsDataImpl data by element kind.

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 55 matching lines @@
     void addFieldsInContainer(ScopeContainerElement container) {
       container.forEachLocalMember((Element member) {
         if (!member.isInstanceMember && member.isField) {
           staticFields.add(member);
         } else if (member.isClass) {
           addFieldsInContainer(member);
         }
       });
     }
 
-    for (Element target in _mirrorsData.targetsUsed) {
-      if (target == null) continue;
+    for (MemberElement target in _mirrorsData.membersInMirrorsUsedTargets) {
       if (target.isField) {
         staticFields.add(target);
-      } else if (target.isLibrary || target.isClass) {
-        addFieldsInContainer(target);
       }
     }
+    for (ClassElement target in _mirrorsData.classesInMirrorsUsedTargets) {
+      addFieldsInContainer(target);
+    }
+    for (LibraryElement target in _mirrorsData.librariesInMirrorsUsedTargets) {
+      addFieldsInContainer(target);
+    }
     return staticFields;
   }
 
   /// Compute the impact for elements that are matched by the mirrors used
   /// annotation or, in lack thereof, all elements.
   WorldImpact _computeImpactForReflectiveElements(
       Iterable<ClassEntity> recents,
       Iterable<ClassEntity> processedClasses,
       Iterable<LibraryElement> loadedLibraries) {
     handler.enqueueReflectiveElements(
         recents, processedClasses, loadedLibraries);
     return handler.flush();
   }
 
   /// Compute the impact for the static fields that have been marked as used by
   /// reflective usage through `MirrorsUsed`.
   WorldImpact _computeImpactForReflectiveStaticFields(
       Iterable<Element> elements) {
     handler.enqueueReflectiveStaticFields(elements);
     return handler.flush();
   }
 
   void onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {
     if (_mirrorsData.isTreeShakingDisabled) {
       enqueuer.applyImpact(_computeImpactForReflectiveElements(recentClasses,
           enqueuer.processedClasses, _compiler.libraryLoader.libraries));
-    } else if (!_mirrorsData.targetsUsed.isEmpty) {
+    } else if (_mirrorsData.membersInMirrorsUsedTargets.isNotEmpty ||
+        _mirrorsData.classesInMirrorsUsedTargets.isNotEmpty ||
+        _mirrorsData.librariesInMirrorsUsedTargets.isNotEmpty) {
       // Add all static elements (not classes) that have been requested for
       // reflection. If there is no mirror-usage these are probably not
       // necessary, but the backend relies on them being resolved.
       enqueuer.applyImpact(
           _computeImpactForReflectiveStaticFields(_findStaticFieldTargets()));
     }
 
     if (_mirrorsData.mustPreserveNames) _reporter.log('Preserving names.');
 
     if (_mirrorsData.mustRetainMetadata) {
       _reporter.log('Retaining metadata.');
 
-      _compiler.libraryLoader.libraries.forEach(_mirrorsData.retainMetadataOf);
+      _compiler.libraryLoader.libraries
+          .forEach(_mirrorsData.retainMetadataOfLibrary);
 
       if (!enqueuer.queueIsClosed) {
         /// Register the constant value of [metadata] as live in resolution.
         void registerMetadataConstant(MetadataAnnotation metadata) {
           ConstantValue constant =
               _constants.getConstantValueForMetadata(metadata);
           Dependency dependency =
               new Dependency(constant, metadata.annotatedElement);
           _metadataConstants.add(dependency);
           _impactBuilder.registerConstantUse(new ConstantUse.mirrors(constant));
@@ skipping 102 matching lines @@
     if (_mirrorsData.isTreeShakingDisabled) {
       enqueuer.applyImpact(_computeImpactForReflectiveElements(recentClasses,
           enqueuer.processedClasses, _compiler.libraryLoader.libraries));
     }
 
     if (_mirrorsData.mustPreserveNames) _reporter.log('Preserving names.');
 
     if (_mirrorsData.mustRetainMetadata) {
       _reporter.log('Retaining metadata.');
 
-      _compiler.libraryLoader.libraries.forEach(_mirrorsData.retainMetadataOf);
+      _compiler.libraryLoader.libraries
+          .forEach(_mirrorsData.retainMetadataOfLibrary);
 
       for (Dependency dependency in _metadataConstants) {
         _impactBuilder
             .registerConstantUse(new ConstantUse.mirrors(dependency.constant));
       }
       _metadataConstants.clear();
       enqueuer.applyImpact(_impactBuilder.flush());
     }
   }
 }
@@ skipping 119 matching lines @@
   /// Enqueue 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.mirrorsData.referencedFromMirrorSystem(cls)) {
+      if (_backend.mirrorsData.isClassReferencedFromMirrorSystem(cls)) {
         _logEnqueueReflectiveAction(cls);
         cls.ensureResolved(_resolution);
         impactBuilder
             .registerTypeUse(new TypeUse.mirrorInstantiation(cls.rawType));
       }
     }
   }
 
   /// Enqueue all local members of the library [lib] if they are required for
   /// reflection.
@@ skipping 71 matching lines @@
 
 /// 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()}';
 }