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;
+  final Renamer rename;
   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 79 matching lines @@
       visit(send.selector);
     } else {
       visit(node.name);
     }
     visit(node.parameters);
     visit(node.initializers);
     visit(node.body);
   }
 
   visitIdentifier(Identifier node) {
-    String newName = renamer.renameIdentifier(node);
-    if (newName === null) {
-      add(node.token.value);
-    } else {
-      sb.add(newName);
-    }
+    add(node.token.value);
   }
 
   visitIf(If node) {
     add(node.ifToken.value);
     visit(node.condition);
     visit(node.thenPart);
     if (node.hasElsePart) {
       addToken(node.elseToken);
       visit(node.elsePart);
     }
@@ skipping 81 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);
+    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);
   }
 }