Avoid known native field names when minifying method names.

sdk/lib/_internal/compiler/implementation/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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 13 matching lines @@
    * Map from top-level or static elements to their unique identifiers provided
    * by [getName].
    *
    * Invariant: Keys must be declaration elements.
    */
   final Compiler compiler;
   final Map<Element, String> globals;
   final Map<String, LibraryElement> shortPrivateNameOwners;
   final Set<String> usedGlobalNames;
   final Set<String> usedInstanceNames;
+  final Map<String, String> globalNameMap;
   final Map<String, String> instanceNameMap;
-  final Map<String, String> globalNameMap;
   final Map<String, int> popularNameCounters;
 
   /**
    * A cache of names used for bailout methods. We make sure two
    * bailout methods cannot have the same name because if the two
    * bailout methods are in a class and a subclass, we would
    * call the wrong bailout method at runtime. To make it
    * simple, we don't keep track of inheritance and always avoid
    * similar names.
    */
@@ skipping 182 matching lines @@
 
   // Construct a new name for the element based on the library and class it is
   // in.  The name here is not important, we just need to make sure it is
   // unique.  If we are minifying, we actually construct the name from the
   // minified versions of the class and instance names, but the result is
   // minified once again, so that is not visible in the end result.
   String shadowedFieldName(Element fieldElement) {
     // Check for following situation: Native field ${fieldElement.name} has
     // fixed JSName ${fieldElement.nativeName()}, but a subclass shadows this
     // name.  We normally handle that by renaming the superclass field, but we
-    // can't do that because native fields have fixed JSNames.  In practice
+    // can't do that because native fields have fixed JsNames.  In practice
     // this can't happen because we can't inherit from native classes.
     assert (!fieldElement.hasFixedBackendName());
 
     ClassElement cls = fieldElement.getEnclosingClass();
     LibraryElement libraryElement = fieldElement.getLibrary();
     String libName = getName(libraryElement);
     String clsName = getName(cls);
     String instanceName = instanceFieldName(libraryElement, fieldElement.name);
     return getMappedInstanceName('$libName\$$clsName\$$instanceName');
   }
@@ skipping 230 matching lines @@
   }
 
   String safeName(String name) {
     if (jsReserved.contains(name) || name.startsWith('\$')) {
       name = "\$$name";
       assert(!jsReserved.contains(name));
     }
     return name;
   }
 }