Split MirrorsData methods and MirrorsDataImpl data by element kind.

pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart

 // Copyright (c) 2013, 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_emitter.full_emitter.class_emitter;
 
 import '../../common.dart';
 import '../../common/names.dart' show Names;
 import '../../elements/resolution_types.dart' show ResolutionDartType;
 import '../../deferred_load.dart' show OutputUnit;
 import '../../elements/elements.dart'
-    show ClassElement, Element, FieldElement, MemberElement, Name;
+    show ClassElement, FieldElement, MemberElement, Name;
 import '../../js/js.dart' as jsAst;
 import '../../js/js.dart' show js;
 import '../../js_backend/js_backend.dart' show CompoundName, Namer;
 import '../../universe/selector.dart' show Selector;
 import '../../util/util.dart' show equalElements;
 import '../../world.dart' show ClosedWorld;
 import '../js_emitter.dart' hide Emitter, EmitterFactory;
 import '../model.dart';
 import 'emitter.dart';
 
@@ skipping 110 matching lines @@
 
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       bool needsFieldsForConstructor = !emitStatics && !classIsNative;
       if (needsFieldsForConstructor || needsAccessor) {
         var metadata =
-            task.metadataCollector.buildMetadataFunction(fieldElement);
+            task.metadataCollector.buildFieldMetadataFunction(fieldElement);
         if (metadata != null) {
           hasMetadata = true;
         } else {
           metadata = new jsAst.LiteralNull();
         }
         fieldMetadata.add(metadata);
         recordMangledField(fieldElement, accessorName,
             namer.privateName(fieldElement.memberName));
         List<jsAst.Literal> fieldNameParts = <jsAst.Literal>[];
         if (!needsAccessor) {
@@ skipping 26 matching lines @@
                 fieldElement, 'Field code is 0 ($fieldElement).');
           }
           fieldNameParts.add(
               js.stringPart(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]));
         }
         // Fields can only be reflected if their declaring class is reflectable
         // (as they are only accessible via [ClassMirror.declarations]).
         // However, set/get operations can be performed on them, so they are
         // reflectable in some sense, which leads to [isAccessibleByReflection]
         // reporting `true`.
-        if (backend.mirrorsData.isAccessibleByReflection(fieldElement)) {
+        if (backend.mirrorsData.isMemberAccessibleByReflection(fieldElement)) {
           fieldNameParts.add(new jsAst.LiteralString('-'));
           if (fieldElement.isTopLevel ||
               backend.mirrorsData
-                  .isAccessibleByReflection(fieldElement.enclosingClass)) {
+                  .isClassAccessibleByReflection(fieldElement.enclosingClass)) {
             ResolutionDartType type = fieldElement.type;
             fieldNameParts.add(task.metadataCollector.reifyType(type));
           }
         }
         jsAst.Literal fieldNameAst = js.concatenateStrings(fieldNameParts);
         builder.addField(fieldNameAst);
         // Add 1 because adding a field to the class also requires a comma
         compiler.dumpInfoTask.registerElementAst(fieldElement, fieldNameAst);
         fieldsAdded = true;
       }
@@ skipping 92 matching lines @@
     if (nativeInfo != null) {
       builder.addPropertyByName(namer.nativeSpecProperty, nativeInfo);
     }
   }
 
   void emitClassBuilderWithReflectionData(Class cls, ClassBuilder classBuilder,
       ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassElement classElement = cls.element;
     jsAst.Name className = cls.name;
 
-    var metadata = task.metadataCollector.buildMetadataFunction(classElement);
+    var metadata =
+        task.metadataCollector.buildClassMetadataFunction(classElement);
     if (metadata != null) {
       classBuilder.addPropertyByName("@", metadata);
     }
 
-    if (backend.mirrorsData.isAccessibleByReflection(classElement)) {
+    if (backend.mirrorsData.isClassAccessibleByReflection(classElement)) {
       List<ResolutionDartType> typeVars = classElement.typeVariables;
       Iterable typeVariableProperties =
           emitter.typeVariableCodegenAnalysis.typeVariablesOf(classElement);
 
       ClassElement superclass = classElement.superclass;
       bool hasSuper = superclass != null;
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && !equalElements(superclass.typeVariables, typeVars))) {
         classBuilder.addPropertyByName(
             '<>', new jsAst.ArrayInitializer(typeVariableProperties.toList()));
@@ skipping 26 matching lines @@
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     jsAst.ObjectInitializer propertyValue = classBuilder.toObjectInitializer();
     compiler.dumpInfoTask
         .registerElementAst(classBuilder.element, propertyValue);
     enclosingBuilder.addProperty(className, propertyValue);
 
     String reflectionName = emitter.getReflectionName(classElement, className);
     if (reflectionName != null) {
-      if (!backend.mirrorsData.isAccessibleByReflection(classElement) ||
+      if (!backend.mirrorsData.isClassAccessibleByReflection(classElement) ||
           cls.onlyForRti) {
         // TODO(herhut): Fix use of reflection name here.
         enclosingBuilder.addPropertyByName("+$reflectionName", js.number(0));
       } else {
         List<jsAst.Expression> types = <jsAst.Expression>[];
         if (classElement.supertype != null) {
           types.add(task.metadataCollector.reifyType(classElement.supertype));
         }
         for (ResolutionDartType interface in classElement.interfaces) {
           types.add(task.metadataCollector.reifyType(interface));
         }
         // TODO(herhut): Fix use of reflection name here.
         enclosingBuilder.addPropertyByName(
             "+$reflectionName", new jsAst.ArrayInitializer(types));
       }
     }
   }
 
   void recordMangledField(
-      Element member, jsAst.Name accessorName, String memberName) {
+      FieldElement member, jsAst.Name accessorName, String memberName) {
     if (!backend.mirrorsData.shouldRetainGetter(member)) return;
     String previousName;
     if (member.isInstanceMember) {
       previousName = emitter.mangledFieldNames
           .putIfAbsent(namer.deriveGetterName(accessorName), () => memberName);
     } else {
       previousName = emitter.mangledGlobalFieldNames
           .putIfAbsent(accessorName, () => memberName);
     }
     assert(invariant(member, previousName == memberName,
         message: '$previousName != ${memberName}'));
   }
 
   void emitGetterForCSP(FieldElement member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateGetter(member, fieldName);
 
     jsAst.Name getterName = namer.deriveGetterName(accessorName);
     ClassElement cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, getterName, function]));
-    if (backend.mirrorsData.isAccessibleByReflection(member)) {
+    if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, getterName]));
     }
   }
 
   void emitSetterForCSP(FieldElement member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateSetter(member, fieldName);
 
     jsAst.Name setterName = namer.deriveSetterName(accessorName);
     ClassElement cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, setterName, function]));
-    if (backend.mirrorsData.isAccessibleByReflection(member)) {
+    if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, setterName]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(
-      Element member, jsAst.Name name, ClassBuilder builder,
+      MemberElement member, jsAst.Name name, ClassBuilder builder,
       {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(new Name(member.name, member.library))
         : new Selector.setter(
             new Name(member.name, member.library, isSetter: true));
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
-      var reflectable =
-          js(backend.mirrorsData.isAccessibleByReflection(member) ? '1' : '0');
+      var reflectable = js(
+          backend.mirrorsData.isMemberAccessibleByReflection(member)
+              ? '1'
+              : '0');
       builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }