Some enhancements of PrettyPrinter for NodeList, LiteralList.

lib/compiler/implementation/tree/prettyprint.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.
 
 /**
  * Pretty-prints Node tree in XML-like format.
  *
  * TODO(smok): Add main() to run from command-line to print out tree for given
  * .dart file.
  */
@@ skipping 52 matching lines @@
   }
 
   void addTypeWithParams(String type, [Map params]) {
     if (nextTypePrefix !== null) {
       sb.add(nextTypePrefix);
       nextTypePrefix = null;
     }
     sb.add("${type}");
     if (params != null) {
       // TODO(smok): Escape doublequotes in values.
-      params.forEach((k, v) => sb.add(' $k="$v"'));
+      params.forEach((k, v) {
+        sb.add(' $k=');
+        if (v !== null) {
+          sb.add('"$v"');
+        } else {
+          sb.add('null');
+        }
+      });
     }
   }
 
   void addCurrentIndent() {
     for (int i = 0; i < depth; i++) {
       sb.add(INDENT);
     }
   }
 
   /**
@@ skipping 101 matching lines @@
   }
 
   visitLiteralDouble(LiteralDouble node) {
     visitLiteral(node, "LiteralDouble");
   }
 
   visitLiteralInt(LiteralInt node) {
     visitLiteral(node, "LiteralInt");
   }
 
+  /** Returns token string value or [null] if token is [null]. */
+  tokenToStringOrNull(Token token) {
+    if (token == null) {

[Anton Muhin, 2012/07/06 10:19:07]

nit: === instead of == and single line:

if (token === null) return null;

Another option:

tTSON(Token token) => token === null ? null : token.stringValue;

[Roman, 2012/07/06 11:28:32]

Done.

+      return null;
+    }
+    return token.stringValue;
+  }
+
   visitLiteralList(LiteralList node) {
-    visitNodeWithChildren(node, "LiteralList");
+    openNode("LiteralList", {
+      "constKeyword" : tokenToStringOrNull(node.constKeyword)
+    });
+    visitWithPrefix(node.type, "type:");
+    visitWithPrefix(node.elements, "elements:");
+    closeNode("LiteralList");
   }
 
   visitLiteralMap(LiteralMap node) {
     visitNodeWithChildren(node, "LiteralMap");
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visitNodeWithChildren(node, "LiteralMapEntry");
   }
 
@@ skipping 11 matching lines @@
 
   visitNamedArgument(NamedArgument node) {
     visitNodeWithChildren(node, "NamedArgument");
   }
 
   visitNewExpression(NewExpression node) {
     visitNodeWithChildren(node, "NewExpression");
   }
 
   visitNodeList(NodeList node) {
+    var params = {
+        "delimiter" : node.delimiter != null ? node.delimiter.stringValue : null,

[Anton Muhin, 2012/07/06 10:19:07]

nit: !==

And apparently you can use your function above for it.

[Roman, 2012/07/06 11:28:32]

Done. delimiter is a SourceString, not a Token.

+        "beginToken" : tokenToStringOrNull(node.beginToken),
+        "endToken" : tokenToStringOrNull(node.endToken)};
     if (node.nodes.toList().length == 0) {
-      openAndCloseNode("NodeList");
+      openAndCloseNode("NodeList", params);
     } else {
-      visitNodeWithChildren(node, "NodeList");
+      openNode("NodeList", params);
+      node.visitChildren(this);
+      closeNode("NodeList");
     }
   }
 
   visitOperator(Operator node) {
     openAndCloseNode("Operator", {"value" : node.token.slowToString()});
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visitNodeWithChildren(node, "ParenthesizedExpression");
   }
 
   visitReturn(Return node) {
     var beginToken =
         node.beginToken !== null ? node.beginToken.stringValue : "null";
     var endToken = node.endToken !== null ? node.endToken.stringValue : "null";
     openNode("Return", {"beginToken" : beginToken, "endToken" : endToken});
-    if (node.hasExpression) visitWithPrefix(node.expression, "expression:");
+    visitWithPrefix(node.expression, "expression:");
     closeNode("Return");
   }
 
   visitScriptTag(ScriptTag node) {
     visitNodeWithChildren(node, "ScriptTag");
   }
 
   /** Custom helper to visit given node and print its type with prefix. */
   visitWithPrefix(Node node, String prefix) {
-    nextTypePrefix = prefix;
-    node.accept(this);
+    if (node !== null) {

[Anton Muhin, 2012/07/06 10:19:07]

another option: if (node === null) return;

[Roman, 2012/07/06 11:28:32]

Done.

+      nextTypePrefix = prefix;
+      node.accept(this);
+    }
   }
 
   openSendNodeWithFields(Send node, String type) {
     openNode(type, {
         "isPrefix" : "${node.isPrefix}",
         "isPostfix" : "${node.isPostfix}",
         "isIndex" : "${node.isIndex}"
     });
-    if (node.receiver !== null) visitWithPrefix(node.receiver, "receiver:");
-    if (node.selector !== null) visitWithPrefix(node.selector, "selector:");
-    if (node.argumentsNode !== null)
-        visitWithPrefix(node.argumentsNode, "argumentsNode:");
+    visitWithPrefix(node.receiver, "receiver:");
+    visitWithPrefix(node.selector, "selector:");
+    visitWithPrefix(node.argumentsNode, "argumentsNode:");
   }
 
   visitSend(Send node) {
     openSendNodeWithFields(node, "Send");
     closeNode("Send");
   }
 
   visitSendSet(SendSet node) {
     openSendNodeWithFields(node, "SendSet");
-    if (node.assignmentOperator !== null)
-        visitWithPrefix(node.assignmentOperator, "assignmentOperator:");
+    visitWithPrefix(node.assignmentOperator, "assignmentOperator:");
     closeNode("SendSet");
   }
 
   visitStringInterpolation(StringInterpolation node) {
     visitNodeWithChildren(node, "StringInterpolation");
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     visitNodeWithChildren(node, "StringInterpolationPart");
   }
@@ skipping 24 matching lines @@
 
   visitTypedef(Typedef node) {
     visitNodeWithChildren(node, "Typedef");
   }
 
   visitTypeVariable(TypeVariable node) {
     visitNodeWithChildren(node, "TypeVariable");
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
-    visitNodeWithChildren(node, "VariableDefinitions");
+    openNode("VariableDefinitions", {
+      "beginToken" : "${node.getBeginToken().stringValue}",
+      "endToken" : "${node.endToken.stringValue}"

[Anton Muhin, 2012/07/06 10:19:07]

that applies to the diff above as well: I believe you should stick to
get{Begin,End}Token.

[Roman, 2012/07/06 11:28:32]

Done. Changed everywhere.

+    });
+    visitWithPrefix(node.type, "type:");
+    visitWithPrefix(node.modifiers, "modifiers:");
+    visitWithPrefix(node.definitions, "definitions:");
+    closeNode("VariableDefinitions");
   }
 
   visitWhile(While node) {
     visitNodeWithChildren(node, "While");
   }
 }