Move namer into javascript backend.

lib/compiler/implementation/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("leg.dart");
 #import("scanner/scannerlib.dart");
 #import("tree/tree.dart");
@@ skipping 426 matching lines @@
          link = link.tail) {
       Node definition = link.head;
       Element element = elements[definition];
       if (capturedVariableMapping.containsKey(element)) {
         result.add(element);
       };
     }
     scopeData.boxedLoopVariables = result;
   }
 
+  /** Returns a non-unique name for the given closure element. */
+  String closureName(Element element) {

[floitsch, 2012/09/05 21:27:46]

code directly copied from the Namer.

The name given to the closure class is independent from the namer (think
minifying or pretty-printing namer), and since the type-analysis uses the this
class too, it doesn't make sense to add a dependency on the backend.

+    List<String> parts = <String>[];
+    SourceString ownName = element.name;
+    if (ownName == null || ownName.stringValue == "") {
+      parts.add("anon");
+    } else {
+      parts.add(ownName.slowToString());
+    }
+    for (Element enclosingElement = element.enclosingElement;
+         enclosingElement != null &&
+             (enclosingElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
+              || enclosingElement.kind === ElementKind.CLASS
+              || enclosingElement.kind === ElementKind.FUNCTION
+              || enclosingElement.kind === ElementKind.GETTER
+              || enclosingElement.kind === ElementKind.SETTER);
+         enclosingElement = enclosingElement.enclosingElement) {
+      SourceString surroundingName = enclosingElement.name;
+      if (surroundingName != null) {
+        String surroundingNameString = surroundingName.slowToString();
+        if (surroundingNameString != "") parts.add(surroundingNameString);
+      }
+    }
+    // Invert the parts.
+    for (int i = 0, j = parts.length - 1; i < j; i++, j--) {
+      var tmp = parts[i];
+      parts[i] = parts[j];
+      parts[j] = tmp;
+    }
+    return Strings.join(parts, "_");
+  }
+
   ClosureClassMap globalizeClosure(FunctionExpression node, Element element) {
-    SourceString closureName =
-        new SourceString(compiler.namer.closureName(element));
+    SourceString closureName = new SourceString(closureName(element));
     ClassElement globalizedElement = new ClosureClassElement(
         closureName, compiler, element, element.getCompilationUnit());
     FunctionElement callElement =
-        new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME,
+        new FunctionElement.from(Compiler.CALL_OPERATOR_NAME,
                                  element,
                                  globalizedElement);
     globalizedElement.backendMembers =
         const EmptyLink<Element>().prepend(callElement);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     Element thisElement = closureData.thisElement;
     return new ClosureClassMap(element, globalizedElement,
                                callElement, thisElement);
   }
@@ skipping 88 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }