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

runtime/vm/ast.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.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 
 
 namespace dart {
 
-#define DEFINE_VISIT_FUNCTION(type, name)                                      \
-  void type::Visit(AstNodeVisitor* visitor) {                                  \
-    visitor->Visit##type(this);                                                \
-  }
-NODE_LIST(DEFINE_VISIT_FUNCTION)
+#define DEFINE_VISIT_FUNCTION(BaseName)                                        \
+void BaseName##Node::Visit(AstNodeVisitor* visitor) {                          \
+  visitor->Visit##BaseName##Node(this);                                        \
+}
+
+FOR_EACH_NODE(DEFINE_VISIT_FUNCTION)
 #undef DEFINE_VISIT_FUNCTION
 
 
-#define DEFINE_NAME_FUNCTION(type, name)                                       \
-  const char* type::PrettyName() const {                                       \
-    return name;                                                               \
-  }
-NODE_LIST(DEFINE_NAME_FUNCTION)
+#define DEFINE_NAME_FUNCTION(BaseName)                                         \
+const char* BaseName##Node::PrettyName() const {                               \
+  return #BaseName;                                                            \
+}
+
+FOR_EACH_NODE(DEFINE_NAME_FUNCTION)
 #undef DEFINE_NAME_FUNCTION
 
 
 // A visitor class to collect all the nodes (including children) into an
 // array.
 class AstNodeCollector : public AstNodeVisitor {
  public:
   explicit AstNodeCollector(GrowableArray<AstNode*>* nodes)
     : nodes_(nodes) { }
 
-#define DEFINE_VISITOR_FUNCTION(type, name)                                    \
-  virtual void Visit##type(type* node) {                                       \
+#define DEFINE_VISITOR_FUNCTION(BaseName)                                      \
+  virtual void Visit##BaseName##Node(BaseName##Node* node) {                   \
     nodes_->Add(node);                                                         \
     node->VisitChildren(this);                                                 \
   }
-NODE_LIST(DEFINE_VISITOR_FUNCTION)
+
+FOR_EACH_NODE(DEFINE_VISITOR_FUNCTION)
 #undef DEFINE_VISITOR_FUNCTION
 
  private:
   GrowableArray<AstNode*>* nodes_;
   DISALLOW_COPY_AND_ASSIGN(AstNodeCollector);
 };
 
 
 void SequenceNode::CollectAllNodes(GrowableArray<AstNode*>* nodes) {
   AstNodeCollector node_collector(nodes);
@@ skipping 90 matching lines @@
 
 bool ComparisonNode::IsKindValid() const {
   return Token::IsRelationalOperator(kind_)
       || Token::IsEqualityOperator(kind_)
       || Token::IsTypeTestOperator(kind_)
       || Token::IsTypeCastOperator(kind_);
 }
 
 
 const char* ComparisonNode::TokenName() const {
-  return Token::Str(kind_);
+  return (kind_ == Token::kAS) ? "as" : Token::Str(kind_);
 }
 
 
 bool ComparisonNode::IsPotentiallyConst() const {
   switch (kind_) {
     case Token::kLT:
     case Token::kGT:
     case Token::kLTE:
     case Token::kGTE:
     case Token::kEQ:
@@ skipping 385 matching lines @@
   if (result.IsError() || result.IsNull()) {
     // TODO(turnidge): We could get better error messages by returning
     // the Error object directly to the parser.  This will involve
     // replumbing all of the EvalConstExpr methods.
     return NULL;
   }
   return &Instance::ZoneHandle(Instance::Cast(result).raw());
 }
 
 }  // namespace dart