Revert "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;
-  ClosureTask(Compiler compiler)
+  ClosureNamer namer;
+  ClosureTask(Compiler compiler, this.namer)
       : 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);
+          new ClosureTranslator(compiler, elements, closureMappingCache, namer);
 
       // 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);
-
-  /// 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).
-  ///
-  /// 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 "${outermostElement.name}_${name}_$id";
-  }
+                    this.closureMappingCache,
+                    this.namer);
 
   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 = getClosureVariableName(capturedLocal.name, id);
+        String name = namer.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 208 matching lines @@
   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 =
-              getClosureVariableName('box', closureFieldCounter++);
+              namer.getClosureVariableName('box', closureFieldCounter++);
           box = new BoxLocal(boxName, executableContext);
         }
         String elementName = variable.name;
         String boxedName =
-            getClosureVariableName(elementName, boxedFieldCounter++);
+            namer.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);
       }
     }
 
@@ skipping 234 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;
   }
 }