Use the entity model for dump_info.

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 '../../common_elements.dart';
 import '../../elements/resolution_types.dart' show ResolutionDartType;
@@ skipping 83 matching lines @@
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
 
     ClassEntity classElement = cls.element;
 
     jsAst.Expression constructorAst = _stubGenerator.generateClassConstructor(
         classElement, fieldNames, cls.hasRtiField);
 
     jsAst.Name constructorName = namer.className(classElement);
     OutputUnit outputUnit =
-        compiler.deferredLoadTask.outputUnitForElement(classElement);
+        compiler.deferredLoadTask.outputUnitForEntity(classElement);
     emitter.assemblePrecompiledConstructor(
         outputUnit, constructorName, constructorAst, fieldNames);
   }
 
   /// Returns `true` if fields added.
   bool emitFields(FieldContainer container, ClassBuilder builder,
       {bool classIsNative: false, bool emitStatics: false}) {
     Iterable<Field> fields;
     if (container is Class) {
       if (emitStatics) {
@@ skipping 83 matching lines @@
                   .isClassAccessibleByReflection(fieldElement.enclosingClass)) {
             // TODO(redemption): Support field entities.
             FieldElement element = fieldElement;
             ResolutionDartType type = element.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);
+        compiler.dumpInfoTask.registerEntityAst(fieldElement, fieldNameAst);
         fieldsAdded = true;
       }
     }
 
     if (hasMetadata) {
       builder.fieldMetadata = fieldMetadata;
     }
     return fieldsAdded;
   }
 
   /// Emits checked setters for fields.
   void emitCheckedClassSetters(Class cls, ClassBuilder builder) {
     if (cls.onlyForRti) return;
 
     for (StubMethod method in cls.checkedSetters) {
       MemberEntity member = method.element;
       assert(member != null);
       jsAst.Expression code = method.code;
       jsAst.Name setterName = method.name;
       compiler.dumpInfoTask
-          .registerElementAst(member, builder.addProperty(setterName, code));
+          .registerEntityAst(member, builder.addProperty(setterName, code));
       generateReflectionDataForFieldGetterOrSetter(member, setterName, builder,
           isGetter: false);
     }
   }
 
   /// Emits getters/setters for fields if compiling in CSP mode.
   void emitClassGettersSettersForCSP(Class cls, ClassBuilder builder) {
     if (!compiler.options.useContentSecurityPolicy || cls.onlyForRti) return;
 
     for (Field field in cls.fields) {
       FieldEntity member = field.element;
       reporter.withCurrentElement(member, () {
         if (field.needsGetter) {
           emitGetterForCSP(member, field.name, field.accessorName, builder);
         }
         if (field.needsUncheckedSetter) {
           emitSetterForCSP(member, field.name, field.accessorName, builder);
         }
       });
     }
   }
 
   void emitStubs(Iterable<StubMethod> stubs, ClassBuilder builder) {
     for (Method method in stubs) {
       jsAst.Property property = builder.addProperty(method.name, method.code);
-      compiler.dumpInfoTask.registerElementAst(method.element, property);
+      compiler.dumpInfoTask.registerEntityAst(method.element, property);
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(Class cls, ClassBuilder builder) {
     ClassEntity classElement = cls.element;
@@ skipping 67 matching lines @@
             '<>', new jsAst.ArrayInitializer(typeVariableProperties.toList()));
       }
     }
 
     List<jsAst.Property> statics = new List<jsAst.Property>();
     ClassBuilder staticsBuilder =
         new ClassBuilder.forStatics(classEntity, namer);
     if (emitFields(cls, staticsBuilder, emitStatics: true)) {
       jsAst.ObjectInitializer initializer =
           staticsBuilder.toObjectInitializer();
-      compiler.dumpInfoTask.registerElementAst(classEntity, initializer);
+      compiler.dumpInfoTask.registerEntityAst(classEntity, initializer);
       jsAst.Node property = initializer.properties.single;
-      compiler.dumpInfoTask.registerElementAst(classEntity, property);
+      compiler.dumpInfoTask.registerEntityAst(classEntity, property);
       statics.add(property);
     }
 
     // TODO(herhut): Do not grab statics out of the properties.
     ClassBuilder classProperties =
         emitter.classDescriptors[fragment]?.remove(classEntity);
     if (classProperties != null) {
       statics.addAll(classProperties.properties);
     }
 
     if (!statics.isEmpty) {
       classBuilder.addProperty(
           namer.staticsPropertyName, // 'static' or its minified name.
           new jsAst.ObjectInitializer(statics, isOneLiner: false));
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     jsAst.ObjectInitializer propertyValue = classBuilder.toObjectInitializer();
     compiler.dumpInfoTask
-        .registerElementAst(classBuilder.element, propertyValue);
+        .registerEntityAst(classBuilder.element, propertyValue);
     enclosingBuilder.addProperty(className, propertyValue);
 
     String reflectionName =
         emitter.getReflectionClassName(classEntity, className);
     if (reflectionName != null) {
       if (!backend.mirrorsData.isClassAccessibleByReflection(classEntity) ||
           cls.onlyForRti) {
         // TODO(herhut): Fix use of reflection name here.
         enclosingBuilder.addPropertyByName("+$reflectionName", js.number(0));
       } else {
@@ skipping 30 matching lines @@
 
   void emitGetterForCSP(FieldEntity member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateGetter(member, fieldName);
 
     jsAst.Name getterName = namer.deriveGetterName(accessorName);
     ClassEntity cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
-        compiler.deferredLoadTask.outputUnitForElement(member);
+        compiler.deferredLoadTask.outputUnitForEntity(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, getterName, function]));
     if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, getterName]));
     }
   }
 
   void emitSetterForCSP(FieldEntity member, jsAst.Name fieldName,
       jsAst.Name accessorName, ClassBuilder builder) {
     jsAst.Expression function =
         _stubGenerator.generateSetter(member, fieldName);
 
     jsAst.Name setterName = namer.deriveSetterName(accessorName);
     ClassEntity cls = member.enclosingClass;
     jsAst.Name className = namer.className(cls);
     OutputUnit outputUnit =
-        compiler.deferredLoadTask.outputUnitForElement(member);
+        compiler.deferredLoadTask.outputUnitForEntity(member);
     emitter
         .cspPrecompiledFunctionFor(outputUnit)
         .add(js('#.prototype.# = #', [className, setterName, function]));
     if (backend.mirrorsData.isMemberAccessibleByReflection(member)) {
       emitter.cspPrecompiledFunctionFor(outputUnit).add(js(
           '#.prototype.#.${namer.reflectableField} = 1',
           [className, setterName]));
     }
   }
 
   void generateReflectionDataForFieldGetterOrSetter(
       MemberEntity member, jsAst.Name name, ClassBuilder builder,
       {bool isGetter}) {
     Selector selector = isGetter
         ? new Selector.getter(member.memberName.getter)
         : new Selector.setter(member.memberName.setter);
     String reflectionName = emitter.getReflectionSelectorName(selector, name);
     if (reflectionName != null) {
       var reflectable = js(
           backend.mirrorsData.isMemberAccessibleByReflection(member)
               ? '1'
               : '0');
       builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }