dart2dart: Introduce Renamer that is used by renaming unparser

lib/compiler/implementation/dart_backend/emitter.dart

Index: lib/compiler/implementation/dart_backend/emitter.dart
diff --git a/lib/compiler/implementation/dart_backend/emitter.dart b/lib/compiler/implementation/dart_backend/emitter.dart
index 8d177aa82afbf6f4ed5f02f756afe6cace6b72a3..82c79e70d04d6559e0d2dbd7a3feb11f956e6c7d 100644
--- a/lib/compiler/implementation/dart_backend/emitter.dart
+++ b/lib/compiler/implementation/dart_backend/emitter.dart
@@ -9,33 +9,44 @@ class Emitter {
 
   final Compiler compiler;
   final StringBuffer sb;
+  final Renamer renamer;
 
-  Emitter(this.compiler) : sb = new StringBuffer();
+  Emitter(Compiler compiler) :
+      this.compiler = compiler,
+      sb = new StringBuffer(),
+      renamer = new ConflictingRenamer(compiler);
 
   /**
    * Outputs given class element with selected inner elements.
    */
   void outputClass(ClassElement classElement, Set<Element> innerElements) {
+    Unparser unparser = new Unparser(renamer);
+    renamer.setContext(classElement.getCompilationUnit());
     ClassNode classNode = classElement.parseNode(compiler);
     sb.add(classElement.beginToken.slowToString());  // 'class' or 'interface'.
     sb.add(' ');
-    sb.add(classNode.name.unparse());
+    sb.add(renamer.renameType(classElement.type));
     if (classNode.typeParameters !== null) {
-      sb.add(classNode.typeParameters.unparse());
+      sb.add(unparser.unparse(classNode.typeParameters));
     }
     if (classNode.extendsKeyword !== null) {
       sb.add(' ');
       classNode.extendsKeyword.value.printOn(sb);
       sb.add(' ');
-      sb.add(classNode.superclass.unparse());
+      sb.add(renamer.renameType(classElement.supertype));
     }
     if (!classNode.interfaces.isEmpty()) {
       sb.add(classElement.isInterface() ? ' extends ' : ' implements ');
-      classNode.interfaces.nodes.printOn(sb, classNode.interfaces.delimiter);
+      Link<Node> interfaceNodes = classNode.interfaces.nodes;

[Anton Muhin, 2012/07/23 17:58:54]

your modified version of NodeList processing, won't it cover this case?  I mean
won't unparser.unparse(classNode.interfaces) just work?

[Roman, 2012/07/24 08:22:49]

Unfortunately, unparse() for NodeList first prints out begin token (which is
'extends' or 'implements') and then, without any whitespaces, a list of unparsed
nodes. So it would be 'extendsA,B,C'. 

[Anton Muhin, 2012/07/24 08:43:58]

Shouldn't that be fixed?

[Roman, 2012/07/24 08:58:04]

It is not clear that it's a bug. Usually node list is something like parameters
for a function, e.g. foo(a,b,c), or a list of statements in a function body, you
don't need whitespaces there.

[Roman, 2012/07/24 08:58:54]

For a case of whitespaces there is no beginToken I guess, so that example is
bad.

[Anton Muhin, 2012/07/24 09:00:10]

I think it should be fixed even if (for now) we'll output unnecessary space: I
believe unparse should be able to treat any node list correctly at node list
level.

On 2012/07/24 08:58:54, Roman wrote:

[Roman, 2012/07/24 10:37:04]

I was wrong, 'extends' or 'implements' is not part of interfaces nodelist. So I
just changed this part to unparser.unparse(classNode.interfaces);

[Anton Muhin, 2012/07/24 10:46:50]

thanks a lot!

On 2012/07/24 10:37:04, Roman wrote:

+      sb.add(unparser.unparse(interfaceNodes.head));
+      for (Link link = interfaceNodes.tail; !link.isEmpty(); link = link.tail) {
+        sb.add(classNode.interfaces.delimiter);
+        sb.add(unparser.unparse(link.head));
+      }
     }
     if (classNode.defaultClause !== null) {
       sb.add(' default ');
-      sb.add(classNode.defaultClause.unparse());
+      sb.add(unparser.unparse(classNode.defaultClause));
     }
     sb.add('{');
     innerElements.forEach((element) {
@@ -46,15 +57,17 @@ class Emitter {
   }
 
   void outputElement(Element element) {
+    Unparser unparser = new Unparser(renamer);
+    renamer.setContext(element);
     // TODO(smok): Figure out why AbstractFieldElement appears here,
     // we have used getters/setters resolved instead of it.
     if (element is SynthesizedConstructorElement
         || element is AbstractFieldElement) return;
     if (element.isField()) {
       assert(element is VariableElement);
-      sb.add(element.variables.parseNode(compiler).unparse());
+      sb.add(unparser.unparse(element.variables.parseNode(compiler)));
     } else {
-      sb.add(element.parseNode(compiler).unparse());
+      sb.add(unparser.unparse(element.parseNode(compiler)));
     }
   }