A visitor that builds a map from node to "Usage".

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.
 
+// Returns null if no need to rename a node.
+typedef String Renamer(Node node);
+
 class Unparser implements Visitor {
-  final Renamer renamer;
+  Renamer rename;

[Anton Muhin, 2012/08/08 08:27:20]

why it's not final any more?

[Roman, 2012/08/09 05:02:35]

Done.

   StringBuffer sb;
 
-  Unparser([this.renamer = const Renamer()]);
+  Unparser() : this.withRenamer((Node) => null);
+  Unparser.withRenamer(this.rename);
 
   String unparse(Node node) {
     sb = new StringBuffer();
     visit(node);
     return sb.toString();
   }
 
   void add(SourceString string) {
     string.printOn(sb);
   }
 
   void addToken(Token token) {
     if (token === null) return;
     add(token.value);
     if (token.kind === KEYWORD_TOKEN || token.kind === IDENTIFIER_TOKEN) {
       sb.add(' ');
     }
   }
 
   visit(Node node) {
-    if (node !== null) node.accept(this);
+    if (node === null) return;
+    String renamed = rename(node);
+    if (renamed !== null) {
+      sb.add(renamed);
+    } else {
+      // Fallback.
+      node.accept(this);
+    }
   }
 
   visitBlock(Block node) {
     visit(node.statements);
   }
 
   visitCascade(Cascade node) {
     visit(node.expression);
   }
 
@@ skipping 58 matching lines @@
       sb.add(' ');
     }
     if (node.getOrSet !== null) {
       add(node.getOrSet.value);
       sb.add(' ');
     }
     // TODO(antonm): that's a workaround as currently FunctionExpression
     // names are modelled with Send and it emits operator[] as only
     // operator, without [] which are expected to be emitted with
     // arguments.
-    emitName(Identifier name) {
-      final newName = renamer.renameIdentifier(name);
-      if (newName === null) {
-        visit(name);
-      } else {
-        sb.add(newName);
-      }
-    }
     if (node.name is Send) {
       Send send = node.name;
       assert(send is !SendSet);
       if (!send.isOperator) {
         // Looks like a factory method.
-        emitName(send.receiver);
+        visit(send.receiver);
         sb.add('.');
       } else {
         visit(send.receiver);
         if (send.selector.token.kind === KEYWORD_TOKEN) sb.add(' ');
       }
       visit(send.selector);
     } else {
-      if (node.name !== null) emitName(node.name);
+      if (node.name !== null) visit(node.name);

[Anton Muhin, 2012/08/08 08:27:20]

no need in !== null check, but after rebase this diff should go away.

     }
     visit(node.parameters);
     visit(node.initializers);
     visit(node.body);
   }
 
   visitIdentifier(Identifier node) {
     add(node.token.value);
   }
 
@@ skipping 89 matching lines @@
   }
 
   unparseSendPart(Send node) {
     Operator op = node.selector.asOperator();
     bool spacesNeeded = op !== null &&
         (op.source.stringValue === 'is' || op.source.stringValue == 'as');
 
     if (node.isPrefix) {
       visit(node.selector);
     }
-    if (node.receiver !== null) {
+    // TODO(smok): Remove ugly hack for library preferences.
+    // Check that renamer does not want to omit receiver at all,
+    // in that case we don't need spaces or dot.
+    if (node.receiver !== null && rename(node.receiver) != '') {
       visit(node.receiver);
       CascadeReceiver asCascadeReceiver = node.receiver.asCascadeReceiver();
       if (asCascadeReceiver !== null) {
         add(asCascadeReceiver.cascadeOperator.value);
       } else if (op === null) {
         sb.add('.');
       } else if (spacesNeeded) {
         sb.add(' ');
       }
     }
     if (!node.isPrefix && !node.isIndex) {
       visit(node.selector);
     }
     if (spacesNeeded) {
       sb.add(' ');
     }
   }
 
   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);
-    }
+    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);
@@ skipping 28 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) {
-    String newName = renamer.renameTypeName(node);
-    if (newName !== null) {
-      sb.add(newName);
-      visit(node.typeArguments);
-    } else {
-      // Fallback to default unparse without renaming.
-      node.visitChildren(this);
-    }
+    visit(node.typeName);

[Anton Muhin, 2012/08/08 08:27:20]

what about TODO as was discussed before?

[Roman, 2012/08/09 05:02:35]

As discussed, keeping as is.

+    visit(node.typeArguments);
   }
 
   visitTypeVariable(TypeVariable node) {
     visit(node.name);
     if (node.bound !== null) {
       sb.add(' extends ');
       visit(node.bound);
     }
   }
 
@@ skipping 171 matching lines @@
       sb.add(' ');
     }
     visit(node.name);
     if (node.typeParameters !== null) {
       visit(node.typeParameters);
     }
     visit(node.formals);
     add(node.endToken.value);
   }
 }