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) {
       names = new _FieldNamingScope.forBox(element.box, fieldRegistry);
+    } else if (element is JBoxedField) {
+      names = new _FieldNamingScope.forBox(element.box, fieldRegistry);
     } 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));
   }
 
   _FieldNamingScope.rootScope(this.container, this.registry)
       : superScope = null,
         _fieldNameCounter = 0;
 
   _FieldNamingScope.inherit(this.container, this.superScope, this.registry) {
     _fieldNameCounter = superScope.inheritanceBasedFieldNameCounter;
   }
 
   /**
    * Checks whether [name] is already used in the current scope chain.
    */
   _isNameUnused(jsAst.Name name) {
     return !names.values.contains(name) &&
         ((superScope == null) || superScope._isNameUnused(name));
   }
 
   jsAst.Name _nextName() => registry.getName(_localFieldNameCounter++);
 
-  jsAst.Name operator [](Element field) {
+  jsAst.Name operator [](Entity field) {
     jsAst.Name name = names[field];
     if (name == null && superScope != null) return superScope[field];
     return name;
   }
 
-  void add(Element field) {
+  void add(Entity field) {
     if (names.containsKey(field)) return;
 
     jsAst.Name value = _nextName();
     assert(_isNameUnused(value), failedAt(field));
     names[field] = value;
   }
 
-  bool containsField(Element field) => names.containsKey(field);
+  bool containsField(Entity field) => names.containsKey(field);
 }
 
 /**
  * Field names for mixins have two constraints: They need to be unique in the
  * hierarchy of each application of a mixin and they need to be the same for
  * all applications of a mixin. To achieve this, we use global naming for
  * mixins from the same name pool as fields and add a `$` at the end to ensure
  * they do not collide with normal field names. The `$` sign is typically used
  * as a separator between method names and argument counts and does not appear
  * in generated names themselves.
@@ skipping 26 matching lines @@
  * inheritance chain, we do not need to compute fields a priori but can assign
  * names on the fly.
  */
 class _BoxFieldNamingScope extends _FieldNamingScope {
   _BoxFieldNamingScope(Local box, _FieldNamingRegistry registry)
       : super.rootScope(box, registry);
 
   @override
   bool containsField(_) => true;
 
-  jsAst.Name operator [](Element field) {
+  jsAst.Name operator [](Entity field) {
     if (!names.containsKey(field)) add(field);
     return names[field];
   }
 }