dart2dart: Introduce Renamer that is used by renaming unparser

lib/compiler/implementation/tree/unparser.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 Unparser implements Visitor {
+  final Renamer renamer;

[ahe, 2012/10/01 11:27:27]

I'm not really comfortable with this addition. The unparser is used by dart2js
for debugging and testing. Renaming is not something that the unparser should be
dealing with.

I think renaming can be handled by a subclass of Unparser.

[Anton Muhin, 2012/10/01 13:10:08]

I agree with you, Peter, see https://chromiumcodereview.appspot.com/10905019/

Let me discuss it with Roma once again

On 2012/10/01 11:27:27, ahe wrote:

[ahe, 2012/10/01 13:22:42]

Thank you, good that we agree on the long term direction.

On 2012/10/01 13:10:08, Anton Muhin wrote:

   StringBuffer sb;
 
-  Unparser();
+  Unparser([this.renamer = const Renamer()]);
 
   String unparse(Node node) {
     sb = new StringBuffer();
     visit(node);
     return sb.toString();
   }
 
   void add(SourceString string) {
     string.printOn(sb);
   }
@@ skipping 91 matching lines @@
       visit(send.selector);
     } else {
       visit(node.name);
     }
     visit(node.parameters);
     visit(node.initializers);
     visit(node.body);
   }
 
   visitIdentifier(Identifier node) {
-    add(node.token.value);
+    String newName = renamer.renameIdentifier(node);
+    if (newName == null) {
+      add(node.token.value);
+    } else {
+      sb.add(newName);
+    }
   }
 
   visitIf(If node) {
     add(node.ifToken.value);
     visit(node.condition);
     visit(node.thenPart);
     if (node.hasElsePart) {
       add(node.elseToken.value);
       sb.add(' ');
       visit(node.elsePart);
@@ skipping 45 matching lines @@
     sb.add(' ');
     visit(node.elements);
   }
 
   visitModifiers(Modifiers node) => node.visitChildren(this);
 
   /**
    * Unparses given NodeList starting from specific node.
    */
   unparseNodeListFrom(NodeList node, Link<Node> from) {
+    if (from.isEmpty()) return;
     String delimiter = (node.delimiter === null) ? " " : "${node.delimiter} ";
-    from.printOn(sb, delimiter);
+    visit(from.head);
+    for (Link link = from.tail; !link.isEmpty(); link = link.tail) {
+      sb.add(delimiter);
+      visit(link.head);
+    }
   }
 
   visitNodeList(NodeList node) {
     if (node.beginToken !== null) add(node.beginToken.value);
     if (node.nodes !== null) {
       unparseNodeListFrom(node, node.nodes);
     }
     if (node.endToken !== null) add(node.endToken.value);
   }
 
@@ skipping 26 matching lines @@
       }
     }
     if (!node.isPrefix && !node.isIndex) {
       visit(node.selector);
     }
     if (isCheck) {
       sb.add(' ');
     }
   }
 
-  visitSend(Send node) {
+  unparseSend(Send node) {
     unparseSendPart(node);
     visit(node.argumentsNode);
   }
 
+  visitSend(Send node) {
+    String newMethodName = renamer.renameSendMethod(node);
+    if (newMethodName !== null) {
+      sb.add(newMethodName);
+      visit(node.argumentsNode);
+    } else {
+      unparseSendPart(node);
+      visit(node.argumentsNode);
+    }
+  }
+
   /**
    * Special case for assignments like "list[0] = 1".
    */
   unparseIndexedSet(SendSet node) {
     if (node.isPrefix) {
       add(node.assignmentOperator.token.value);
     }
     visit(node.receiver);
     sb.add('[');
     sb.add(node.arguments.head);
@@ skipping 22 matching lines @@
   visitThrow(Throw node) {
     add(node.throwToken.value);
     if (node.expression !== null) {
       sb.add(' ');
       visit(node.expression);
     }
     node.endToken.value.printOn(sb);
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
-    node.visitChildren(this);
+    String newName = renamer.renameTypeName(node);
+    if (newName !== null) {
+      sb.add(newName);
+      visit(node.typeArguments);
+    } else {
+      // Fallback to default unparse without renaming.
+      node.visitChildren(this);
+    }
   }
 
   visitTypeVariable(TypeVariable node) {
     visit(node.name);
     if (node.bound !== null) {
       sb.add(' extends ');
       visit(node.bound);
     }
   }
 
@@ skipping 180 matching lines @@
       sb.add(' ');
     }
     visit(node.name);
     if (node.typeParameters !== null) {
       visit(node.typeParameters);
     }
     visit(node.formals);
     add(node.endToken.value);
   }
 }