clang-format runtime/vm

runtime/vm/ast.h

 // 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.
 
 #ifndef RUNTIME_VM_AST_H_
 #define RUNTIME_VM_AST_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
@@ skipping 46 matching lines @@
   V(LoadStaticField)                                                           \
   V(StoreStaticField)                                                          \
   V(LoadIndexed)                                                               \
   V(StoreIndexed)                                                              \
   V(Sequence)                                                                  \
   V(Let)                                                                       \
   V(CatchClause)                                                               \
   V(TryCatch)                                                                  \
   V(Throw)                                                                     \
   V(InlinedFinally)                                                            \
-  V(StringInterpolate)                                                         \
+  V(StringInterpolate)
 
 
 #define FORWARD_DECLARATION(BaseName) class BaseName##Node;
 FOR_EACH_NODE(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 
 // Abstract class to implement an AST node visitor. An example is AstPrinter.
 class AstNodeVisitor : public ValueObject {
  public:
   AstNodeVisitor() {}
   virtual ~AstNodeVisitor() {}
 
 #define DEFINE_VISITOR_FUNCTION(BaseName)                                      \
-  virtual void Visit##BaseName##Node(BaseName##Node* node) { }
+  virtual void Visit##BaseName##Node(BaseName##Node* node) {}
 
   FOR_EACH_NODE(DEFINE_VISITOR_FUNCTION)
 #undef DEFINE_VISITOR_FUNCTION
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AstNodeVisitor);
 };
 
 
 #define DECLARE_COMMON_NODE_FUNCTIONS(type)                                    \
   virtual void Visit(AstNodeVisitor* visitor);                                 \
   virtual const char* Name() const;                                            \
   virtual type* As##type() { return this; }
 
 
 class AstNode : public ZoneAllocated {
  public:
-  explicit AstNode(TokenPosition token_pos)
-      : token_pos_(token_pos) {
+  explicit AstNode(TokenPosition token_pos) : token_pos_(token_pos) {
     ASSERT(!token_pos_.IsClassifying() ||
            (token_pos_ == TokenPosition::kMethodExtractor));
   }
-  virtual ~AstNode() { }
+  virtual ~AstNode() {}
 
   TokenPosition token_pos() const { return token_pos_; }
 
 #define AST_TYPE_CHECK(BaseName)                                               \
   bool Is##BaseName##Node() { return As##BaseName##Node() != NULL; }           \
   virtual BaseName##Node* As##BaseName##Node() { return NULL; }
 
   FOR_EACH_NODE(AST_TYPE_CHECK)
 #undef AST_TYPE_CHECK
 
   virtual void Visit(AstNodeVisitor* visitor) = 0;
   virtual void VisitChildren(AstNodeVisitor* visitor) const = 0;
   virtual const char* Name() const = 0;
 
   // Convert the node into an assignment node using the rhs which is passed in,
   // this is typically used for converting nodes like LoadLocalNode,
   // LoadStaticFieldNode, InstanceGetterNode etc. which were created during
   // parsing as the assignment context was not known yet at that time.
   virtual AstNode* MakeAssignmentNode(AstNode* rhs) {
     return NULL;  // By default all nodes are not assignable.
   }
 
   // Return NULL if 'unary_op_kind' can't be applied.
-  virtual AstNode* ApplyUnaryOp(Token::Kind unary_op_kind) {
-    return NULL;
-  }
+  virtual AstNode* ApplyUnaryOp(Token::Kind unary_op_kind) { return NULL; }
 
   // Returns true if this node can be a compile-time constant, assuming
   // that all nodes it depends on are also compile-time constants of
   // the proper types and values.
   // See the concept of "potentially constant expression" in the language spec.
   // The purpose of IsPotentiallyConst is to detect cases where the node is
   // known NOT to be a constant expression, in which case false is returned and
   // a compile-time error is reported by the compiler. Otherwise, an error may
   // still be reported at run-time depending on actual values.
   virtual bool IsPotentiallyConst() const { return false; }
@@ skipping 22 matching lines @@
 
 class AwaitNode : public AstNode {
  public:
   AwaitNode(TokenPosition token_pos,
             AstNode* expr,
             LocalVariable* saved_try_ctx,
             LocalVariable* async_saved_try_ctx,
             LocalVariable* outer_saved_try_ctx,
             LocalVariable* outer_async_saved_try_ctx,
             LocalScope* scope)
-    : AstNode(token_pos),
-      expr_(expr),
-      saved_try_ctx_(saved_try_ctx),
-      async_saved_try_ctx_(async_saved_try_ctx),
-      outer_saved_try_ctx_(outer_saved_try_ctx),
-      outer_async_saved_try_ctx_(outer_async_saved_try_ctx),
-      scope_(scope) { }
+      : AstNode(token_pos),
+        expr_(expr),
+        saved_try_ctx_(saved_try_ctx),
+        async_saved_try_ctx_(async_saved_try_ctx),
+        outer_saved_try_ctx_(outer_saved_try_ctx),
+        outer_async_saved_try_ctx_(outer_async_saved_try_ctx),
+        scope_(scope) {}
 
-  void VisitChildren(AstNodeVisitor* visitor) const {
-    expr_->Visit(visitor);
-  }
+  void VisitChildren(AstNodeVisitor* visitor) const { expr_->Visit(visitor); }
 
   AstNode* expr() const { return expr_; }
   LocalVariable* saved_try_ctx() const { return saved_try_ctx_; }
   LocalVariable* async_saved_try_ctx() const { return async_saved_try_ctx_; }
   LocalVariable* outer_saved_try_ctx() const { return outer_saved_try_ctx_; }
   LocalVariable* outer_async_saved_try_ctx() const {
     return outer_async_saved_try_ctx_;
   }
   LocalScope* scope() const { return scope_; }
 
@@ skipping 18 matching lines @@
 //
 // It is expected (ASSERT) that an AwaitMarker is followed by
 // a return node of kind kContinuationTarget. That is:
 //   <AwaitMarker> -> <other nodes> -> <kContinuationTarget> -> <other nodes> ->
 //   <AwaitMarker> -> ...
 class AwaitMarkerNode : public AstNode {
  public:
   AwaitMarkerNode(LocalScope* async_scope,
                   LocalScope* await_scope,
                   TokenPosition token_pos)
-    : AstNode(token_pos),
-      async_scope_(async_scope),
-      await_scope_(await_scope) {
+      : AstNode(token_pos),
+        async_scope_(async_scope),
+        await_scope_(await_scope) {
     ASSERT(async_scope != NULL);
     ASSERT(await_scope != NULL);
     await_scope->CaptureLocalVariables(async_scope);
   }
 
-  void VisitChildren(AstNodeVisitor* visitor) const { }
+  void VisitChildren(AstNodeVisitor* visitor) const {}
 
   LocalScope* async_scope() const { return async_scope_; }
   LocalScope* await_scope() const { return await_scope_; }
 
   DECLARE_COMMON_NODE_FUNCTIONS(AwaitMarkerNode);
 
  private:
   LocalScope* async_scope_;
   LocalScope* await_scope_;
 
   DISALLOW_COPY_AND_ASSIGN(AwaitMarkerNode);
 };
 
 
 class SequenceNode : public AstNode {
  public:
   SequenceNode(TokenPosition token_pos, LocalScope* scope)
-    : AstNode(token_pos),
-      scope_(scope),
-      nodes_(4),
-      label_(NULL) {
-  }
+      : AstNode(token_pos), scope_(scope), nodes_(4), label_(NULL) {}
 
   LocalScope* scope() const { return scope_; }
 
   SourceLabel* label() const { return label_; }
   void set_label(SourceLabel* value) { label_ = value; }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   void Add(AstNode* node);
   intptr_t length() const { return nodes_.length(); }
   AstNode* NodeAt(intptr_t index) const { return nodes_[index]; }
   void ReplaceNodeAt(intptr_t index, AstNode* value) { nodes_[index] = value; }
 
   DECLARE_COMMON_NODE_FUNCTIONS(SequenceNode);
 
   // Collects all nodes accessible from this sequence node into array 'nodes'.
   void CollectAllNodes(GrowableArray<AstNode*>* nodes);
 
  private:
   LocalScope* scope_;
   GrowableArray<AstNode*> nodes_;
   SourceLabel* label_;
 
   DISALLOW_COPY_AND_ASSIGN(SequenceNode);
 };
 
 
 class CloneContextNode : public AstNode {
  public:
-  explicit CloneContextNode(TokenPosition token_pos)
-    : AstNode(token_pos) {
-  }
+  explicit CloneContextNode(TokenPosition token_pos) : AstNode(token_pos) {}
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(CloneContextNode);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloneContextNode);
 };
 
 
 class ArgumentListNode : public AstNode {
  public:
   explicit ArgumentListNode(TokenPosition token_pos)
-     : AstNode(token_pos),
-       nodes_(4),
-       names_(Array::ZoneHandle()) {
-  }
+      : AstNode(token_pos), nodes_(4), names_(Array::ZoneHandle()) {}
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
-  void Add(AstNode* node) {
-    nodes_.Add(node);
-  }
+  void Add(AstNode* node) { nodes_.Add(node); }
   intptr_t length() const { return nodes_.length(); }
   AstNode* NodeAt(intptr_t index) const { return nodes_[index]; }
   void SetNodeAt(intptr_t index, AstNode* node) { nodes_[index] = node; }
   const Array& names() const { return names_; }
-  void set_names(const Array& names) {
-    names_ = names.raw();
-  }
+  void set_names(const Array& names) { names_ = names.raw(); }
   const GrowableArray<AstNode*>& nodes() const { return nodes_; }
 
   DECLARE_COMMON_NODE_FUNCTIONS(ArgumentListNode);
 
  private:
   GrowableArray<AstNode*> nodes_;
   Array& names_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentListNode);
 };
 
 
 class LetNode : public AstNode {
  public:
   explicit LetNode(TokenPosition token_pos);
 
   LocalVariable* TempAt(intptr_t i) const { return vars_[i]; }
   AstNode* InitializerAt(intptr_t i) const { return initializers_[i]; }
 
   virtual bool IsPotentiallyConst() const;
   virtual const Instance* EvalConstExpr() const;
 
   LocalVariable* AddInitializer(AstNode* node);
 
   const GrowableArray<AstNode*>& nodes() const { return nodes_; }
 
   void AddNode(AstNode* node) { nodes_.Add(node); }
 
-  intptr_t num_temps() const {
-    return vars_.length();
-  }
+  intptr_t num_temps() const { return vars_.length(); }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(LetNode);
 
  private:
   GrowableArray<LocalVariable*> vars_;
   GrowableArray<AstNode*> initializers_;
   GrowableArray<AstNode*> nodes_;
 
   DISALLOW_COPY_AND_ASSIGN(LetNode);
 };
 
 
 class ArrayNode : public AstNode {
  public:
   ArrayNode(TokenPosition token_pos, const AbstractType& type)
-      : AstNode(token_pos),
-        type_(type),
-        elements_() {
+      : AstNode(token_pos), type_(type), elements_() {
     CheckFields();
   }
   ArrayNode(TokenPosition token_pos,
             const AbstractType& type,
             const GrowableArray<AstNode*>& elements)
-      : AstNode(token_pos),
-        type_(type),
-        elements_(elements.length()) {
+      : AstNode(token_pos), type_(type), elements_(elements.length()) {
     CheckFields();
     for (intptr_t i = 0; i < elements.length(); i++) {
       elements_.Add(elements[i]);
     }
   }
 
   void VisitChildren(AstNodeVisitor* visitor) const;
 
   intptr_t length() const { return elements_.length(); }
 
@@ skipping 20 matching lines @@
            ((TypeArguments::Handle(type_.arguments()).Length() == 1)));
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayNode);
 };
 
 
 class StringInterpolateNode : public AstNode {
  public:
   StringInterpolateNode(TokenPosition token_pos, ArrayNode* value)
-      : AstNode(token_pos), value_(value) { }
+      : AstNode(token_pos), value_(value) {}
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value_->Visit(visitor);
   }
 
   ArrayNode* value() const { return value_; }
 
   virtual bool IsPotentiallyConst() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(StringInterpolateNode);
@@ skipping 17 matching lines @@
     }
 #endif  // defined(DEBUG)
     ASSERT(literal_.IsNull() ||
            Class::Handle(literal_.clazz()).is_finalized() ||
            Class::Handle(literal_.clazz()).is_prefinalized());
   }
 
   const Instance& literal() const { return literal_; }
 
   virtual bool IsPotentiallyConst() const;
-  virtual const Instance* EvalConstExpr() const {
-    return &literal();
-  }
+  virtual const Instance* EvalConstExpr() const { return &literal(); }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   virtual AstNode* ApplyUnaryOp(Token::Kind unary_op_kind);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LiteralNode);
 
  private:
   const Instance& literal_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LiteralNode);
 };
 
 
 class TypeNode : public AstNode {
  public:
   TypeNode(TokenPosition token_pos, const AbstractType& type)
       : AstNode(token_pos), type_(type) {
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
     // A wellformed literal Type must be canonical.
-    ASSERT(!type_.IsType() ||
-           type_.IsMalformedOrMalbounded() ||
+    ASSERT(!type_.IsType() || type_.IsMalformedOrMalbounded() ||
            type_.IsCanonical());
   }
 
   const AbstractType& type() const { return type_; }
 
   const char* TypeName() const;
 
   virtual const Instance* EvalConstExpr() const {
     if (!type_.IsInstantiated() || type_.IsMalformedOrMalbounded()) {
       return NULL;
     }
     return &type();
   }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(TypeNode);
 
  private:
   const AbstractType& type_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TypeNode);
 };
 
 
@@ skipping 79 matching lines @@
 };
 
 
 // Primary nodes hold identifiers or values (library, class or function)
 // resolved from an identifier. Primary nodes should not ever make it to the
 // code generation phase as they will be transformed into the correct call or
 // field access nodes.
 class PrimaryNode : public AstNode {
  public:
   PrimaryNode(TokenPosition token_pos, const Object& primary)
-      : AstNode(token_pos),
-        primary_(primary),
-        is_deferred_reference_(false) {
+      : AstNode(token_pos), primary_(primary), is_deferred_reference_(false) {
     ASSERT(primary_.IsNotTemporaryScopedHandle());
   }
 
   const Object& primary() const { return primary_; }
 
   void set_is_deferred(bool value) { is_deferred_reference_ = value; }
   bool is_deferred_reference() const { return is_deferred_reference_; }
 
   bool IsSuper() const {
     return primary().IsString() && (primary().raw() == Symbols::Super().raw());
@@ skipping 15 matching lines @@
 // * A regular return node that in the case of async functions
 //    gets replaced with appropriate completer calls. (kRegular)
 // * A continuation return that just returns from a function, without
 //   completing the Future. (kContinuation)
 // * A continuation return followed by a continuation target, i.e. the
 //   location at which the closure resumes the next time it gets invoked.
 //   (kContinuationTarget).
 // In synchronous functions, return nodes are always of type'kRegular'
 class ReturnNode : public AstNode {
  public:
-  enum ReturnType {
-    kRegular,
-    kContinuation,
-    kContinuationTarget
-  };
+  enum ReturnType { kRegular, kContinuation, kContinuationTarget };
 
   // Return from a void function returns the null object.
   explicit ReturnNode(TokenPosition token_pos)
       : AstNode(token_pos),
         value_(new LiteralNode(token_pos, Instance::ZoneHandle())),
         inlined_finally_list_(),
-        return_type_(kRegular) { }
+        return_type_(kRegular) {}
   // Return from a non-void function.
-  ReturnNode(TokenPosition token_pos,
-             AstNode* value)
+  ReturnNode(TokenPosition token_pos, AstNode* value)
       : AstNode(token_pos),
         value_(value),
         inlined_finally_list_(),
         return_type_(kRegular) {
     ASSERT(value_ != NULL);
   }
 
   AstNode* value() const { return value_; }
 
   intptr_t inlined_finally_list_length() const {
@@ skipping 29 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ReturnNode);
 };
 
 
 class ComparisonNode : public AstNode {
  public:
   ComparisonNode(TokenPosition token_pos,
                  Token::Kind kind,
                  AstNode* left,
                  AstNode* right)
-  : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
+      : AstNode(token_pos), kind_(kind), left_(left), right_(right) {
     ASSERT(left_ != NULL);
     ASSERT(right_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* left() const { return left_; }
   AstNode* right() const { return right_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
@@ skipping 61 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(BinaryOpNode);
 };
 
 
 class UnaryOpNode : public AstNode {
  public:
   // Returns optimized version, e.g., for ('-' '1') ('-1') literal is returned.
   static AstNode* UnaryOpOrLiteral(TokenPosition token_pos,
                                    Token::Kind kind,
                                    AstNode* operand);
-  UnaryOpNode(TokenPosition token_pos,
-              Token::Kind kind,
-              AstNode* operand)
+  UnaryOpNode(TokenPosition token_pos, Token::Kind kind, AstNode* operand)
       : AstNode(token_pos), kind_(kind), operand_(operand) {
     ASSERT(operand_ != NULL);
     ASSERT(IsKindValid());
   }
 
   Token::Kind kind() const { return kind_; }
   AstNode* operand() const { return operand_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     operand()->Visit(visitor);
@@ skipping 18 matching lines @@
 class ConditionalExprNode : public AstNode {
  public:
   ConditionalExprNode(TokenPosition token_pos,
                       AstNode* condition,
                       AstNode* true_expr,
                       AstNode* false_expr)
       : AstNode(token_pos),
         condition_(condition),
         true_expr_(true_expr),
         false_expr_(false_expr) {
-      ASSERT(condition_ != NULL);
-      ASSERT(true_expr_ != NULL);
-      ASSERT(false_expr_ != NULL);
+    ASSERT(condition_ != NULL);
+    ASSERT(true_expr_ != NULL);
+    ASSERT(false_expr_ != NULL);
   }
 
   AstNode* condition() const { return condition_; }
   AstNode* true_expr() const { return true_expr_; }
   AstNode* false_expr() const { return false_expr_; }
 
   void set_true_expr(AstNode* true_expr) {
     ASSERT(true_expr != NULL);
     true_expr_ = true_expr;
   }
@@ skipping 25 matching lines @@
 class IfNode : public AstNode {
  public:
   IfNode(TokenPosition token_pos,
          AstNode* condition,
          SequenceNode* true_branch,
          SequenceNode* false_branch)
       : AstNode(token_pos),
         condition_(condition),
         true_branch_(true_branch),
         false_branch_(false_branch) {
-      ASSERT(condition_ != NULL);
+    ASSERT(condition_ != NULL);
   }
 
   AstNode* condition() const { return condition_; }
   SequenceNode* true_branch() const { return true_branch_; }
   SequenceNode* false_branch() const { return false_branch_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     condition()->Visit(visitor);
     true_branch()->Visit(visitor);
     if (false_branch() != NULL) {
@@ skipping 13 matching lines @@
 
 
 class CaseNode : public AstNode {
  public:
   CaseNode(TokenPosition token_pos,
            SourceLabel* label,
            SequenceNode* case_expressions,
            bool contains_default,
            LocalVariable* switch_expr_value,
            SequenceNode* statements)
-    : AstNode(token_pos),
-      label_(label),
-      case_expressions_(case_expressions),
-      contains_default_(contains_default),
-      switch_expr_value_(switch_expr_value),
-      statements_(statements) {
+      : AstNode(token_pos),
+        label_(label),
+        case_expressions_(case_expressions),
+        contains_default_(contains_default),
+        switch_expr_value_(switch_expr_value),
+        statements_(statements) {
     // label may be NULL.
     ASSERT(case_expressions_ != NULL);
     ASSERT(switch_expr_value_ != NULL);
     ASSERT(statements_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   SequenceNode* case_expressions() const { return case_expressions_; }
   bool contains_default() const { return contains_default_; }
   LocalVariable* switch_expr_value() const { return switch_expr_value_; }
@@ skipping 12 matching lines @@
   bool contains_default_;
   LocalVariable* switch_expr_value_;
   SequenceNode* statements_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaseNode);
 };
 
 
 class SwitchNode : public AstNode {
  public:
-  SwitchNode(TokenPosition token_pos,
-             SourceLabel* label,
-             SequenceNode* body)
-    : AstNode(token_pos),
-      label_(label),
-      body_(body) {
+  SwitchNode(TokenPosition token_pos, SourceLabel* label, SequenceNode* body)
+      : AstNode(token_pos), label_(label), body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   SequenceNode* body() const { return body_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     body()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(SwitchNode);
 
  private:
   SourceLabel* label_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SwitchNode);
 };
 
 
 class WhileNode : public AstNode {
  public:
   WhileNode(TokenPosition token_pos,
             SourceLabel* label,
             AstNode* condition,
             SequenceNode* condition_preamble,
             SequenceNode* body)
-    : AstNode(token_pos),
-      label_(label),
-      condition_(condition),
-      condition_preamble_(condition_preamble),
-      body_(body) {
+      : AstNode(token_pos),
+        label_(label),
+        condition_(condition),
+        condition_preamble_(condition_preamble),
+        body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(condition_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   AstNode* condition() const { return condition_; }
   SequenceNode* body() const { return body_; }
   SequenceNode* condition_preamble() const { return condition_preamble_; }
 
@@ skipping 16 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(WhileNode);
 };
 
 
 class DoWhileNode : public AstNode {
  public:
   DoWhileNode(TokenPosition token_pos,
               SourceLabel* label,
               AstNode* condition,
               SequenceNode* body)
-    : AstNode(token_pos),
-      label_(label),
-      condition_(condition),
-      body_(body) {
+      : AstNode(token_pos), label_(label), condition_(condition), body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(condition_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   AstNode* condition() const { return condition_; }
   SequenceNode* body() const { return body_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
@@ skipping 15 matching lines @@
 // The condition can be NULL.
 class ForNode : public AstNode {
  public:
   ForNode(TokenPosition token_pos,
           SourceLabel* label,
           SequenceNode* initializer,
           AstNode* condition,
           SequenceNode* condition_preamble,
           SequenceNode* increment,
           SequenceNode* body)
-    : AstNode(token_pos),
-      label_(label),
-      initializer_(initializer),
-      condition_(condition),
-      condition_preamble_(condition_preamble),
-      increment_(increment),
-      body_(body) {
+      : AstNode(token_pos),
+        label_(label),
+        initializer_(initializer),
+        condition_(condition),
+        condition_preamble_(condition_preamble),
+        increment_(increment),
+        body_(body) {
     ASSERT(label_ != NULL);
     ASSERT(initializer_ != NULL);
     ASSERT(increment_ != NULL);
     ASSERT(body_ != NULL);
   }
 
   SourceLabel* label() const { return label_; }
   SequenceNode* initializer() const { return initializer_; }
   AstNode* condition() const { return condition_; }
   AstNode* condition_preamble() const { return condition_preamble_; }
@@ skipping 22 matching lines @@
   AstNode* condition_preamble_;
   SequenceNode* increment_;
   SequenceNode* body_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ForNode);
 };
 
 
 class JumpNode : public AstNode {
  public:
-  JumpNode(TokenPosition token_pos,
-           Token::Kind kind,
-           SourceLabel* label)
-    : AstNode(token_pos),
-      kind_(kind),
-      label_(label),
-      inlined_finally_list_() {
+  JumpNode(TokenPosition token_pos, Token::Kind kind, SourceLabel* label)
+      : AstNode(token_pos),
+        kind_(kind),
+        label_(label),
+        inlined_finally_list_() {
     ASSERT(label_ != NULL);
     ASSERT(kind_ == Token::kBREAK || kind_ == Token::kCONTINUE);
   }
 
   SourceLabel* label() const { return label_; }
   Token::Kind kind() const { return kind_; }
 
   intptr_t inlined_finally_list_length() const {
     return inlined_finally_list_.length();
   }
   InlinedFinallyNode* InlinedFinallyNodeAt(intptr_t index) const {
     return inlined_finally_list_[index];
   }
   void AddInlinedFinallyNode(InlinedFinallyNode* finally_node) {
     inlined_finally_list_.Add(finally_node);
   }
 
   const char* TokenName() const;
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(JumpNode);
 
  private:
   Token::Kind kind_;
   SourceLabel* label_;
   GrowableArray<InlinedFinallyNode*> inlined_finally_list_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JumpNode);
 };
 
 
 class StopNode : public AstNode {
  public:
   StopNode(TokenPosition token_pos, const char* message)
-      : AstNode(token_pos),
-        message_(message) {
+      : AstNode(token_pos), message_(message) {
     ASSERT(message != NULL);
   }
 
   const char* message() const { return message_; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(StopNode);
 
  private:
   const char* message_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StopNode);
 };
 
 
 class LoadLocalNode : public AstNode {
  public:
   LoadLocalNode(TokenPosition token_pos, const LocalVariable* local)
       : AstNode(token_pos), local_(*local) {
     ASSERT(local != NULL);
   }
 
   const LocalVariable& local() const { return local_; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   virtual const Instance* EvalConstExpr() const;
   virtual bool IsPotentiallyConst() const;
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadLocalNode);
 
  private:
   const LocalVariable& local_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadLocalNode);
 };
 
 
 class StoreLocalNode : public AstNode {
  public:
   StoreLocalNode(TokenPosition token_pos,
                  const LocalVariable* local,
                  AstNode* value)
-      : AstNode(token_pos),  local_(*local), value_(value) {
+      : AstNode(token_pos), local_(*local), value_(value) {
     ASSERT(local != NULL);
     ASSERT(value_ != NULL);
   }
 
   const LocalVariable& local() const { return local_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(StoreLocalNode);
 
  private:
   const LocalVariable& local_;
   AstNode* value_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StoreLocalNode);
 };
 
 
 class LoadInstanceFieldNode : public AstNode {
  public:
   LoadInstanceFieldNode(TokenPosition token_pos,
                         AstNode* instance,
                         const Field& field)
-      : AstNode(token_pos), instance_(instance),
-        field_(*MayCloneField(field)) {
+      : AstNode(token_pos), instance_(instance), field_(*MayCloneField(field)) {
     ASSERT(instance_ != NULL);
     ASSERT(field_.IsZoneHandle());
   }
 
   AstNode* instance() const { return instance_; }
   const Field& field() const { return field_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     instance()->Visit(visitor);
   }
@@ skipping 53 matching lines @@
       : AstNode(token_pos),
         field_(*MayCloneField(field)),
         is_deferred_reference_(false) {
     ASSERT(field_.IsZoneHandle());
   }
 
   const Field& field() const { return field_; }
   void set_is_deferred(bool value) { is_deferred_reference_ = value; }
   bool is_deferred_reference() const { return is_deferred_reference_; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
-  virtual bool IsPotentiallyConst() const {
-    return field_.is_const();
-  }
+  virtual bool IsPotentiallyConst() const { return field_.is_const(); }
 
   virtual const Instance* EvalConstExpr() const {
     ASSERT(field_.is_static());
     return !is_deferred_reference_ && field_.is_const()
-        ? &Instance::ZoneHandle(field_.StaticValue())
-        : NULL;
+               ? &Instance::ZoneHandle(field_.StaticValue())
+               : NULL;
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(LoadStaticFieldNode);
 
  private:
   const Field& field_;
   bool is_deferred_reference_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LoadStaticFieldNode);
 };
 
 
 class StoreStaticFieldNode : public AstNode {
  public:
   StoreStaticFieldNode(TokenPosition token_pos,
                        const Field& field,
                        AstNode* value)
-      : AstNode(token_pos),
-        field_(*MayCloneField(field)),
-        value_(value) {
+      : AstNode(token_pos), field_(*MayCloneField(field)), value_(value) {
     ASSERT(field_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   const Field& field() const { return field_; }
   AstNode* value() const { return value_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     value()->Visit(visitor);
   }
@@ skipping 45 matching lines @@
 };
 
 
 class StoreIndexedNode : public AstNode {
  public:
   StoreIndexedNode(TokenPosition token_pos,
                    AstNode* array,
                    AstNode* index,
                    AstNode* value,
                    const Class& super_class)
-    : AstNode(token_pos),
-      array_(array),
-      index_expr_(index),
-      value_(value),
-      super_class_(super_class) {
+      : AstNode(token_pos),
+        array_(array),
+        index_expr_(index),
+        value_(value),
+        super_class_(super_class) {
     ASSERT(array_ != NULL);
     ASSERT(index_expr_ != NULL);
     ASSERT(value_ != NULL);
     ASSERT(super_class_.IsZoneHandle());
   }
 
   AstNode* array() const { return array_; }
   AstNode* index_expr() const { return index_expr_; }
   AstNode* value() const { return value_; }
   const Class& super_class() const { return super_class_; }
@@ skipping 131 matching lines @@
   AstNode* value_;
   const bool is_conditional_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceSetterNode);
 };
 
 
 class InitStaticFieldNode : public AstNode {
  public:
   InitStaticFieldNode(TokenPosition token_pos, const Field& field)
-      : AstNode(token_pos),
-        field_(*MayCloneField(field)) {
+      : AstNode(token_pos), field_(*MayCloneField(field)) {
     ASSERT(field_.IsZoneHandle());
   }
 
   const Field& field() const { return field_; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(InitStaticFieldNode);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldNode);
 };
 
 
@@ skipping 26 matching lines @@
     ASSERT(value.IsLibraryPrefix() || value.IsLibrary() || value.IsClass());
     owner_ = value.raw();
   }
   const Object& owner() const { return owner_; }
 
   const Class& cls() const { return cls_; }
   const String& field_name() const { return field_name_; }
   bool is_super_getter() const { return receiver_ != NULL; }
   void set_is_deferred(bool value) { is_deferred_reference_ = value; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   virtual bool IsPotentiallyConst() const;
   virtual const Instance* EvalConstExpr() const;
 
   DECLARE_COMMON_NODE_FUNCTIONS(StaticGetterNode);
 
  private:
   AstNode* receiver_;
@@ skipping 25 matching lines @@
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   // For unresolved setters.
   StaticSetterNode(TokenPosition token_pos,
                    AstNode* receiver,
                    const Class& cls,
                    const String& field_name,
                    AstNode* value)
-  : AstNode(token_pos),
-  receiver_(receiver),
-  cls_(cls),
-  field_name_(field_name),
-  function_(Function::ZoneHandle()),
-  value_(value) {
+      : AstNode(token_pos),
+        receiver_(receiver),
+        cls_(cls),
+        field_name_(field_name),
+        function_(Function::ZoneHandle()),
+        value_(value) {
     ASSERT(cls_.IsZoneHandle());
     ASSERT(field_name_.IsZoneHandle());
     ASSERT(value_ != NULL);
   }
 
   // The receiver is required for a super setter (an instance method
   // that is resolved at compile time rather than at runtime).
   AstNode* receiver() const { return receiver_; }
   const Class& cls() const { return cls_; }
   const String& field_name() const { return field_name_; }
@@ skipping 16 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticSetterNode);
 };
 
 
 class StaticCallNode : public AstNode {
  public:
   StaticCallNode(TokenPosition token_pos,
                  const Function& function,
                  ArgumentListNode* arguments)
-      : AstNode(token_pos),
-        function_(function),
-        arguments_(arguments) {
+      : AstNode(token_pos), function_(function), arguments_(arguments) {
     ASSERT(function_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
   const Function& function() const { return function_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     arguments()->Visit(visitor);
   }
 
   virtual AstNode* MakeAssignmentNode(AstNode* rhs);
 
   DECLARE_COMMON_NODE_FUNCTIONS(StaticCallNode);
 
  private:
   const Function& function_;
   ArgumentListNode* arguments_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCallNode);
 };
 
 
 class ClosureCallNode : public AstNode {
  public:
   ClosureCallNode(TokenPosition token_pos,
                   AstNode* closure,
                   ArgumentListNode* arguments)
-      : AstNode(token_pos),
-        closure_(closure),
-        arguments_(arguments) {
+      : AstNode(token_pos), closure_(closure), arguments_(arguments) {
     ASSERT(closure_ != NULL);
     ASSERT(arguments_ != NULL);
   }
 
   AstNode* closure() const { return closure_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     closure()->Visit(visitor);
     arguments()->Visit(visitor);
@@ skipping 43 matching lines @@
                       ArgumentListNode* arguments)
       : AstNode(token_pos),
         type_arguments_(type_arguments),
         constructor_(constructor),
         arguments_(arguments) {
     ASSERT(type_arguments_.IsZoneHandle());
     ASSERT(constructor_.IsZoneHandle());
     ASSERT(arguments_ != NULL);
   }
 
-  const TypeArguments& type_arguments() const {
-    return type_arguments_;
-  }
+  const TypeArguments& type_arguments() const { return type_arguments_; }
   const Function& constructor() const { return constructor_; }
   ArgumentListNode* arguments() const { return arguments_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     arguments()->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(ConstructorCallNode);
 
  private:
@@ skipping 24 matching lines @@
   }
 
   const Function& function() const { return function_; }
   const String& native_c_function_name() const {
     return native_c_function_name_;
   }
   LocalScope* scope() const { return scope_; }
 
   bool link_lazily() const { return link_lazily_; }
 
-  virtual void VisitChildren(AstNodeVisitor* visitor) const { }
+  virtual void VisitChildren(AstNodeVisitor* visitor) const {}
 
   DECLARE_COMMON_NODE_FUNCTIONS(NativeBodyNode);
 
  private:
   const Function& function_;  // Native Dart function.
   const String& native_c_function_name_;
   LocalScope* scope_;
   const bool link_lazily_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(NativeBodyNode);
@@ skipping 30 matching lines @@
     ASSERT(exception_var != NULL);
     ASSERT(stacktrace_var != NULL);
   }
 
   SequenceNode* sequence() const { return catch_block_; }
   const Array& handler_types() const { return handler_types_; }
   const LocalVariable& context_var() const { return context_var_; }
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
   const LocalVariable& rethrow_exception_var() const {
-      return rethrow_exception_var_;
+    return rethrow_exception_var_;
   }
   const LocalVariable& rethrow_stacktrace_var() const {
-      return rethrow_stacktrace_var_;
+    return rethrow_stacktrace_var_;
   }
   intptr_t catch_handler_index() const { return catch_handler_index_; }
   bool needs_stacktrace() const { return needs_stacktrace_; }
 
   virtual void VisitChildren(AstNodeVisitor* visitor) const {
     catch_block_->Visit(visitor);
   }
 
   DECLARE_COMMON_NODE_FUNCTIONS(CatchClauseNode);
 
@@ skipping 122 matching lines @@
   const intptr_t try_index_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(InlinedFinallyNode);
 };
 
 }  // namespace dart
 
 #undef DECLARE_COMMON_NODE_FUNCTIONS
 
 #endif  // RUNTIME_VM_AST_H_