Split MirrorsData methods and MirrorsDataImpl data by element kind.

pkg/compiler/lib/src/js_emitter/program_builder/collector.dart

 // Copyright (c) 2015, 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.js_emitter.program_builder;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 100 matching lines @@
 
   /**
    * Compute all the constants that must be emitted.
    */
   void computeNeededConstants() {
     // Make sure we retain all metadata of all elements. This could add new
     // constants to the handler.
     if (backend.mirrorsData.mustRetainMetadata) {
       // TODO(floitsch): verify that we don't run through the same elements
       // multiple times.
-      for (Element element in backend.generatedCode.keys) {
-        if (backend.mirrorsData.isAccessibleByReflection(element)) {
+      for (MemberElement element in backend.generatedCode.keys) {
+        if (backend.mirrorsData.isMemberAccessibleByReflection(element)) {
           bool shouldRetainMetadata =
-              backend.mirrorsData.retainMetadataOf(element);
+              backend.mirrorsData.retainMetadataOfMember(element);
           if (shouldRetainMetadata &&
               (element.isFunction ||
                   element.isConstructor ||
                   element.isSetter)) {
-            FunctionElement function = element;
-            function.functionSignature
-                .forEachParameter(backend.mirrorsData.retainMetadataOf);
+            MethodElement function = element;
+            function.functionSignature.forEachParameter(
+                backend.mirrorsData.retainMetadataOfParameter);
           }
         }
       }
       for (ClassElement cls in neededClasses) {
         final onlyForRti = classesOnlyNeededForRti.contains(cls);
         if (!onlyForRti) {
-          backend.mirrorsData.retainMetadataOf(cls);
+          backend.mirrorsData.retainMetadataOfClass(cls);
           new FieldVisitor(compiler, namer, closedWorld).visitFields(cls, false,
-              (Element member, js.Name name, js.Name accessorName,
+              (FieldElement member, js.Name name, js.Name accessorName,
                   bool needsGetter, bool needsSetter, bool needsCheckedSetter) {
             bool needsAccessor = needsGetter || needsSetter;
             if (needsAccessor &&
-                backend.mirrorsData.isAccessibleByReflection(member)) {
-              backend.mirrorsData.retainMetadataOf(member);
+                backend.mirrorsData.isMemberAccessibleByReflection(member)) {
+              backend.mirrorsData.retainMetadataOfMember(member);
             }
           });
         }
       }
-      typedefsNeededForReflection.forEach(backend.mirrorsData.retainMetadataOf);
+      typedefsNeededForReflection
+          .forEach(backend.mirrorsData.retainMetadataOfTypedef);
     }
 
     JavaScriptConstantCompiler handler = backend.constants;
     List<ConstantValue> constants =
         handler.getConstantsForEmission(emitter.compareConstants);
     for (ConstantValue constant in constants) {
       if (emitter.isConstantInlinedOrAlreadyEmitted(constant)) continue;
 
       if (constant.isList) outputContainsConstantList = true;
 
       OutputUnit constantUnit =
           compiler.deferredLoadTask.outputUnitForConstant(constant);
       if (constantUnit == null) {
         // The back-end introduces some constants, like "InterceptorConstant" or
         // some list constants. They are emitted in the main output-unit.
         // TODO(sigurdm): We should track those constants.
         constantUnit = compiler.deferredLoadTask.mainOutputUnit;
       }
       outputConstantLists
           .putIfAbsent(constantUnit, () => new List<ConstantValue>())
           .add(constant);
     }
   }
 
   /// Compute all the classes and typedefs that must be emitted.
   void computeNeededDeclarations() {
     // Compute needed typedefs.
     typedefsNeededForReflection = Elements.sortedByPosition(closedWorld
         .allTypedefs
-        .where(backend.mirrorsData.isAccessibleByReflection)
+        .where(backend.mirrorsData.isTypedefAccessibleByReflection)
         .toList());
 
     // Compute needed classes.
     Set<ClassElement> instantiatedClasses = compiler
         // TODO(johnniwinther): This should be accessed from a codegen closed
         // world.
         .codegenWorldBuilder
         .directlyInstantiatedClasses
         .where(computeClassFilter())
         .toSet();
@@ skipping 72 matching lines @@
         outputClassLists
             .putIfAbsent(
                 compiler.deferredLoadTask.outputUnitForElement(element),
                 () => new List<ClassElement>())
             .add(element);
       }
     }
   }
 
   void computeNeededStatics() {
-    bool isStaticFunction(Element element) =>
+    bool isStaticFunction(MemberElement element) =>
         !element.isInstanceMember && !element.isField;
 
-    Iterable<Element> elements =
+    Iterable<MemberElement> elements =
         backend.generatedCode.keys.where(isStaticFunction);
 
     for (Element element in Elements.sortedByPosition(elements)) {
       List<Element> list = outputStaticLists.putIfAbsent(
           compiler.deferredLoadTask.outputUnitForElement(element),
           () => new List<Element>());
       list.add(element);
     }
   }
 
   void computeNeededStaticNonFinalFields() {
     addToOutputUnit(Element element) {
       List<VariableElement> list = outputStaticNonFinalFieldLists.putIfAbsent(
           compiler.deferredLoadTask.outputUnitForElement(element),
           () => new List<VariableElement>());
       list.add(element);
     }
 
-    Iterable<Element> fields = compiler
+    Iterable<FieldElement> fields = compiler
         // TODO(johnniwinther): This should be accessed from a codegen closed
         // world.
         .codegenWorldBuilder
         .allReferencedStaticFields
         .where((FieldElement field) {
       if (!field.isConst) {
         return field.isField &&
             !field.isInstanceMember &&
             !field.isFinal &&
             field.constant != null;
       } else {
         // We also need to emit static const fields if they are available for
         // reflection.
-        return backend.mirrorsData.isAccessibleByReflection(field);
+        return backend.mirrorsData.isMemberAccessibleByReflection(field);
       }
     });
 
     Elements.sortedByPosition(fields).forEach(addToOutputUnit);
   }
 
   void computeNeededLibraries() {
     void addSurroundingLibraryToSet(Element element) {
       OutputUnit unit = compiler.deferredLoadTask.outputUnitForElement(element);
       LibraryElement library = element.library;
       outputLibraryLists
           .putIfAbsent(unit, () => new Set<LibraryElement>())
           .add(library);
     }
 
     backend.generatedCode.keys.forEach(addSurroundingLibraryToSet);
     neededClasses.forEach(addSurroundingLibraryToSet);
   }
 
   void collect() {
     computeNeededDeclarations();
     computeNeededConstants();
     computeNeededStatics();
     computeNeededStaticNonFinalFields();
     computeNeededLibraries();
   }
 }