Produce better XML, one which cannot be analysed with tools like BaseX.

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.
  */
 class PrettyPrinter implements Visitor {
 
   /** String used to represent one level of indent. */
   static const String INDENT = "  ";
 
   StringBuffer sb;
-  int depth;
-  /** Prefix for the type passed to the next [openNode()] call. */
-  String nextTypePrefix;
-  /** Nodes that were opened with [openNode()] calls. */
-  Link<String> currentNodeTypes;
+  Link<String> tagStack;
 
   PrettyPrinter() :
       sb = new StringBuffer(),
-      depth = 0,
-      currentNodeTypes = new EmptyLink<String>();
+      tagStack = new EmptyLink<String>();
 
-  void pushCurrentNodeType(String nodeType) {
-    currentNodeTypes = currentNodeTypes.prepend(nodeType);
+  void pushTag(String tag) {
+    tagStack = tagStack.prepend(tag);
   }
 
-  String popCurrentNodeType() {
-    assert(!currentNodeTypes.isEmpty());
-    String currentNodeType = currentNodeTypes.head;
-    currentNodeTypes = currentNodeTypes.tail;
-    return currentNodeType;
+  String popTag() {
+    assert(!tagStack.isEmpty());
+    String tag = tagStack.head;
+    tagStack = tagStack.tail;
+    return tag;
   }
 
   /**
    * Adds given string to result string.
    */
   void add(SourceString string) {
     string.printOn(sb);
   }
 
   void addBeginAndEndTokensToParams(Node node, Map params) {
     params['getBeginToken'] = tokenToStringOrNull(node.getBeginToken());
     params['getEndToken'] = tokenToStringOrNull(node.getEndToken());
   }
 
   /**
-   * Adds given node type to result string, increasing current depth by 1.
+   * Adds given node type to result string.
    * The method "opens" the node, meaning that all output after calling
    * this method and before calling closeNode() will represent contents
    * of given node.
    */
   void openNode(Node node, String type, [Map params]) {
     if (params === null) params = new Map();
     addCurrentIndent();
     sb.add("<");
     addBeginAndEndTokensToParams(node, params);
     addTypeWithParams(type, params);
     sb.add(">\n");
-    pushCurrentNodeType(type);
-    depth++;
+    pushTag(type);
   }
 
   /**
-   * Adds given node to result string, depth is not affected.
+   * Adds given node to result string.
    */
   void openAndCloseNode(Node node, String type, [Map params]) {
     if (params === null) params = new Map();
     addCurrentIndent();
     sb.add("<");
     addBeginAndEndTokensToParams(node, params);
     addTypeWithParams(type, params);
     sb.add("/>\n");
   }
 
   /**
-   * Closes current node type, decreasing current depth by 1.
+   * Closes current node type.
    */
   void closeNode() {
-    depth--;
+    String tag = popTag();
     addCurrentIndent();
     sb.add("</");
-    addTypeWithParams(popCurrentNodeType());
+    addTypeWithParams(tag);
     sb.add(">\n");
   }
 
   void addTypeWithParams(String type, [Map params]) {
     if (params === null) params = new Map();
-    if (nextTypePrefix !== null) {
-      sb.add(nextTypePrefix);
-      nextTypePrefix = null;
-    }
     sb.add("${type}");
-    // TODO(smok): Escape doublequotes in values.
     params.forEach((k, v) {
-      sb.add(' $k=');
+      String value;
       if (v !== null) {
-        sb.add('"$v"');
+        value = v
+            .replaceAll("<", "&lt;")
+            .replaceAll(">", "&gt;")
+            .replaceAll('"', "'");
       } else {
-        sb.add('null');
+        value = "[null]";
       }
+      sb.add(' $k="$value"');
     });
   }
 
   void addCurrentIndent() {
-    for (int i = 0; i < depth; i++) {
-      sb.add(INDENT);
-    }
+    tagStack.forEach((_) { sb.add(INDENT); });
   }
 
   /**
    * Pretty-prints given node tree into string.
    */
   static String prettyPrint(Node node) {
     var p = new PrettyPrinter();
     node.accept(p);
     return p.sb.toString();
   }
@@ skipping 25 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visitNodeWithChildren(node, "CatchBlock");
   }
 
   visitClassNode(ClassNode node) {
     openNode(node, "ClassNode", {
       "extendsKeyword" : tokenToStringOrNull(node.extendsKeyword)
     });
-    visitWithPrefix(node.name, "name:");
-    visitWithPrefix(node.superclass, "superclass:");
-    visitWithPrefix(node.interfaces, "interfaces:");
-    visitWithPrefix(node.typeParameters, "typeParameters:");
-    visitWithPrefix(node.defaultClause, "defaultClause:");
+    visitChildNode(node.name, "name");
+    visitChildNode(node.superclass, "superclass");
+    visitChildNode(node.interfaces, "interfaces");
+    visitChildNode(node.typeParameters, "typeParameters");
+    visitChildNode(node.defaultClause, "defaultClause");
     closeNode();
   }
 
   visitConditional(Conditional node) {
     visitNodeWithChildren(node, "Conditional");
   }
 
   visitContinueStatement(ContinueStatement node) {
     visitNodeWithChildren(node, "ContinueStatement");
   }
@@ skipping 19 matching lines @@
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitNodeWithChildren(node, "FunctionDeclaration");
   }
 
   visitFunctionExpression(FunctionExpression node) {
     openNode(node, "FunctionExpression", {
       "getOrSet" : tokenToStringOrNull(node.getOrSet)
     });
-    visitWithPrefix(node.modifiers, "modifiers:");
-    visitWithPrefix(node.returnType, "returnType:");
-    visitWithPrefix(node.name, "name:");
-    visitWithPrefix(node.parameters, "parameters:");
-    visitWithPrefix(node.initializers, "initializers:");
-    visitWithPrefix(node.body, "body:");
+    visitChildNode(node.modifiers, "modifiers");
+    visitChildNode(node.returnType, "returnType");
+    visitChildNode(node.name, "name");
+    visitChildNode(node.parameters, "parameters");
+    visitChildNode(node.initializers, "initializers");
+    visitChildNode(node.body, "body");
     closeNode();
   }
 
   visitIdentifier(Identifier node) {
     openAndCloseNode(node, "Identifier", {"token" : node.token.slowToString()});
   }
 
   visitIf(If node) {
     visitNodeWithChildren(node, "If");
   }
@@ skipping 23 matching lines @@
     visitLiteral(node, "LiteralInt");
   }
 
   /** Returns token string value or [null] if token is [null]. */
   tokenToStringOrNull(Token token) => token === null ? null : token.stringValue;
 
   visitLiteralList(LiteralList node) {
     openNode(node, "LiteralList", {
       "constKeyword" : tokenToStringOrNull(node.constKeyword)
     });
-    visitWithPrefix(node.typeArguments, "typeArguments:");
-    visitWithPrefix(node.elements, "elements:");
+    visitChildNode(node.typeArguments, "typeArguments");
+    visitChildNode(node.elements, "elements");
     closeNode();
   }
 
   visitLiteralMap(LiteralMap node) {
     visitNodeWithChildren(node, "LiteralMap");
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visitNodeWithChildren(node, "LiteralMapEntry");
   }
@@ skipping 36 matching lines @@
   visitOperator(Operator node) {
     openAndCloseNode(node, "Operator", {"value" : node.token.slowToString()});
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visitNodeWithChildren(node, "ParenthesizedExpression");
   }
 
   visitReturn(Return node) {
     openNode(node, "Return");
-    visitWithPrefix(node.expression, "expression:");
+    visitChildNode(node.expression, "expression");
     closeNode();
   }
 
   visitScriptTag(ScriptTag node) {
     visitNodeWithChildren(node, "ScriptTag");
   }
 
-  /** Custom helper to visit given node and print its type with prefix. */
-  visitWithPrefix(Node node, String prefix) {
+  visitChildNode(Node node, String fieldName) {
     if (node === null) return;
-    nextTypePrefix = prefix;
+    addCurrentIndent();
+    sb.add("<$fieldName>\n");
+    pushTag(fieldName);
     node.accept(this);
+    popTag();
+    addCurrentIndent();
+    sb.add("</$fieldName>\n");
   }
 
   openSendNodeWithFields(Send node, String type) {
     openNode(node, type, {
         "isPrefix" : "${node.isPrefix}",
         "isPostfix" : "${node.isPostfix}",
         "isIndex" : "${node.isIndex}"
     });
-    visitWithPrefix(node.receiver, "receiver:");
-    visitWithPrefix(node.selector, "selector:");
-    visitWithPrefix(node.argumentsNode, "argumentsNode:");
+    visitChildNode(node.receiver, "receiver");
+    visitChildNode(node.selector, "selector");
+    visitChildNode(node.argumentsNode, "argumentsNode");
   }
 
   visitSend(Send node) {
     openSendNodeWithFields(node, "Send");
     closeNode();
   }
 
   visitSendSet(SendSet node) {
     openSendNodeWithFields(node, "SendSet");
-    visitWithPrefix(node.assignmentOperator, "assignmentOperator:");
+    visitChildNode(node.assignmentOperator, "assignmentOperator");
     closeNode();
   }
 
   visitStringInterpolation(StringInterpolation node) {
     visitNodeWithChildren(node, "StringInterpolation");
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     visitNodeWithChildren(node, "StringInterpolationPart");
   }
@@ skipping 13 matching lines @@
   visitThrow(Throw node) {
     visitNodeWithChildren(node, "Throw");
   }
 
   visitTryStatement(TryStatement node) {
     visitNodeWithChildren(node, "TryStatement");
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     openNode(node, "TypeAnnotation");
-    visitWithPrefix(node.typeName, "typeName:");
-    visitWithPrefix(node.typeArguments, "typeArguments:");
+    visitChildNode(node.typeName, "typeName");
+    visitChildNode(node.typeArguments, "typeArguments");
     closeNode();
   }
 
   visitTypedef(Typedef node) {
     visitNodeWithChildren(node, "Typedef");
   }
 
   visitTypeVariable(TypeVariable node) {
     openNode(node, "TypeVariable");
-    visitWithPrefix(node.name, "name:");
-    visitWithPrefix(node.bound, "bound:");
+    visitChildNode(node.name, "name");
+    visitChildNode(node.bound, "bound");
     closeNode();
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     openNode(node, "VariableDefinitions");
-    visitWithPrefix(node.type, "type:");
-    visitWithPrefix(node.modifiers, "modifiers:");
-    visitWithPrefix(node.definitions, "definitions:");
+    visitChildNode(node.type, "type");
+    visitChildNode(node.modifiers, "modifiers");
+    visitChildNode(node.definitions, "definitions");
     closeNode();
   }
 
   visitWhile(While node) {
     visitNodeWithChildren(node, "While");
   }
 }