Support implicitly bound closures (aka. tear-off closures).

frog/leg/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.
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer {
   final Compiler compiler;
 
@@ skipping 46 matching lines @@
   }
 
   String setterName(SourceString name) {
     return 'set\$$name';
   }
 
   String getterName(SourceString name) {
     return 'get\$$name';
   }
 
+  String getFreshGlobalName(String proposedName) {
+    int usedCount = usedGlobals[proposedName];
+    if (usedCount === null) {
+      // No element with this name has been used before.
+      usedGlobals[proposedName] = 1;
+      return proposedName;
+    } else {
+      // Not the first time we see this name. Append a number to make it unique.
+      String name;
+      do {
+        usedCount++;
+        name = '$proposedName$usedCount';
+      } while (usedGlobals[name] !== null);
+      usedGlobals[proposedName] = usedCount;
+      return name;
+    }
+  }
+
   /**
    * Returns a preferred JS-id for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
   String _computeGuess(Element element) {
     assert(!element.isInstanceMember());
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       FunctionElement functionElement = element;
       return instanceMethodName(
           element.name, functionElement.parameterCount(compiler));
@@ skipping 26 matching lines @@
   /**
    * Returns a preferred JS-id for the given element. The returned id is
    * guaranteed to be a valid JS-id. Globals and static fields are furthermore
    * guaranteed to be unique.
    *
    * For accessing statics consider calling
    * [isolateAccess]/[isolateBailoutAccess] or [isolatePropertyAccess] instead.
    */
   String getName(Element element) {
     if (element.isInstanceMember()) {
-      SourceString name;
       if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
         ConstructorBodyElement bodyElement = element;
         SourceString name = bodyElement.constructor.name;
         return instanceMethodName(name, bodyElement.parameterCount(compiler));
       } else if (element.kind == ElementKind.FUNCTION) {
         FunctionElement functionElement = element;
         return instanceMethodName(
             element.name, functionElement.parameterCount(compiler));
       } else if (element.kind == ElementKind.GETTER) {
         return getterName(element.name);
@@ skipping 13 matching lines @@
         case ElementKind.PARAMETER:
           // The name is not guaranteed to be unique.
           return guess;
 
         case ElementKind.GENERATIVE_CONSTRUCTOR:
         case ElementKind.FUNCTION:
         case ElementKind.CLASS:
         case ElementKind.FIELD:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
-          // We need to make sure the name is unique.
-          int usedCount = usedGlobals[guess];
-          if (usedCount === null) {
-            // No element with this name has been used before.
-            usedGlobals[guess] = 1;
-            globals[element] = guess;
-            return guess;
-          } else {
-            // Not the first time we see an element with this name. Append a
-            // number to make it unique.
-            String name;
-            do {
-              usedCount++;
-              name = '$guess$usedCount';
-            } while (usedGlobals[name] !== null);
-            usedGlobals[guess] = usedCount;
-            globals[element] = name;
-            return name;
-          }
+          String result = getFreshGlobalName(guess);
+          globals[element] = result;
+          return result;
 
         default:
           compiler.internalError('getName for unknown kind: ${element.kind}',
                                  node: element.parseNode(compiler));
       }
     }
   }
 
   String isolateAccess(Element element) {
     return "$CURRENT_ISOLATE.${getName(element)}";
   }
 
   String isolatePropertyAccess(Element element) {
     return "$ISOLATE.prototype.${getName(element)}";
   }
 
   String isolateBailoutPropertyAccess(Element element) {
     return '${isolatePropertyAccess(element)}\$bailout';
   }
 
   String isolateBailoutAccess(Element element) {
     return '${isolateAccess(element)}\$bailout';
   }
 
   String operatorIs(ClassElement element) {
     return 'is\$${getName(element)}';
   }
 }