Handle instance fields in compile_from_dill_test

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 112 matching lines @@
       assert(container is Library);
       assert(emitStatics);
       fields = container.staticFieldsForReflection;
     }
 
     var fieldMetadata = [];
     bool hasMetadata = false;
     bool fieldsAdded = false;
 
     for (Field field in fields) {
-      FieldElement fieldElement = field.element;
+      FieldEntity fieldElement = field.element;
       jsAst.Name name = field.name;
       jsAst.Name accessorName = field.accessorName;
       bool needsGetter = field.needsGetter;
       bool needsSetter = field.needsUncheckedSetter;
 
       // 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
@@ skipping 25 matching lines @@
           fieldNameParts.add(name);
           if (field.needsInterceptedGetter) {
             emitter.interceptorEmitter.interceptorInvocationNames
                 .add(namer.getterForElement(fieldElement));
           }
           // TODO(16168): The setter creator only looks at the getter-name.
           // Even though the setter could avoid the interceptor convention we
           // currently still need to add the additional argument.
           if (field.needsInterceptedGetter || field.needsInterceptedSetter) {
             emitter.interceptorEmitter.interceptorInvocationNames
-                .add(namer.setterForElement(fieldElement));
+                .add(namer.setterForMember(fieldElement));
           }
 
           int code = field.getterFlags + (field.setterFlags << 2);
           if (code == 0) {
             reporter.internalError(
                 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.isMemberAccessibleByReflection(fieldElement)) {
           fieldNameParts.add(new jsAst.LiteralString('-'));
           if (fieldElement.isTopLevel ||
               backend.mirrorsData
                   .isClassAccessibleByReflection(fieldElement.enclosingClass)) {
-            ResolutionDartType type = fieldElement.type;
+            // TODO(johnniwinther): 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);
         fieldsAdded = true;
       }
     }
@@ skipping 149 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.getReflectionClassName(classEntity, className);
     if (reflectionName != null) {
-      // TODO(johnniwinther): Handle class entities.
-      ClassElement classElement = classEntity;
-      if (!backend.mirrorsData.isClassAccessibleByReflection(classElement) ||
+      if (!backend.mirrorsData.isClassAccessibleByReflection(classEntity) ||
           cls.onlyForRti) {
         // TODO(herhut): Fix use of reflection name here.
         enclosingBuilder.addPropertyByName("+$reflectionName", js.number(0));
       } else {
+        // TODO(johnniwinther): Handle class entities.
+        ClassElement classElement = classEntity;
         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(
-      FieldElement member, jsAst.Name accessorName, String memberName) {
+      FieldEntity 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(previousName == memberName,
@@ skipping 49 matching lines @@
     String reflectionName = emitter.getReflectionSelectorName(selector, name);
     if (reflectionName != null) {
       var reflectable = js(
           backend.mirrorsData.isMemberAccessibleByReflection(member)
               ? '1'
               : '0');
       builder.addPropertyByName('+$reflectionName', reflectable);
     }
   }
 }