First take on support of library private names.

lib/compiler/implementation/dart_backend/renamer.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.
 
 class SendRenamer extends ResolvedVisitor<String> {
   final ConflictingRenamer renamer;
 
   SendRenamer(this.renamer, elements) : super(elements);
 
   String visitSuperSend(Send node) => null;
   String visitOperatorSend(Send node) => null;
   String visitClosureSend(Send node) => null;
-  String visitDynamicSend(Send node) => null;
   String visitForeignSend(Send node) => null;
 
+  String tryRenamePrivateId(Send node) {
+    Identifier selector = node.selector.asIdentifier();
+    assert(selector !== null);
+    String originalName = selector.source.slowToString();
+    if (originalName.startsWith('_')) {
+      String newName = renamer.renamePrivateId(
+          renamer.context.getLibrary(), originalName);
+      if (node.receiver !== null) {
+        // TODO: ugly, should be fixed with new renamer infrastructure.
+        String receiver = new Unparser(renamer).unparse(node.receiver);
+        newName = '$receiver.$newName';
+      }
+      return newName;
+    }
+
+    return null;
+  }
+
+  String visitDynamicSend(Send node) => tryRenamePrivateId(node);
+
   String visitGetterSend(Send node) {
     final element = elements[node];
-    if (element === null || !element.isTopLevel()) return null;
+    if (element === null || !element.isTopLevel()) {
+      return tryRenamePrivateId(node);
+    }
     return renamer.renameElement(element);
   }
 
   String visitStaticSend(Send node) {
     final element = elements[node];
 
     if (element.isTopLevel()) return renamer.renameElement(element);
 
     if (element.isGenerativeConstructor() || element.isFactoryConstructor()) {
       // Don't want to rename redirects to :this(args) or super calls.
@@ skipping 31 matching lines @@
 
 /**
  * Renames only top-level elements that would let to ambiguity if not renamed.
  * TODO(smok): Make sure that top-level fields are correctly renamed.
  */
 class ConflictingRenamer extends Renamer {
   final Compiler compiler;
   final Map<LibraryElement, Map<String, String>> renamed;
   final Set<String> usedTopLevelIdentifiers;
   final Map<LibraryElement, String> imports;
+  int privateNameCounter = 0;
   TreeElements contextElements;
   Element context;
 
   Map<Element, TreeElements> get resolvedElements() =>
       compiler.enqueuer.resolution.resolvedElements;
 
   ConflictingRenamer(this.compiler) :
       renamed = new Map<LibraryElement, Map<String, String>>(),
       usedTopLevelIdentifiers = new Set<String>(),
       imports = new Map<LibraryElement, String>();
@@ skipping 34 matching lines @@
       //      1.dart: interface C default p0.C { C(); }
       //    the second case is just a bug now.
       final enclosingClass = context.getEnclosingClass();
       if (node.token.slowToString() == enclosingClass.name.slowToString()) {
         // TODO: distinguish the case of constructor vs. nested named closure
         // (see function_syntax_test).
         // TODO: fix the bugs above and turn if into the assert.
         return renameElement(enclosingClass);
       }
     }
-    if (context.isFunction() && context.cachedNode.name == node) {
+    if (context.isFunction() && context.isTopLevel() &&
+        context.cachedNode.name == node) {
       return renameElement(context);
     }
+    // TODO: as the rest of renameIdentifier should go closer to
+    // Emitter.outputElement.
+    // Note: this code should only rename private identifiers for class'
+    // fields/getters/setters/methods.  Top-level identifiers are renamed
+    // just to escape conflicts and that should be enough as we shouldn't
+    // be able to resolve private identifiers for other libraries.
+    final originalName = node.source.slowToString();
+    if (originalName.startsWith('_')) {
+      return '${renamePrivateId(context.getLibrary(), originalName)}';
+    }
     return null;
   }
 
+  String getName(LibraryElement library, String originalName, renamer) =>
+      renamed.putIfAbsent(library, () => <String>{})
+          .putIfAbsent(originalName, renamer);
+
+  String renamePrivateId(LibraryElement library, String originalName) =>
+      getName(library, originalName,
+              () => '_${privateNameCounter++}${originalName}');
+
   String renameElement(Element element) {
+    assert(element.isTopLevel());
+
     // This comes from currently buggy TypeAnnotation renamer.
     // It should be solved in there and it will be solved with
     // new fancy renamer. TODO: remove this cruft.
     if (element === compiler.types.voidType.element) return null;
 
     // TODO(smok): Make sure that the new name does not conflict with existing
     // local identifiers.
     generateUniqueName(name) {
-      while (usedTopLevelIdentifiers.contains(name)) {
-        name = "p_$name";
-      }
+      while (usedTopLevelIdentifiers.contains(name)) name = 'p_$name';
       usedTopLevelIdentifiers.add(name);
       return name;
     }
 
     String originalName = element.name.slowToString();
-
-    // TODO(antonm): we should rename lib private names as well.
-    if (!element.isTopLevel()) return originalName;
-    final library = element.getLibrary();
+    LibraryElement library = element.getLibrary();
     if (library === compiler.coreLibrary) return originalName;
     if (isDartCoreLib(compiler, library)) {
       final prefix =
           imports.putIfAbsent(library, () => generateUniqueName('p'));
       return '$prefix.$originalName';
     }
 
-    return renamed.putIfAbsent(library, () => <String>{})
-        .putIfAbsent(originalName, () => generateUniqueName(originalName));
+    return getName(library, originalName,
+                   () => generateUniqueName(originalName));
   }
 }