Make minification Entity-friendly.

pkg/compiler/lib/src/js_backend/field_naming_mixin.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 js_backend.namer;
 
 abstract class _MinifiedFieldNamer implements Namer {
   _FieldNamingRegistry get fieldRegistry;
 
   // Returns a minimal name for the field that is globally unique along
   // the given element's class inheritance chain.
   //
   // The inheritance scope based naming might not yield a name. For instance,
   // this could be because the field belongs to a mixin. In such a case this
   // will return `null` and a normal field name has to be used.
-  jsAst.Name _minifiedInstanceFieldPropertyName(FieldElement element) {
+  jsAst.Name _minifiedInstanceFieldPropertyName(FieldEntity element) {
     if (_nativeData.hasFixedBackendName(element)) {
       return new StringBackedName(_nativeData.getFixedBackendName(element));
     }
 
     _FieldNamingScope names;
-    if (element is BoxFieldElement) {
+    if (element is BoxFieldElement || element is JBoxedField) {
       names = new _FieldNamingScope.forBox(element.box, fieldRegistry);

[Siggi Cherem (dart-lang), 2017/08/03 23:44:54]

this might trigger some unhappy analyzer in strong mode tests, you might need to
add here: (element as dynamic).box

The alternative would be to duplicate the code twice:
if (... is BoxFieldElement) {
} else if (... is JBoxedField) {
...
}

[Emily Fortuna, 2017/08/04 01:35:03]

yes, sorry about that. Just ran the analyzer tests and am fixing that now.

     } else {
-      ClassElement cls = element.enclosingClass;
+      ClassEntity cls = element.enclosingClass;
       names = new _FieldNamingScope.forClass(cls, _closedWorld, fieldRegistry);
     }
 
     if (names.containsField(element)) {
       return names[element];
     }
     return null;
   }
 }
 
@@ skipping 73 matching lines @@
 
   /// The number of locally used fields. Depending on the naming source
   /// (e.g. inheritance based or globally unique for mixixns) this
   /// might be different from [inheritanceBasedFieldNameCounter].
   int get _localFieldNameCounter => _fieldNameCounter;
   void set _localFieldNameCounter(int val) {
     _fieldNameCounter = val;
   }
 
   factory _FieldNamingScope.forClass(
-      ClassElement cls, ClosedWorld world, _FieldNamingRegistry registry) {
+      ClassEntity cls, ClosedWorld world, _FieldNamingRegistry registry) {
     _FieldNamingScope result = registry.scopes[cls];
     if (result != null) return result;
 
     if (world.isUsedAsMixin(cls)) {
       result = new _MixinFieldNamingScope.mixin(cls, registry);
     } else {
-      if (cls.superclass == null) {
+      var superclass = world.elementEnvironment.getSuperClass(cls);
+      if (superclass == null) {
         result = new _FieldNamingScope.rootScope(cls, registry);
       } else {
         _FieldNamingScope superScope =
-            new _FieldNamingScope.forClass(cls.superclass, world, registry);
-        if (cls.isMixinApplication) {
+            new _FieldNamingScope.forClass(superclass, world, registry);
+        if (world.elementEnvironment.isMixinApplication(cls)) {
           result =
               new _MixinFieldNamingScope.mixedIn(cls, superScope, registry);
         } else {
           result = new _FieldNamingScope.inherit(cls, superScope, registry);
         }
       }
     }
 
-    cls.forEachInstanceField((cls, field) => result.add(field));
+    world.elementEnvironment.forEachClassMember(cls,
+        (ClassEntity declarer, MemberEntity member) {
+      if (member.isField && member.isInstanceMember) result.add(member);
+    });
 
     registry.scopes[cls] = result;
     return result;
   }
 
   factory _FieldNamingScope.forBox(Local box, _FieldNamingRegistry registry) {
     return registry.scopes
         .putIfAbsent(box, () => new _BoxFieldNamingScope(box, registry));
   }
 
@@ skipping 74 matching lines @@
       : super.rootScope(box, registry);
 
   @override
   bool containsField(_) => true;
 
   jsAst.Name operator [](Element field) {
     if (!names.containsKey(field)) add(field);
     return names[field];
   }
 }