dartfmt pkg/compiler

pkg/compiler/lib/src/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.
 
 import '../tokens/token.dart' show BeginGroupToken, Token;
 import '../util/util.dart';
 import 'nodes.dart';
 
 /**
  * Pretty-prints Node tree in XML-like format.
@@ skipping 29 matching lines @@
     node.visitChildren(this);
     closeNode();
   }
 
   visitAssert(Assert node) {
     visitNodeWithChildren(node, "Assert");
   }
 
   visitAsyncModifier(AsyncModifier node) {
     openAndCloseNode(node, "AsyncModifier",
-        {'asyncToken': node.asyncToken,
-         'starToken': node.starToken});
+        {'asyncToken': node.asyncToken, 'starToken': node.starToken});
   }
 
   visitBlock(Block node) {
     visitNodeWithChildren(node, "Block");
   }
 
   visitBreakStatement(BreakStatement node) {
     visitNodeWithChildren(node, "BreakStatement");
   }
 
   visitCascade(Cascade node) {
     visitNodeWithChildren(node, "Cascade");
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visitNodeWithChildren(node, "CascadeReceiver");
   }
 
   visitCaseMatch(CaseMatch node) {
     visitNodeWithChildren(node, "CaseMatch");
   }
 
   visitCatchBlock(CatchBlock node) {
     visitNodeWithChildren(node, "CatchBlock");
   }
 
   visitClassNode(ClassNode node) {
-    openNode(node, "ClassNode", {
-      "extendsKeyword" : tokenToStringOrNull(node.extendsKeyword)
-    });
+    openNode(node, "ClassNode",
+        {"extendsKeyword": tokenToStringOrNull(node.extendsKeyword)});
     visitChildNode(node.name, "name");
     visitChildNode(node.superclass, "superclass");
     visitChildNode(node.interfaces, "interfaces");
     visitChildNode(node.typeParameters, "typeParameters");
     closeNode();
   }
 
   visitConditional(Conditional node) {
     visitNodeWithChildren(node, "Conditional");
   }
@@ skipping 40 matching lines @@
     openNode(node, "ForIn");
     node.visitChildren(this);
     closeNode();
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitNodeWithChildren(node, "FunctionDeclaration");
   }
 
   visitFunctionExpression(FunctionExpression node) {
-    openNode(node, "FunctionExpression", {
-      "getOrSet" : tokenToStringOrNull(node.getOrSet)
-    });
+    openNode(node, "FunctionExpression",
+        {"getOrSet": tokenToStringOrNull(node.getOrSet)});
     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});
+    openAndCloseNode(node, "Identifier", {"token": node.token});
   }
 
   visitIf(If node) {
     visitNodeWithChildren(node, "If");
   }
 
   visitLabel(Label node) {
     visitNodeWithChildren(node, "Label");
   }
 
   visitLabeledStatement(LabeledStatement node) {
     visitNodeWithChildren(node, "LabeledStatement");
   }
 
   // Custom.
   printLiteral(Literal node, String type) {
-    openAndCloseNode(node, type, {"value" : node.value.toString()});
+    openAndCloseNode(node, type, {"value": node.value.toString()});
   }
 
   visitLiteralBool(LiteralBool node) {
     printLiteral(node, "LiteralBool");
   }
 
   visitLiteralDouble(LiteralDouble node) {
     printLiteral(node, "LiteralDouble");
   }
 
   visitLiteralInt(LiteralInt node) {
     printLiteral(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)
-    });
+    openNode(node, "LiteralList",
+        {"constKeyword": tokenToStringOrNull(node.constKeyword)});
     visitChildNode(node.typeArguments, "typeArguments");
     visitChildNode(node.elements, "elements");
     closeNode();
   }
 
   visitLiteralMap(LiteralMap node) {
     visitNodeWithChildren(node, "LiteralMap");
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visitNodeWithChildren(node, "LiteralMapEntry");
   }
 
   visitLiteralNull(LiteralNull node) {
     printLiteral(node, "LiteralNull");
   }
 
   visitLiteralString(LiteralString node) {
-    openAndCloseNode(node, "LiteralString",
-        {"value" : node.token});
+    openAndCloseNode(node, "LiteralString", {"value": node.token});
   }
 
   visitMixinApplication(MixinApplication node) {
     visitNodeWithChildren(node, "MixinApplication");
   }
 
   visitModifiers(Modifiers node) {
     visitNodeWithChildren(node, "Modifiers");
   }
 
   visitNamedArgument(NamedArgument node) {
     visitNodeWithChildren(node, "NamedArgument");
   }
 
   visitNamedMixinApplication(NamedMixinApplication node) {
     visitNodeWithChildren(node, "NamedMixinApplication");
   }
 
   visitNewExpression(NewExpression node) {
     visitNodeWithChildren(node, "NewExpression");
   }
 
   visitNodeList(NodeList node) {
-    var params = { "delimiter" : node.delimiter };
+    var params = {"delimiter": node.delimiter};
     if (node.isEmpty) {
       openAndCloseNode(node, "NodeList", params);
     } else {
       openNode(node, "NodeList", params);
       node.visitChildren(this);
       closeNode();
     }
   }
 
   visitOperator(Operator node) {
-    openAndCloseNode(node, "Operator", {"value" : node.token});
+    openAndCloseNode(node, "Operator", {"value": node.token});
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visitNodeWithChildren(node, "ParenthesizedExpression");
   }
 
   visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     openNode(node, "RedirectingFactoryBody");
     visitChildNode(node.constructorReference, "constructorReference");
     closeNode();
@@ skipping 21 matching lines @@
     sb.write("<$fieldName>\n");
     pushTag(fieldName);
     node.accept(this);
     popTag();
     addCurrentIndent();
     sb.write("</$fieldName>\n");
   }
 
   openSendNodeWithFields(Send node, String type) {
     openNode(node, type, {
-        "isPrefix" : "${node.isPrefix}",
-        "isPostfix" : "${node.isPostfix}",
-        "isIndex" : "${node.isIndex}"
+      "isPrefix": "${node.isPrefix}",
+      "isPostfix": "${node.isPostfix}",
+      "isIndex": "${node.isIndex}"
     });
     visitChildNode(node.receiver, "receiver");
     visitChildNode(node.selector, "selector");
     visitChildNode(node.argumentsNode, "argumentsNode");
   }
 
   visitSend(Send node) {
     openSendNodeWithFields(node, "Send");
     closeNode();
   }
@@ skipping 66 matching lines @@
     visitChildNode(node.modifiers, "modifiers");
     visitChildNode(node.definitions, "definitions");
     closeNode();
   }
 
   visitWhile(While node) {
     visitNodeWithChildren(node, "While");
   }
 
   visitMetadata(Metadata node) {
-    openNode(node, "Metadata", {
-      "token": node.token
-    });
+    openNode(node, "Metadata", {"token": node.token});
     visitChildNode(node.expression, "expression");
     closeNode();
   }
 
   visitCombinator(Combinator node) {
-    openNode(node, "Combinator", {"isShow" : "${node.isShow}",
-                                  "isHide" : "${node.isHide}"});
+    openNode(node, "Combinator",
+        {"isShow": "${node.isShow}", "isHide": "${node.isHide}"});
     closeNode();
   }
 
   visitExport(Export node) {
     openNode(node, "Export");
     visitChildNode(node.uri, "uri");
     if (node.conditionalUris != null) {
       visitChildNode(node.conditionalUris, "conditionalUris");
     }
     visitChildNode(node.combinators, "combinators");
     closeNode();
   }
 
   visitImport(Import node) {
-    openNode(node, "Import", {
-      "isDeferred" : "${node.isDeferred}"});
+    openNode(node, "Import", {"isDeferred": "${node.isDeferred}"});
     visitChildNode(node.uri, "uri");
     if (node.conditionalUris != null) {
       visitChildNode(node.conditionalUris, "conditionalUris");
     }
     visitChildNode(node.combinators, "combinators");
     if (node.prefix != null) {
       visitChildNode(node.prefix, "prefix");
     }
     closeNode();
   }
@@ skipping 57 matching lines @@
   }
 
   visitGotoStatement(GotoStatement node) {
     unimplemented('visitNode', node: node);
   }
 
   unimplemented(String message, {Node node}) {
     throw message;
   }
 }