Handle instance fields in compile_from_dill_test

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
@@ skipping 850 matching lines @@
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
   jsAst.Name invocationMirrorInternalName(Selector selector) =>
       invocationName(selector);
 
   /**
    * Returns the disambiguated name for the given field, used for constructing
    * the getter and setter names.
    */
-  jsAst.Name fieldAccessorName(FieldElement element) {
+  jsAst.Name fieldAccessorName(FieldEntity element) {
     return element.isInstanceMember
         ? _disambiguateMember(element.memberName)
         : _disambiguateGlobalMember(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store a static or instance
    * field.
    */
-  jsAst.Name fieldPropertyName(FieldElement element) {
+  jsAst.Name fieldPropertyName(FieldEntity element) {
     return element.isInstanceMember
         ? instanceFieldPropertyName(element)
         : _disambiguateGlobalMember(element);
   }
 
   /// Returns a JavaScript property name used to store the member [element] on
   /// one of the global objects.
   ///
   /// Should be used together with [globalObjectForMember], which denotes the
   /// object on which the returned property name should be used.
@@ skipping 12 matching lines @@
   /// [element] on one of the global objects.
   ///
   /// Should be used together with [globalObjectForType], which denotes the
   /// object on which the returned property name should be used.
   jsAst.Name globalPropertyNameForType(TypeDeclarationElement element) =>
       _disambiguateGlobalType(element);
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
-  jsAst.Name instanceFieldPropertyName(FieldElement element) {
-    ClassElement enclosingClass = element.enclosingClass;
+  jsAst.Name instanceFieldPropertyName(FieldEntity element) {
+    ClassEntity enclosingClass = element.enclosingClass;
 
     if (_nativeData.hasFixedBackendName(element)) {
       return new StringBackedName(_nativeData.getFixedBackendName(element));
     }
 
     // Some elements, like e.g. instances of BoxFieldElement are special.
     // They are created with a unique and safe name for the element model.
     // While their name is unique, it is not very readable. So we try to
     // preserve the original, proposed name.
     // However, as boxes are not really instances of classes, the usual naming
     // scheme that tries to avoid name clashes with super classes does not
     // apply. So we can directly grab a name.
-    Entity asEntity = element;
-    if (asEntity is JSEntity) {
+    if (element is JSEntity) {
+      var jsEntity = element;
       return _disambiguateInternalMember(
-          element, () => asEntity.declaredEntity.name);
+          jsEntity,
+          // ignore: UNDEFINED_GETTER
+          () => jsEntity.declaredEntity.name);
     }
 
     // If the name of the field might clash with another field,
     // use a mangled field name to avoid potential clashes.
     // Note that if the class extends a native class, that native class might
     // have fields with fixed backend names, so we assume the worst and always
     // mangle the field names of classes extending native classes.
     // Methods on such classes are stored on the interceptor, not the instance,
     // so only fields have the potential to clash with a native property name.
     if (_closedWorld.isUsedAsMixin(enclosingClass) ||
         _isShadowingSuperField(element) ||
         _isUserClassExtendingNative(enclosingClass)) {
       String proposeName() => '${enclosingClass.name}_${element.name}';
       return _disambiguateInternalMember(element, proposeName);
     }
 
     // No superclass uses the disambiguated name as a property name, so we can
     // use it for this field. This generates nicer field names since otherwise
     // the field name would have to be mangled.
     return _disambiguateMember(new Name(element.name, element.library));
   }
 
-  bool _isShadowingSuperField(Element element) {
-    return element.enclosingClass.hasFieldShadowedBy(element);
+  bool _isShadowingSuperField(FieldEntity element) {
+    ClassEntity cls = element.enclosingClass;
+    if (cls is ClassElement) {
+      return cls.hasFieldShadowedBy(element);
+    }
+    // TODO(johnniwinther): Support class entities.
+    return false;
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
-  bool _isUserClassExtendingNative(ClassElement class_) {
+  bool _isUserClassExtendingNative(ClassEntity class_) {
     return !_nativeData.isNativeClass(class_) &&
-        _nativeData.isNativeOrExtendsNative(class_.superclass);
+        _nativeData.isNativeOrExtendsNative(class_);
   }
 
   /// Annotated name for the setter of [element].
-  jsAst.Name setterForElement(MemberElement element) {
+  jsAst.Name setterForMember(MemberEntity element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     jsAst.Name name = _disambiguateMember(element.memberName);
     return deriveSetterName(name);
   }
 
   /// Annotated name for the setter of any member with [disambiguatedName].
   jsAst.Name deriveSetterName(jsAst.Name disambiguatedName) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
@@ skipping 1255 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }