Get back recording 'implements' and 'extends' keyword on NodeList

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;
   StringBuffer sb;
 
   Unparser([this.renamer = const Renamer()]);
 
   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);
   }
 
   visitBlock(Block node) {
     visit(node.statements);
   }
 
   visitCascade(Cascade node) {
     visit(node.expression);
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
   }
 
   visitClassNode(ClassNode node) {
-    node.beginToken.value.printOn(sb);
-    sb.add(' ');
+    addToken(node.beginToken);
     visit(node.name);
     sb.add(' ');
     if (node.extendsKeyword !== null) {
-      node.extendsKeyword.value.printOn(sb);
-      sb.add(' ');
+      addToken(node.extendsKeyword);
       visit(node.superclass);
       sb.add(' ');
     }
     visit(node.interfaces);
     if (node.defaultClause !== null) {
       visit(node.defaultClause);
       sb.add(' ');
     }
     sb.add('{\n');
     sb.add('}\n');
@@ skipping 58 matching lines @@
       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);

[ahe, 2012/08/03 06:46:43]

Long term, consider if this is simpler using addToken here. With the current
implementation, that would sometimes add extra spaces, but you could change
addToken to something like:

bool previousTokenRequiresSpace = false;
void addToken(Token token) {
  if (token === null) return;
  bool requiresSpace = token.kind === KEYWORD_TOKEN || token.kind ===
IDENTIFIER_TOKEN;
  if (previousTokenRequiresSpace && requiresSpace) {
    sb.add(' ');
  }
  previousTokenRequiresSpace = requiresSpace;
  add(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(' ');
+      addToken(node.elseToken);
       visit(node.elsePart);
     }
   }
 
   visitLiteralBool(LiteralBool node) {
     add(node.token.value);
   }
 
   visitLiteralDouble(LiteralDouble node) {
     add(node.token.value);
@@ skipping 15 matching lines @@
     visit(node.first);
     sb.add(" ");
     visit(node.second);
   }
 
   visitLiteralNull(LiteralNull node) {
     add(node.token.value);
   }
 
   visitNewExpression(NewExpression node) {
     // TODO(ahe): handle 'const'.

[ahe, 2012/08/03 06:46:43]

Is this TODO obsolete?

[Roman, 2012/08/03 08:02:19]

I guess so. Removed.

-    add(node.newToken.value);
-    sb.add(' ');
+    addToken(node.newToken);
     visit(node.send);
   }
 
   visitLiteralList(LiteralList node) {
-    if (node.constKeyword !== null) {
-      add(node.constKeyword.value);
-    }
+    addToken(node.constKeyword);
     if (node.type !== null) {
       sb.add('<');
       visit(node.type);
       sb.add('>');
     }
-    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}";
     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.beginToken !== null) addToken(node.beginToken);
     if (node.nodes !== null) {
       unparseNodeListFrom(node, node.nodes);
     }
     if (node.endToken !== null) add(node.endToken.value);
   }
 
   visitOperator(Operator node) {
     visitIdentifier(node);
   }
 
@@ skipping 122 matching lines @@
       visit(node.type);
       sb.add(' ');
     }
     visit(node.definitions);
     if (node.endToken.value == const SourceString(';')) {
       add(node.endToken.value);
     }
   }
 
   visitDoWhile(DoWhile node) {
-    add(node.doKeyword.value);
-    sb.add(' ');
+    addToken(node.doKeyword);
     visit(node.body);
     sb.add(' ');
-    add(node.whileKeyword.value);
-    sb.add(' ');
+    addToken(node.whileKeyword);
     visit(node.condition);
     sb.add(node.endToken.value);
   }
 
   visitWhile(While node) {
-    add(node.whileKeyword.value);
-    sb.add(' ');
+    addToken(node.whileKeyword);
     visit(node.condition);
     sb.add(' ');
     visit(node.body);
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     add(node.getBeginToken().value);
     visit(node.expression);
     add(node.getEndToken().value);
   }
@@ skipping 29 matching lines @@
 
   visitContinueStatement(ContinueStatement node) {
     visitGotoStatement(node);
   }
 
   visitForIn(ForIn node) {
     add(node.forToken.value);
     sb.add(' (');
     visit(node.declaredIdentifier);
     sb.add(' ');
-    add(node.inToken.value);
-    sb.add(' ');
+    addToken(node.inToken);
     visit(node.expression);
     sb.add(') ');
     visit(node.body);
   }
 
   visitLabel(Label node) {
     visit(node.identifier);
     add(node.colonToken.value);
    }
 
@@ skipping 18 matching lines @@
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.name);
     add(node.colonToken.value);
     sb.add(' ');
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    add(node.switchKeyword.value);
-    sb.add(' ');
+    addToken(node.switchKeyword);
     visit(node.parenthesizedExpression);
     sb.add(' ');
     visit(node.cases);
   }
 
   visitSwitchCase(SwitchCase node) {
     visit(node.labelsAndCases);
     if (node.isDefaultCase) {
       sb.add('default:');
     }
     visit(node.statements);
   }
 
   visitScriptTag(ScriptTag node) {
     add(node.beginToken.value);
     visit(node.tag);
     sb.add('(');
     visit(node.argument);
     if (node.prefixIdentifier !== null) {
       visit(node.prefixIdentifier);
       sb.add(': ');
       visit(node.prefix);
     }
     sb.add(')');
     add(node.endToken.value);
   }
 
   visitTryStatement(TryStatement node) {
-    add(node.tryKeyword.value);
-    sb.add(' ');
+    addToken(node.tryKeyword);
     visit(node.tryBlock);
     visit(node.catchBlocks);
     if (node.finallyKeyword !== null) {
       sb.add(' ');
-      add(node.finallyKeyword.value);
-      sb.add(' ');
+      addToken(node.finallyKeyword);
       visit(node.finallyBlock);
     }
   }
 
   visitCaseMatch(CaseMatch node) {
     add(node.caseKeyword.value);
     sb.add(" ");
     visit(node.expression);
     add(node.colonToken.value);
   }
 
   visitCatchBlock(CatchBlock node) {
-    add(node.catchKeyword.value);
-    sb.add(' ');
+    addToken(node.catchKeyword);
     visit(node.formals);
     sb.add(' ');
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
-    add(node.typedefKeyword.value);
-    sb.add(' ');
+    addToken(node.typedefKeyword);
     if (node.returnType !== null) {
       visit(node.returnType);
       sb.add(' ');
     }
     visit(node.name);
     if (node.typeParameters !== null) {
       visit(node.typeParameters);
     }
     visit(node.formals);
     add(node.endToken.value);
   }
 }