Do not use the namer for naming closure elements.

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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  *
  * Names are generated through three stages:
@@ skipping 83 matching lines @@
  *    (The [getterPrefix] and [setterPrefix] are different in [MinifyNamer]).
  *
  * 3. The `is` and operator uses the following names:
  *
  *        $is<NAME>
  *        $as<NAME>
  *
  * For local variables, the [Namer] only provides *proposed names*. These names
  * must be disambiguated elsewhere.
  */
-class Namer implements ClosureNamer {
+class Namer {
 
   static const List<String> javaScriptKeywords = const <String>[
     // These are current keywords.
     "break", "delete", "function", "return", "typeof", "case", "do", "if",
     "switch", "var", "catch", "else", "in", "this", "void", "continue",
     "false", "instanceof", "throw", "while", "debugger", "finally", "new",
     "true", "with", "default", "for", "null", "try",
 
     // These are future keywords.
     "abstract", "double", "goto", "native", "static", "boolean", "enum",
@@ skipping 541 matching lines @@
     return _disambiguateGlobal(element);
   }
 
   /**
    * Returns the JavaScript property name used to store an instance field.
    */
   String instanceFieldPropertyName(Element element) {
     ClassElement enclosingClass = element.enclosingClass;
 
     if (element.hasFixedBackendName) {
-      // Box fields and certain native fields must be given a specific name.
-      // Native names must not contain '$'. We rely on this to avoid clashes.
-      assert(element is BoxFieldElement ||
-          enclosingClass.isNative && !element.fixedBackendName.contains(r'$'));
+      // Certain native fields must be given a specific name. Native names must
+      // not contain '$'. We rely on this to avoid clashes.
+      assert(enclosingClass.isNative &&
+             !element.fixedBackendName.contains(r'$'));
 
       return element.fixedBackendName;
     }
 
+    // Instances of BoxFieldElement are special. They are already created with
+    // a unique and safe 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. We still do not mark the name as a
+    // fixedBackendName, as we want to allow other namers to do something more
+    // clever with them.
+    if (element is BoxFieldElement) {
+      return element.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.
     ClassWorld classWorld = compiler.world;
     if (classWorld.isUsedAsMixin(enclosingClass) ||
         _isShadowingSuperField(element) ||
@@ skipping 281 matching lines @@
   /// If [name] is not an annotated name, the result will not be an annotated
   /// name either.
   String _sanitizeForNatives(String name) {
     if (!name.contains(r'$')) {
       // Prepend $$. The result must not coincide with an annotated name.
       name = '\$\$$name';
     }
     return name;
   }
 
-  /// Generate a unique name for the [id]th closure variable, with proposed name
-  /// [name].
-  ///
-  /// The result is used as the name of [BoxFieldElement]s and
-  /// [ClosureFieldElement]s, and must therefore be unique to avoid breaking an
-  /// invariant in the element model (classes cannot declare multiple fields
-  /// with the same name).
-  ///
-  /// Since the result is used as an element name, it will later show up as a
-  /// *proposed name* when the element is passed to [instanceFieldPropertyName].
-  String getClosureVariableName(String name, int id) {
-    return "${name}_$id";
-  }
-
   /**
    * Returns a proposed name for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
   String _proposeNameForGlobal(Element element) {
     assert(!element.isInstanceMember);
     String name;
     if (element.isGenerativeConstructor) {
       name = "${element.enclosingClass.name}\$"
              "${element.name}";
@@ skipping 770 matching lines @@
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }