Handle platform access through prefix in dart2dart

pkg/compiler/lib/src/dart_backend/outputter.dart

 // Copyright (c) 2014, 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;
 
 typedef bool IsSafeToRemoveTypeDeclarations(
     Map<ClassElement, Iterable<Element>> classMembers);
 typedef void ElementCallback<E>(E element);
 typedef void ElementPostProcessFunction(
@@ skipping 137 matching lines @@
   static PlaceholderCollector collectPlaceholders(
       DiagnosticListener listener,
       MirrorRenamer mirrorRenamer,
       FunctionElement mainFunction,
       LibraryInfo libraryInfo,
       ElementInfo elementInfo) {
     // Create all necessary placeholders.
     PlaceholderCollector collector = new PlaceholderCollector(
         listener,
         mirrorRenamer,
-        libraryInfo.fixedMemberNames,
+        libraryInfo.fixedDynamicNames,
         elementInfo.elementAsts,
         mainFunction);
 
     makePlaceholders(element) {
       collector.collect(element);
 
       if (element.isClass) {
         elementInfo.classMembers[element].forEach(makePlaceholders);
       }
     }
     elementInfo.topLevelElements.forEach(makePlaceholders);
     return collector;
   }
 
   static PlaceholderRenamer createRenamer(
       PlaceholderCollector collector,
       LibraryInfo libraryInfo,
       ElementInfo elementInfo,
       {bool enableMinification: false,
        bool forceStripTypes: false,
        isSafeToRemoveTypeDeclarations}) {
     // Create renames.
     bool shouldCutDeclarationTypes = forceStripTypes
         || (enableMinification
             && isSafeToRemoveTypeDeclarations(elementInfo.classMembers));
 
     PlaceholderRenamer placeholderRenamer = new PlaceholderRenamer(
-        libraryInfo.fixedMemberNames, libraryInfo.reexportingLibraries,
+        libraryInfo.fixedDynamicNames,
+        libraryInfo.fixedStaticNames,
+        libraryInfo.reexportingLibraries,
         cutDeclarationTypes: shouldCutDeclarationTypes,
         enableMinification: enableMinification);
 
     placeholderRenamer.computeRenames(collector);
     return placeholderRenamer;
   }
 
   static String astOutput(DiagnosticListener listener,
                           ElementInfo elementInfo) {
     // TODO(antonm): Ideally XML should be a separate backend.
@@ skipping 11 matching lines @@
         elementInfo.classMembers[topLevel].forEach(outputElement);
       } else {
         outputElement(topLevel);
       }
     }
     return '<Program>\n$sb</Program>\n';
   }
 }
 
 class LibraryInfo {
-  final Set<String> fixedMemberNames;
+  final Set<String> fixedStaticNames;
+  final Set<String> fixedDynamicNames;
   final Map<Element, LibraryElement> reexportingLibraries;
   final List<LibraryElement> userLibraries;
 
-  LibraryInfo(this.fixedMemberNames,
+  LibraryInfo(this.fixedStaticNames,
+              this.fixedDynamicNames,
               this.reexportingLibraries,
               this.userLibraries);
 
   static LibraryInfo processLibraries(
       Iterable<LibraryElement> libraries,
       Iterable<AstElement> resolvedElements) {
-    Set<String> fixedMemberNames = new Set<String>();
+    Set<String> fixedStaticNames = new Set<String>();
+    Set<String> fixedDynamicNames = new Set<String>();
     Map<Element, LibraryElement> reexportingLibraries =
           <Element, LibraryElement>{};
     List<LibraryElement> userLibraries = <LibraryElement>[];
     // Conservatively traverse all platform libraries and collect member names.
     // TODO(antonm): ideally we should only collect names of used members,
     // however as of today there are problems with names of some core library
     // interfaces, most probably for interfaces of literals.
 
     for (LibraryElement library in libraries) {
       if (!library.isPlatformLibrary) {
         userLibraries.add(library);
         continue;
       }
       library.forEachLocalMember((Element element) {
         if (element.isClass) {
           ClassElement classElement = element;
           assert(invariant(classElement, classElement.isResolved,
               message: "Unresolved platform class."));
           classElement.forEachLocalMember((member) {
-            String name = member.name;
-            // Skip operator names.
-            if (!name.startsWith(r'operator$')) {
-              // Fetch name of named constructors and factories if any,
-              // otherwise store regular name.
-              // TODO(antonm): better way to analyze the name.
-              fixedMemberNames.add(name.split(r'$').last);
+            if (member.isInstanceMember) {
+              fixedDynamicNames.add(member.name);
+            } else {
+              fixedStaticNames.add(member.name);
             }
           });
         }
         // Even class names are added due to a delicate problem we have:
         // if one imports dart:core with a prefix, we cannot tell prefix.name
         // from dynamic invocation (alas!).  So we'd better err on preserving
         // those names.
-        fixedMemberNames.add(element.name);
+        fixedStaticNames.add(element.name);
       });
 
       for (Element export in library.exports) {
         if (!library.isInternalLibrary &&
             export.library.isInternalLibrary) {
           // If an element of an internal library is reexported by a platform
           // library, we have to import the reexporting library instead of the
           // internal library, because the internal library is an
           // implementation detail of dart2js.
           reexportingLibraries[export] = library;
         }
       }
     }
     // As of now names of named optionals are not renamed. Therefore add all
     // field names used as named optionals into [fixedMemberNames].
     for (final element in resolvedElements) {
       if (!element.isConstructor) continue;
       Link<Element> optionalParameters =
           element.functionSignature.optionalParameters;
       for (final optional in optionalParameters) {
         if (!optional.isInitializingFormal) continue;
-        fixedMemberNames.add(optional.name);
+        fixedDynamicNames.add(optional.name);
       }
     }
     // The VM will automatically invoke the call method of objects
     // that are invoked as functions. Make sure to not rename that.
-    fixedMemberNames.add('call');
-    // TODO(antonm): TypeError.srcType and TypeError.dstType are defined in
-    // runtime/lib/error.dart. Overall, all DartVM specific libs should be
-    // accounted for.
-    fixedMemberNames.add('srcType');
-    fixedMemberNames.add('dstType');
+    fixedDynamicNames.add('call');
 
     return new LibraryInfo(
-        fixedMemberNames, reexportingLibraries, userLibraries);
+        fixedStaticNames, fixedDynamicNames,
+        reexportingLibraries, userLibraries);
   }
 }
 
 class ElementInfo {
   final Map<Element, ElementAst> elementAsts;
   final Iterable<Element> topLevelElements;
   final Map<ClassElement, Iterable<Element>> classMembers;
   final Iterable<ClassElement> emitNoMembersFor;
 
   ElementInfo(this.elementAsts,
@@ skipping 207 matching lines @@
               ? "${outputPaths[libraryElement]}.dart"
               : libraryElement.canonicalUri.toString();
           if (dependency is Import) {
             unparser.unparseImportTag(uri);
           } else {
             unparser.unparseExportTag(uri);
           }
         }
       }
     } else {
-      for(LibraryElement library in placeholderRenamer.platformImports) {
-        if (library.isPlatformLibrary && !library.isInternalLibrary) {
-          mainUnparser.unparseImportTag(library.canonicalUri.toString());
+      placeholderRenamer.platformImports.forEach(
+          (LibraryElement library, String prefix) {
+        assert(library.isPlatformLibrary && !library.isInternalLibrary);
+        mainUnparser.unparseImportTag(library.canonicalUri.toString());
+        if (prefix != null) {
+          // Adding a prefixed import because (some) top-level access need
+          // it to avoid shadowing.
+          // TODO(johnniwinther): Avoid prefix-less import if not needed.
+          mainUnparser.unparseImportTag(library.canonicalUri.toString(),
+                                        prefix: prefix);
         }
-      }
+      });
     }
 
     for (int i = 0; i < elementInfo.topLevelElements.length; i++) {
       Element element = elementInfo.topLevelElements.elementAt(i);
       Node node = topLevelNodes[i];
       Unparser unparser = multiFile ? unparsers[element.library] : mainUnparser;
       if (node is ClassNode) {
         // TODO(smok): Filter out default constructors here.
         unparser.unparseClassWithBody(node, memberNodes[node]);
       } else {
@@ skipping 18 matching lines @@
       outputProvider("", "dart")
            ..add(code)
            ..close();
 
       totalSize = code.length;
     }
 
     return totalSize;
   }
 }