Change --print-ast output to be more regular.

runtime/vm/ast_printer.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/ast_printer.h"
 
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 AstPrinter::AstPrinter() { }
 
 
 AstPrinter::~AstPrinter() { }
 
 
 void AstPrinter::VisitGenericAstNode(AstNode* node) {
   OS::Print("(%s ", node->PrettyName());
   node->VisitChildren(this);
   OS::Print(")");
 }
 
 
-void AstPrinter::VisitSequenceNode(SequenceNode* node_sequence) {
+void AstPrinter::VisitSequenceNode(SequenceNode* node) {
   // TODO(regis): Make the output more readable by indenting the nested
   // sequences. This could be achieved using a AstPrinterContext similar to the
   // CodeGeneratorContext.

[regis, 2013/09/06 16:27:34]

Feel free to remove this TODO :-)
It could be replaced with a comment pointing to ikarus.

-  ASSERT(node_sequence != NULL);
-  for (int i = 0; i < node_sequence->length(); i++) {
-    OS::Print("scope %p: ",
-              node_sequence->scope());
-    node_sequence->NodeAt(i)->Visit(this);
+  OS::Print("(%s (scope \"%p\")", node->PrettyName(), node->scope());
+  for (int i = 0; i < node->length(); ++i) {
     OS::Print("\n");
+    node->NodeAt(i)->Visit(this);
   }
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitCloneContextNode(CloneContextNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitArgumentListNode(ArgumentListNode* arguments) {
   VisitGenericAstNode(arguments);
 }
 
 
 void AstPrinter::VisitReturnNode(ReturnNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitGenericLocalNode(AstNode* node,
                                        const LocalVariable& var) {
-  OS::Print("(%s %s%s '%s'",
+  OS::Print("(%s %s%s \"%s\"",
             node->PrettyName(),
             var.is_final() ? "final " : "",
             String::Handle(var.type().Name()).ToCString(),
             var.name().ToCString());
   if (var.HasIndex()) {
-    OS::Print(" @%d", var.index());
     if (var.is_captured()) {
-      OS::Print(" ctx %d", var.owner()->context_level());
+      OS::Print(" (context %d %d)", var.owner()->context_level(), var.index());
+    } else {
+      OS::Print(" (stack %d)", var.index());
     }
   }
+  OS::Print(" ");
   node->VisitChildren(this);
   OS::Print(")");
 }
 
 
 void AstPrinter::VisitLoadLocalNode(LoadLocalNode* node) {
   VisitGenericLocalNode(node, node->local());
 }
 
 
 void AstPrinter::VisitStoreLocalNode(StoreLocalNode* node) {
   VisitGenericLocalNode(node, node->local());
 }
 
 
 void AstPrinter::VisitGenericFieldNode(AstNode* node, const Field& field) {
-  OS::Print("(%s %s%s '%s' ",
+  OS::Print("(%s %s%s \"%s\" ",
             node->PrettyName(),
             field.is_final() ? "final " : "",
             String::Handle(AbstractType::Handle(field.type()).Name()).
                 ToCString(),
             String::Handle(field.name()).ToCString());
   node->VisitChildren(this);
   OS::Print(")");
 }
 
 
@@ skipping 22 matching lines @@
 }
 
 
 void AstPrinter::VisitArrayNode(ArrayNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitLiteralNode(LiteralNode* node) {
   const Instance& literal = node->literal();
-  OS::Print("'%s'", literal.ToCString());
+  OS::Print("(%s \"%s\")", node->PrettyName(), literal.ToCString());
 }
 
 
 void AstPrinter::VisitTypeNode(TypeNode* node) {
   const AbstractType& type = node->type();
-  OS::Print("'%s'", String::Handle(type.Name()).ToCString());
+  OS::Print("(%s \"%s\")",
+            node->PrettyName(),
+            String::Handle(type.Name()).ToCString());
 }
 
 
 void AstPrinter::VisitAssignableNode(AssignableNode* node) {
-  OS::Print("(assignable ");
-  node->expr()->Visit(this);
   const AbstractType& type = node->type();
   const String& dst_name = node->dst_name();
-  OS::Print(" to type '%s' of '%s')",
+  OS::Print("(%s (type \"%s\") (of \"%s\") ",
+            node->PrettyName(),
             String::Handle(type.Name()).ToCString(),
             dst_name.ToCString());
+  node->VisitChildren(this);
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitPrimaryNode(PrimaryNode* node) {
-  OS::Print("***** PRIMARY NODE IN AST ***** (primary '%s')",
+  OS::Print("*****%s***** \"%s\")",
+            node->PrettyName(),
             node->primary().ToCString());
 }
 
 
 void AstPrinter::VisitComparisonNode(ComparisonNode* node) {
-  if (node->kind() == Token::kAS) {
-    OS::Print("(as ");
-    node->VisitChildren(this);
-    OS::Print(")");
-  } else {
-    VisitGenericAstNode(node);
-  }
+  OS::Print("(%s %s ", node->PrettyName(), node->TokenName());
+  node->VisitChildren(this);
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitBinaryOpNode(BinaryOpNode* node) {
-  VisitGenericAstNode(node);
+  OS::Print("(%s %s ", node->PrettyName(), node->TokenName());
+  node->VisitChildren(this);
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitBinaryOpWithMask32Node(BinaryOpWithMask32Node* node) {
-  OS::Print("(%s %s", node->PrettyName(), node->TokenName());
+  OS::Print("(%s %s ", node->PrettyName(), node->TokenName());
   node->VisitChildren(this);
-  OS::Print(" & 0x%" Px64 "", node->mask32());
+  OS::Print(" & \"0x%" Px64 "", node->mask32());
+  OS::Print("\")");
+}
+
+
+void AstPrinter::VisitUnaryOpNode(UnaryOpNode* node) {
+  OS::Print("(%s %s ", node->PrettyName(), node->TokenName());
+  node->VisitChildren(this);
   OS::Print(")");
 }
 
 
-void AstPrinter::VisitUnaryOpNode(UnaryOpNode* node) {
-  VisitGenericAstNode(node);
-}
-
-
 void AstPrinter::VisitConditionalExprNode(ConditionalExprNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitIfNode(IfNode* node) {
-  OS::Print("(if ");
-  node->condition()->Visit(this);
-  OS::Print(" then ");
-  node->true_branch()->Visit(this);
-  OS::Print(" else ");
-  if (node->false_branch() != NULL) {
-    node->false_branch()->Visit(this);
-  }
-  OS::Print(")");
+  VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitCaseNode(CaseNode* node) {
-  OS::Print("(case (");
+  OS::Print("(%s (", node->PrettyName());
   for (int i = 0; i < node->case_expressions()->length(); i++) {
     node->case_expressions()->NodeAt(i)->Visit(this);
   }
   if (node->contains_default()) {
-    OS::Print(" default ");
+    OS::Print(" default");
   }
   OS::Print(")");
   node->statements()->Visit(this);
   OS::Print(")");
 }
 
 
 void AstPrinter::VisitSwitchNode(SwitchNode* node) {
-  OS::Print("(switch ");
+  VisitGenericAstNode(node);
+}
+
+
+void AstPrinter::VisitWhileNode(WhileNode* node) {
+  VisitGenericAstNode(node);
+}
+
+
+void AstPrinter::VisitForNode(ForNode* node) {
+  // Complicated because the condition is optional and so we clearly want to
+  // indicate the subparts.
+  OS::Print("(%s (init ", node->PrettyName());
+  node->initializer()->Visit(this);
+  if (node->condition() != NULL) {
+    OS::Print(") (cond ");
+    node->condition()->Visit(this);
+  }
+  OS::Print(") (update ");
+  node->increment()->Visit(this);
+  OS::Print(") ");
   node->body()->Visit(this);
   OS::Print(")");
 }
 
 
-void AstPrinter::VisitWhileNode(WhileNode* node) {
-  OS::Print("(while ");
-  node->condition()->Visit(this);
-  OS::Print(" do ");
-  node->body()->Visit(this);
-  OS::Print(")");
-}
-
-
-void AstPrinter::VisitForNode(ForNode* node) {
-  OS::Print("(for (init: ");
-  node->initializer()->Visit(this);
-  OS::Print("; cond:");
-  if (node->condition() != NULL) {
-    node->condition()->Visit(this);
-  }
-  OS::Print("; incr:");
-  node->increment()->Visit(this);
-  OS::Print(") body:");
-  node->body()->Visit(this);
-  OS::Print("endfor)");
-}
-
-
 void AstPrinter::VisitDoWhileNode(DoWhileNode* node) {
-  OS::Print("(do ");
-  node->body()->Visit(this);
-  OS::Print(" while ");
-  node->condition()->Visit(this);
-  OS::Print(")");
+  VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitJumpNode(JumpNode* node) {
-  OS::Print("(%s %s %s in scope %p)",
+  OS::Print("(%s %s %s (scope \"%p\"))",
             node->PrettyName(),
             node->TokenName(),
             node->label()->name().ToCString(),
             node->label()->owner());
 }
 
 
 void AstPrinter::VisitInstanceCallNode(InstanceCallNode* node) {
-  OS::Print("(%s '%s'(", node->PrettyName(), node->function_name().ToCString());
+  OS::Print("(%s \"%s\" ",
+            node->PrettyName(),
+            node->function_name().ToCString());
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitStaticCallNode(StaticCallNode* node) {
   const char* function_fullname = node->function().ToFullyQualifiedCString();
-  OS::Print("(%s '%s'(", node->PrettyName(), function_fullname);
+  OS::Print("(%s \"%s\" ", node->PrettyName(), function_fullname);
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitClosureNode(ClosureNode* node) {
   const char* function_fullname = node->function().ToFullyQualifiedCString();
-  OS::Print("(%s '%s')", node->PrettyName(), function_fullname);
+  OS::Print("(%s \"%s\")", node->PrettyName(), function_fullname);
 }
 
 
 void AstPrinter::VisitClosureCallNode(ClosureCallNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitConstructorCallNode(ConstructorCallNode* node) {
   const char* kind = node->constructor().IsFactory() ? "factory " : "";
   const char* constructor_name = node->constructor().ToFullyQualifiedCString();
-  OS::Print("(%s %s'%s' ((this)", node->PrettyName(), kind, constructor_name);
+  OS::Print("(%s %s \"%s\" ", node->PrettyName(), kind, constructor_name);
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  OS::Print("(%s 'get %s'(",
+  OS::Print("(%s \"%s\" ",
             node->PrettyName(),
             node->field_name().ToCString());
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitInstanceSetterNode(InstanceSetterNode* node) {
-  OS::Print("(%s 'set %s'(",
+  OS::Print("(%s \"%s\" ",
             node->PrettyName(),
             node->field_name().ToCString());
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitStaticGetterNode(StaticGetterNode* node) {
   String& class_name = String::Handle(node->cls().Name());
-  OS::Print("(%s '%s.%s'(",
+  OS::Print("(%s \"%s.%s\")",
             node->PrettyName(),
             class_name.ToCString(),
             node->field_name().ToCString());
-  OS::Print("))");
 }
 
 
 void AstPrinter::VisitStaticSetterNode(StaticSetterNode* node) {
   String& class_name = String::Handle(node->cls().Name());
-  OS::Print("(%s '%s.%s'(",
+  OS::Print("(%s \"%s.%s\" ",
             node->PrettyName(),
             class_name.ToCString(),
             node->field_name().ToCString());
   node->VisitChildren(this);
-  OS::Print("))");
+  OS::Print(")");
 }
 
 
 void AstPrinter::VisitLoadIndexedNode(LoadIndexedNode* node) {
   OS::Print("(%s%s ", node->PrettyName(), node->IsSuperLoad() ? " super" : "");
   node->VisitChildren(this);
   OS::Print(")");
 }
 
 
 void AstPrinter::VisitStoreIndexedNode(StoreIndexedNode* node) {
   OS::Print("(%s%s ", node->PrettyName(), node->IsSuperStore() ? " super" : "");
   node->VisitChildren(this);
   OS::Print(")");
 }
 
 
 void AstPrinter::VisitNativeBodyNode(NativeBodyNode* node) {
-  OS::Print("(native_c call '%s'(%d args))",
+  OS::Print("(%s \"%s\" (%d args))",
+            node->PrettyName(),
             node->native_c_function_name().ToCString(),
             NativeArguments::ParameterCountForResolution(node->function()));
 }
 
 
 void AstPrinter::VisitCatchClauseNode(CatchClauseNode* node) {
-  node->VisitChildren(this);
+  VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitTryCatchNode(TryCatchNode* node) {
-  OS::Print("(");
-
-  // First visit the try block.
-  OS::Print("(try block (");
+  OS::Print("(%s ", node->PrettyName());
   node->try_block()->Visit(this);
-  OS::Print("))");
-
-  // Now visit the catch block if it exists.
   if (node->catch_block() != NULL) {
-    OS::Print("(catch block () (");
     node->catch_block()->Visit(this);
-    OS::Print("))");
   }
-
-  // Now visit the finally block if it exists.
   if (node->finally_block() != NULL) {
-    OS::Print("(finally block () (");
+    OS::Print("(finally ");
     node->finally_block()->Visit(this);
-    OS::Print("))");
+    OS::Print(")");
   }
-
   OS::Print(")");
 }
 
 
 void AstPrinter::VisitThrowNode(ThrowNode* node) {
   VisitGenericAstNode(node);
 }
 
 
 void AstPrinter::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
@@ skipping 107 matching lines @@
   ASSERT(node_sequence != NULL);
   AstPrinter ast_printer;
   const char* function_name =
       parsed_function.function().ToFullyQualifiedCString();
   OS::Print("Ast for function '%s' {\n", function_name);
   node_sequence->Visit(&ast_printer);
   OS::Print("}\n");
 }
 
 }  // namespace dart