Do not put renaming logic into Unparser.

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.
 
 const bool REMOVE_ASSERTS = false;
 
 class ElementAst {
   final Node ast;
   final TreeElements treeElements;
 
@@ skipping 405 matching lines @@
       topLevelNodes.add(elementAsts[element].ast);
       if (element is ClassElement) {
         final members = <Node>[];
         for (final member in sortedClassMembers[element]) {
           members.add(elementAsts[member].ast);
         }
         memberNodes[elementAsts[element].ast] = members;
       }
     }
 
-    final unparser = new Unparser.withRenamer((Node node) => renames[node]);
+    final unparser = new EmitterUnparser(renames);
     emitCode(unparser, imports, topLevelNodes, memberNodes);
     compiler.assembledCode = unparser.result;
 
     // Output verbose info about size ratio of resulting bundle to all
     // referenced non-platform sources.
     logResultBundleSizeInfo(topLevelElements);
   }
 
   void logResultBundleSizeInfo(Set<Element> topLevelElements) {
     Collection<LibraryElement> referencedLibraries =
         compiler.libraries.getValues().filter(isUserLibrary);
     // Sum total size of scripts in each referenced library.
     int nonPlatformSize = 0;
     for (LibraryElement lib in referencedLibraries) {
       for (CompilationUnitElement compilationUnit in lib.compilationUnits) {
         nonPlatformSize += compilationUnit.script.text.length;
       }
     }
     int percentage = compiler.assembledCode.length * 100 ~/ nonPlatformSize;
     log('Total used non-platform files size: ${nonPlatformSize} bytes, '
         'bundle size: ${compiler.assembledCode.length} bytes (${percentage}%)');
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }
 
+class EmitterUnparser extends Unparser {
+  final Map<Node, String> renames;
+
+  EmitterUnparser(this.renames);
+
+  visit(Node node) {
+    if (node !== null && renames.containsKey(node)) {
+      sb.add(renames[node]);
+    } else {
+      super.visit(node);
+    }
+  }
+
+  unparseSendReceiver(Send node, [bool spacesNeeded=false]) {
+    // TODO(smok): Remove ugly hack for library prefices.

[Roman, 2012/10/02 07:55:55]

prefixes ?

[Anton Muhin, 2012/10/02 08:48:42]

O tempora, o mores!

Let's wait for Peter's opinion.

On 2012/10/02 07:55:55, Roman wrote:

+    if (node.receiver !== null && renames[node.receiver] == '') return;

[ahe, 2012/10/02 14:27:39]

I'm not sure what problem this is solving. If you show me an example, perhaps I
have a suggestion for getting rid of it.

[Anton Muhin, 2012/10/02 14:32:15]

That'd be great, Peter.

The problem.  Imagine you use name with a prefix.  When we bundle the
application in a single file in most of the cases we want to delete this prefix
and emit the name w/o the prefix and that's the best way we came up by to
achieve that.

If notion of the name would have its own Send node, that is prefix.value = 1
would have translated into SendSet { target: Send { receiver: prefix, selector:
value }, value = 1 }, we could have renamed it at the level of nodes.

I'll submit this CL in ~20 mins after I ran the test.

On 2012/10/02 14:27:39, ahe wrote:

[ahe, 2012/10/09 07:40:59]

Anton, could you give me an example with actual code?

On 2012/10/02 14:32:15, Anton Muhin wrote:

[Anton Muhin, 2012/10/10 07:21:40]

I assume you're asking for code being transformed.  If not, I'll show how we do
it.

Imagine the code

import 'mylib.dart' as mylib;

main() {
  mylib.topLevelField = 13;
}

where mylib.dart is

int topLevelField = 42;

we'd like to emit (omitting renames):

topLevelField = 42;

main() {
  topLevelField = 13;
}

omitting the prefix.

Our whole renamer can rename the whole AST nodes---we have a map from a node to
string where most of those nodes are identifiers and sometimes it sends, Roma is
currently unifying it all.

However, in this case this would be a send set and there is no node to rename
to, so we need this special trick to mark AST node as one that should be
actually removed the input.

Does that make sense?

Is there simpler approach?

We're considering AST rewrites for those, fyi.


On 2012/10/09 07:40:59, ahe wrote:

+    super.unparseSendReceiver(node, spacesNeeded);
+  }
+}
+
+
 /**
  * Some elements are not recorded by resolver now,
  * for example, typedefs or classes which are only
  * used in signatures, as/is operators or in super clauses
  * (just to name a few).  Retraverse AST to pick those up.
  */
 class ReferencedElementCollector extends Visitor {
   final Compiler compiler;
   final Element rootElement;
   final TreeElements treeElements;
@@ skipping 46 matching lines @@
 }
 
 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);
 }
 
 List<Element> sortElements(Collection<Element> elements) =>
     sorted(elements, compareElements);