Assign a short name to private variables (first one wins).

lib/compiler/implementation/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;
 
   static final CLOSURE_INVOCATION_NAME = const SourceString('\$call');
   static final OPERATOR_EQUALS = const SourceString('operator\$eq');
 
   static Set<String> _jsReserved = null;
   Set<String> get jsReserved() {
     if (_jsReserved === null) {
       _jsReserved = new Set<String>();
       _jsReserved.addAll(JsNames.javaScriptKeywords);
       _jsReserved.addAll(JsNames.reservedPropertySymbols);
     }
     return _jsReserved;
   }
 
   Map<Element, String> globals;
   Map<String, int> usedGlobals;
+  Map<String, LibraryElement> shortPrivateNameOwners;
 
   Namer(this.compiler)
       : globals = new Map<Element, String>(),
-        usedGlobals = new Map<String, int>();
+        usedGlobals = new Map<String, int>(),
+        shortPrivateNameOwners = new Map<String, LibraryElement>();
 
   final String CURRENT_ISOLATE = "\$";
   final String ISOLATE = "Isolate";
   final String ISOLATE_PROPERTIES = "\$isolateProperties";
 
 
   String closureInvocationName(Selector selector) {
     // TODO(floitsch): mangle, while not conflicting with instance names.
     return instanceMethodInvocationName(null, CLOSURE_INVOCATION_NAME,
                                         selector);
   }
 
   String privateName(LibraryElement lib, SourceString name) {
+    bool canNotClashWithMangledPrivateNames(String proposedName) {

[ngeoffray, 2012/05/10 14:20:41]

I'd inline the closure, and add a comment instead of encoding the comment in the
closure name.

[floitsch, 2012/05/10 14:33:01]

Done.

+      return !proposedName.startsWith('_$LIBRARY_PREFIX');
+    }
+
     if (name.isPrivate()) {
-      return '_${getName(lib)}${name.slowToString()}';
+      String nameString = name.slowToString();
+
+      // The first library asking for a short private name wins.
+      LibraryElement owner =
+          shortPrivateNameOwners.putIfAbsent(nameString, () => lib);
+      if (owner === lib && canNotClashWithMangledPrivateNames(nameString)) {
+        return nameString;
+      }
+      String libName = getName(lib);
+      // If a library name does not start with the [LIBRARY_PREFIX] then our
+      // assumptions about clashing with mangled private members does not hold.
+      assert(libName.startsWith(LIBRARY_PREFIX));
+      return '_$libName$nameString';
     } else {
-      return '${name.slowToString()}';
+      return name.slowToString();
     }
   }
 
   String instanceMethodName(LibraryElement lib, SourceString name, int arity) {
     return '${privateName(lib, name)}\$$arity';
   }
 
   String instanceMethodInvocationName(LibraryElement lib, SourceString name,
                                       Selector selector) {
     // TODO(floitsch): mangle, while preserving uniqueness.
@@ skipping 34 matching lines @@
       String name;
       do {
         usedCount++;
         name = '$proposedName$usedCount';
       } while (usedGlobals[name] !== null);
       usedGlobals[proposedName] = usedCount;
       return name;
     }
   }
 
+  static final String LIBRARY_PREFIX = "lib";
+
   /**
    * 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());
     LibraryElement lib = element.getLibrary();
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       FunctionElement functionElement = element;
       return instanceMethodName(lib, element.name,
                                 functionElement.parameterCount(compiler));
     } else {
       // TODO(floitsch): deal with named constructors.
       String name;
       if (Elements.isStaticOrTopLevel(element)) {
         name = element.name.slowToString();
       } else if (element.kind == ElementKind.GETTER) {
         name = getterName(lib, element.name);
       } else if (element.kind == ElementKind.SETTER) {
         name = setterName(lib, element.name);
       } else if (element.kind == ElementKind.FUNCTION) {
         FunctionElement functionElement = element;
         name = element.name.slowToString();
         name = '$name\$${functionElement.parameterCount(compiler)}';
       } else if (element.kind === ElementKind.LIBRARY) {
-        name = 'lib';
+        name = LIBRARY_PREFIX;
       } else {
         name = element.name.slowToString();
       }
       // Prefix the name with '$' if it is reserved.
       return safeName(name);
     }
   }
 
   String getBailoutName(Element element) {
     return '${getName(element)}\$bailout';
@@ skipping 78 matching lines @@
   }
 
   String safeName(String name) {
     if (jsReserved.contains(name) || name.startsWith('\$')) {
       name = "\$$name";
       assert(!jsReserved.contains(name));
     }
     return name;
   }
 }