Rename members and named constructors.

lib/compiler/implementation/dart_backend/backend.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 DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final bool minify;
   final bool cutDeclarationTypes;
 
   Map<Element, TreeElements> get resolvedElements =>
       compiler.enqueuer.resolution.resolvedElements;
 
   DartBackend(Compiler compiler, this.minify, this.cutDeclarationTypes)
       : tasks = <CompilerTask>[],
       super(compiler);
 
-  void enqueueHelpers(Enqueuer world) { }
+  void enqueueHelpers(Enqueuer world) {
+    // Right now resolver doesn't always resolve interfaces needed
+    // for literals, so force them. TODO(antonm): fix in the resolver.
+    final LITERAL_TYPE_NAMES = const [
+      'Map', 'List', 'num', 'int', 'double', 'bool'
+    ];
+    final coreLibrary = compiler.coreLibrary;
+    for (final name in LITERAL_TYPE_NAMES) {
+      ClassElement classElement = coreLibrary.findLocal(new SourceString(name));
+      classElement.ensureResolved(compiler);
+    }
+  }
   void codegen(WorkItem work) { }
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) { }
 
   void assembleProgram() {
+    // 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.
+    final fixedMemberNames = new Set<String>();
+    for (final library in compiler.libraries.getValues()) {
+      if (!library.isPlatformLibrary) continue;
+      for (final element in library.localMembers) {
+        if (element is ClassElement) {
+          ClassElement classElement = element;
+          for (final member in classElement.localMembers) {
+            final name = member.name.slowToString();
+            // Skip operator names.
+            if (name.startsWith(@'operator$')) continue;
+            // 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(@'$').last());
+          }
+        } else {
+          fixedMemberNames.add(element.name.slowToString());
+        }
+      }
+    }
+    // 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');
+
     /**
      * Tells whether we should output given element. Corelib classes like
      * Object should not be in the resulting code.
      */
     final LIBS_TO_IGNORE = [
       compiler.jsHelperLibrary,
       compiler.interceptorsLibrary,
     ];
     bool shouldOutput(Element element) =>
       element.kind !== ElementKind.VOID &&
@@ skipping 49 matching lines @@
         processElement(element, treeElements);
       } else {
         if (!element.isTopLevel()) {
           compiler.cancel(reason: 'Cannot process $element', element: element);
         }
         addTopLevel(element, treeElements);
       }
     });
 
     // Create all necessary placeholders.
-    PlaceholderCollector collector = new PlaceholderCollector(compiler);
+    PlaceholderCollector collector =
+        new PlaceholderCollector(compiler, fixedMemberNames);
     makePlaceholders(element) {
       TreeElements treeElements = resolvedElements[element];
       if (treeElements === null) treeElements = emptyTreeElements;
       collector.collect(element, treeElements);
       if (element is ClassElement) {
         classMembers[element].forEach(makePlaceholders);
       }
     }
     topLevelElements.forEach(makePlaceholders);
 
     // Create renames.
     Map<Node, String> renames = new Map<Node, String>();
     Map<LibraryElement, String> imports = new Map<LibraryElement, String>();
     renamePlaceholders(
-        compiler, collector, renames, imports, minify, cutDeclarationTypes);
+        compiler, collector, renames, imports,
+        fixedMemberNames, minify, cutDeclarationTypes);
 
     // Sort elements.
     final sortedTopLevels = sortElements(topLevelElements);
     final sortedClassMembers = new Map<ClassElement, List<Element>>();
     classMembers.forEach((classElement, members) {
       sortedClassMembers[classElement] = sortElements(members);
     });
 
     final unparser = new Unparser.withRenamer((Node node) => renames[node]);
     compiler.assembledCode = emitCode(
@@ skipping 62 matching lines @@
 
 List<Element> sortElements(Collection<Element> elements) {
   compareElements(e0, e1) {
     int result = compareBy((e) => e.getLibrary().uri.toString())(e0, e1);
     if (result != 0) return result;
     return compareBy((e) => e.position().charOffset)(e0, e1);
   }
 
   return sorted(elements, compareElements);
 }