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 12 matching lines @@
       }
       // Prefix the name with '$' if it is reserved.
       if (jsReserved.contains(name)) {
         name = "\$$name";
         assert(!jsReserved.contains(name));
       }
       return name;
     }
   }
 
+  String _computeFreshGlobalName(Element element) {

[ngeoffray, 2012/02/16 12:38:46]

I would remove this method, it's only called once, and we always want to have a
'guess' for an element, so line 134 (old revision) should be kept.

[floitsch, 2012/02/16 13:43:07]

Done.

+    String guess = _computeGuess(element);
+    return getFreshGlobalName(guess);
+  }
+  
   String getBailoutName(Element element) {
     return '${getName(element)}\$bailout';
   }
 
   /**
    * 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
@@ skipping 15 matching lines @@
       } else if (element.kind == ElementKind.SETTER) {
         return setterName(element.name);
       } else {
         return instanceFieldName(element.name);
       }
     } else {
       // Dealing with a top-level or static element.
       String cached = globals[element];
       if (cached !== null) return cached;
 
-      String guess = _computeGuess(element);
       switch (element.kind) {
         case ElementKind.VARIABLE:
         case ElementKind.PARAMETER:
           // The name is not guaranteed to be unique.
-          return guess;
+          return _computeGuess(element);
 
         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 = _computeFreshGlobalName(element);
+          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)}';
   }
 }