Handle platform access through prefix in dart2dart

pkg/compiler/lib/src/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.
 
 part of dart_backend;
 
 Comparator get _compareNodes =>
     compareBy((n) => n.getBeginToken().charOffset);
 
 abstract class Renamable implements Comparable {
@@ skipping 54 matching lines @@
     return placeholderRenamer._generateUniqueTopLevelName("");
   }
 }
 
 /**
  * Renames only top-level elements that would lead to ambiguity if not renamed.
  */
 class PlaceholderRenamer {
   /// After running [computeRenames] this will contain the computed renames.
   final Map<Node, String> renames = new Map<Node, String>();
-  /// After running [computeRenames] this will contain the used platform
-  /// libraries.
-  final Set<LibraryElement> platformImports = new Set<LibraryElement>();
+  /// After running [computeRenames] this will map the used platform
+  /// libraries to their respective prefixes.
+  final Map<LibraryElement, String> platformImports =
+      <LibraryElement, String>{};
 
   final bool enableMinification;
-  final Set<String> fixedMemberNames;
+  final Set<String> fixedDynamicNames;
+  final Set<String> fixedStaticNames;
   final Map<Element, LibraryElement> reexportingLibraries;
   final bool cutDeclarationTypes;
 
   final Map<Entity, String> _renamedCache = new Map<Entity, String>();
   final Map<Entity, Map<String, String>> _privateCache =
       new Map<Entity, Map<String, String>>();
 
   // Identifiers that has already been used, or are reserved by the
   // language/platform.
   Set<String> _forbiddenIdentifiers;
   Set<String> _allNamedParameterIdentifiers;
 
   Generator _generator;
 
-  PlaceholderRenamer(this.fixedMemberNames,
+  PlaceholderRenamer(this.fixedDynamicNames,
+                     this.fixedStaticNames,
                      this.reexportingLibraries,
                      {this.enableMinification, this.cutDeclarationTypes});
 
   void _renameNodes(Iterable<Node> nodes, String renamer(Node node)) {
     for (Node node in sorted(nodes, _compareNodes)) {
       renames[node] = renamer(node);
     }
   }
 
-  String _generateUniqueTopLevelName(originalName) {
+  String _generateUniqueTopLevelName(String originalName) {
     String newName = _generator.generate(originalName, (name) {
       return _forbiddenIdentifiers.contains(name) ||
              _allNamedParameterIdentifiers.contains(name);
     });
     _forbiddenIdentifiers.add(newName);
     return newName;
   }
 
   String _generateMemberName(String original) {
     return _generator.generate(original, _forbiddenIdentifiers.contains);
@@ skipping 19 matching lines @@
            Elements.isErroneousElement(entity) ||
            Elements.isStaticOrTopLevel(entity) ||
            entity is TypeVariableElement);
     // TODO(smok): We may want to reuse class static field and method names.
     if (entity is Element) {
       LibraryElement library = entity.library;
       if (reexportingLibraries.containsKey(entity)) {
         library = reexportingLibraries[entity];
       }
       if (library.isPlatformLibrary) {
-        if (library.canonicalUri != Compiler.DART_CORE) {
-          platformImports.add(library);
-        }
+        // TODO(johnniwinther): Handle prefixes for dart:core.
+        if (library.canonicalUri == Compiler.DART_CORE) return entity.name;
         if (library.isInternalLibrary) {
           throw new SpannableAssertionFailure(entity,
               "Internal library $library should never have been imported from "
               "the code compiled by dart2dart.");
         }
+
+        String prefix = platformImports.putIfAbsent(library, () => null);
+        if (entity.isTopLevel &&
+            fixedDynamicNames.contains(entity.name)) {
+          if (prefix == null) {
+            prefix = _generateUniqueTopLevelName('');
+            platformImports[library] = prefix;
+          }
+          return '$prefix.${entity.name}';
+        }
         return entity.name;
       }
     }
     String name = _renamedCache.putIfAbsent(entity,
             () => _generateUniqueTopLevelName(entity.name));
     // Look up in [_renamedCache] for a name for [entity] .
     // If it was not renamed before, generate a new name.
     return name;
   }
 
@@ skipping 91 matching lines @@
   /// Finds renamings for all the placeholders in [placeholderCollector] and
   /// stores them in [renames].
   /// Also adds to [platformImports] all the platform-libraries that are used.
   void computeRenames(PlaceholderCollector placeholderCollector) {
     _allNamedParameterIdentifiers = new Set<String>();
     for (FunctionScope functionScope in
         placeholderCollector.functionScopes.values) {
       _allNamedParameterIdentifiers.addAll(functionScope.parameterIdentifiers);
     }
 
-    _forbiddenIdentifiers = new Set<String>.from(fixedMemberNames);
+    _forbiddenIdentifiers = new Set<String>.from(fixedDynamicNames);
+    _forbiddenIdentifiers.addAll(fixedStaticNames);
     _forbiddenIdentifiers.addAll(Keyword.keywords.keys);
     _forbiddenIdentifiers.add('main');
 
     if (enableMinification) {
       _computeMinifiedRenames(placeholderCollector);
     } else {
       _computeNonMinifiedRenames(placeholderCollector);
     }
 
     // Rename constructors.
@@ skipping 78 matching lines @@
   MinifyingGenerator();
 
   String generate(String originalName, bool isForbidden(String name)) {
     String result;
     do {
       result = generateMiniId(index++);
     } while (isForbidden(result));
     return result;
   }
 }