Do not use the namer for naming closure elements.

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 closureToClassMapper;
 
 import "elements/elements.dart";
 import "dart2jslib.dart";
 import "dart_types.dart";
 import "js_backend/js_backend.dart" show JavaScriptBackend;
 import "scanner/scannerlib.dart" show Token;
 import "tree/tree.dart";
 import "util/util.dart";
 import "elements/modelx.dart"
     show BaseFunctionElementX,
          ClassElementX,
          ElementX,
          LocalFunctionElementX;
 import "elements/visitor.dart" show ElementVisitor;
 
 import 'universe/universe.dart' show
     Universe;
 
-class ClosureNamer {
-  String getClosureVariableName(String name, int id) {
-    return "${name}_$id";
-  }
-
-  void forgetElement(Element element) {}
-}
-
 class ClosureTask extends CompilerTask {
   Map<Node, ClosureClassMap> closureMappingCache;
-  ClosureNamer namer;
-  ClosureTask(Compiler compiler, this.namer)
+  ClosureTask(Compiler compiler)
       : closureMappingCache = new Map<Node, ClosureClassMap>(),
         super(compiler);
 
   String get name => "Closure Simplifier";
 
   ClosureClassMap computeClosureToClassMapping(Element element,
                                                Node node,
                                                TreeElements elements) {
     return measure(() {
       ClosureClassMap cached = closureMappingCache[node];
       if (cached != null) return cached;
 
       ClosureTranslator translator =
-          new ClosureTranslator(compiler, elements, closureMappingCache, namer);
+          new ClosureTranslator(compiler, elements, closureMappingCache);
 
       // The translator will store the computed closure-mappings inside the
       // cache. One for given node and one for each nested closure.
       if (node is FunctionExpression) {
         translator.translateFunction(element, node);
       } else if (element.isSynthesized) {
         return new ClosureClassMap(null, null, null, new ThisLocal(element));
       } else {
         assert(element.isField);
         VariableElement field = element;
@@ skipping 24 matching lines @@
   void forgetElement(var closure) {
     ClosureClassElement cls;
     if (closure is ClosureFieldElement) {
       cls = closure.closureClass;
     } else if (closure is SynthesizedCallMethodElementX) {
       cls = closure.closureClass;
     } else {
       throw new SpannableAssertionFailure(
           closure, 'Not a closure: $closure (${closure.runtimeType}).');
     }
-    namer.forgetElement(cls);
     compiler.enqueuer.codegen.forgetElement(cls);
   }
 }
 
 /// Common interface for [BoxFieldElement] and [ClosureFieldElement] as
 /// non-elements.
 abstract class CapturedVariable {}
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
@@ skipping 347 matching lines @@
   // Keep track of the mutated local variables so that we don't need to box
   // non-mutated variables.
   Set<LocalVariableElement> mutatedVariables = new Set<LocalVariableElement>();
 
   MemberElement outermostElement;
   ExecutableElement executableContext;
 
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
-  ClosureNamer namer;
-
   bool insideClosure = false;
 
   ClosureTranslator(this.compiler,
                     this.elements,
-                    this.closureMappingCache,
-                    this.namer);
+                    this.closureMappingCache);
+
+  /// Generate a unique name for the [id]th closure field, with proposed name
+  /// [name].
+  ///
+  /// The result is used as the name of [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).
+  ///
+  /// Also, the names should be distinct from real field names to prevent
+  /// clashes with selectors for those fields.
+  String getClosureVariableName(String name, int id) {
+    return "_captured_${name}_$id";
+  }
+
+  /// Generate a unique name for the [id]th box field, with proposed name
+  /// [name].
+  ///
+  /// The result is used as the name of [BoxFieldElement]s, and must
+  /// therefore be unique to avoid breaking an invariant in the element model
+  /// (classes cannot declare multiple fields with the same name).
+  ///
+  /// Also, the names should be distinct from real field names to prevent
+  /// clashes with selectors for those fields.
+  String getBoxFieldName(int id) {
+    return "_box_$id";
+  }
 
   bool isCapturedVariable(Local element) {
     return _capturedVariableMapping.containsKey(element);
   }
 
   void addCapturedVariable(Node node, Local variable) {
     if (_capturedVariableMapping[variable] != null) {
       compiler.internalError(node, 'In closure analyzer.');
     }
     _capturedVariableMapping[variable] = null;
@@ skipping 82 matching lines @@
           return 1;
         } else if (b is Element) {
           return -1;
         } else {
           return a.name.compareTo(b.name);
         }
       }
 
       for (Local capturedLocal in fieldCaptures.toList()..sort(compareLocals)) {
         int id = closureFieldCounter++;
-        String name = namer.getClosureVariableName(capturedLocal.name, id);
+        String name = getClosureVariableName(capturedLocal.name, id);
         addClosureField(capturedLocal, name);
       }
       closureClass.reverseBackendMembers();
     }
   }
 
   void useLocal(Local variable) {
     // If the element is not declared in the current function and the element
     // is not the closure itself we need to mark the element as free variable.
     // Note that the check on [insideClosure] is not just an
@@ skipping 207 matching lines @@
   // The boxed variables are updated in the [capturedVariableMapping].
   void attachCapturedScopeVariables(Node node) {
     BoxLocal box = null;
     Map<LocalVariableElement, BoxFieldElement> scopeMapping =
         new Map<LocalVariableElement, BoxFieldElement>();
 
     void boxCapturedVariable(LocalVariableElement variable) {
       if (isCapturedVariable(variable)) {
         if (box == null) {
           // TODO(floitsch): construct better box names.
-          String boxName =
-              namer.getClosureVariableName('box', closureFieldCounter++);
+          String boxName = getBoxFieldName(closureFieldCounter++);
           box = new BoxLocal(boxName, executableContext);
         }
         String elementName = variable.name;
         String boxedName =
-            namer.getClosureVariableName(elementName, boxedFieldCounter++);
+            getClosureVariableName(elementName, boxedFieldCounter++);
         // TODO(kasperl): Should this be a FieldElement instead?
         BoxFieldElement boxed = new BoxFieldElement(boxedName, variable, box);
-        // No need to rename the fields of a box, so we give them a native name
-        // right now.
-        boxed.setFixedBackendName(boxedName);
         scopeMapping[variable] = boxed;
         setCapturedVariableBoxField(variable, boxed);
       }
     }
 
     for (LocalVariableElement variable in scopeVariables) {
       // No need to box non-assignable elements.
       if (!variable.isAssignable) continue;
       if (!mutatedVariables.contains(variable)) continue;
       boxCapturedVariable(variable);
@@ skipping 229 matching lines @@
 
   String get name => typeVariable.name;
 
   int get hashCode => typeVariable.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableLocal) return false;
     return typeVariable == other.typeVariable;
   }
 }