[runtime] Support Proxy setPrototypeOf trap

src/ast/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
@@ skipping 75 matching lines @@
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
   V(SuperPropertyReference)     \
   V(SuperCallReference)         \
   V(CaseClause)                 \
   V(EmptyParentheses)           \
   V(DoExpression)
 
-#define AST_NODE_LIST(V)                        \
-  DECLARATION_NODE_LIST(V)                      \
-  STATEMENT_NODE_LIST(V)                        \
+#define AST_NODE_LIST(V)   \
+  DECLARATION_NODE_LIST(V) \
+  STATEMENT_NODE_LIST(V)   \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
 class Declaration;
 class Module;
 class BreakableStatement;
 class Expression;
 class IterationStatement;
@@ skipping 75 matching lines @@
 
  private:
   Flags flags_;
   int node_count_;
   FeedbackVectorSpec spec_;
 };
 
 DEFINE_OPERATORS_FOR_FLAGS(AstProperties::Flags)
 
 
-class AstNode: public ZoneObject {
+class AstNode : public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
-  enum NodeType {
-    AST_NODE_LIST(DECLARE_TYPE_ENUM)
-    kInvalid = -1
-  };
+  enum NodeType { AST_NODE_LIST(DECLARE_TYPE_ENUM) kInvalid = -1 };
 #undef DECLARE_TYPE_ENUM
 
   void* operator new(size_t size, Zone* zone) { return zone->New(size); }
 
-  explicit AstNode(int position): position_(position) {}
+  explicit AstNode(int position) : position_(position) {}
   virtual ~AstNode() {}
 
   virtual void Accept(AstVisitor* v) = 0;
   virtual NodeType node_type() const = 0;
   int position() const { return position_; }
 
-  // Type testing & conversion functions overridden by concrete subclasses.
-#define DECLARE_NODE_FUNCTIONS(type) \
+// Type testing & conversion functions overridden by concrete subclasses.
+#define DECLARE_NODE_FUNCTIONS(type)                                \
   bool Is##type() const { return node_type() == AstNode::k##type; } \
-  type* As##type() { \
-    return Is##type() ? reinterpret_cast<type*>(this) : NULL; \
-  } \
-  const type* As##type() const { \
+  type* As##type() {                                                \
+    return Is##type() ? reinterpret_cast<type*>(this) : NULL;       \
+  }                                                                 \
+  const type* As##type() const {                                    \
     return Is##type() ? reinterpret_cast<const type*>(this) : NULL; \
   }
   AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
 
   // The interface for feedback slots, with default no-op implementations for
@@ skipping 49 matching lines @@
       if (at(i)->FindRootMap() != root_map) {
         list_.RemoveElement(list_.at(i));
       }
     }
   }
 
   void Add(Handle<Map> handle, Zone* zone) {
     list_.Add(handle.location(), zone);
   }
 
-  Handle<Map> at(int i) const {
-    return Handle<Map>(list_.at(i));
-  }
+  Handle<Map> at(int i) const { return Handle<Map>(list_.at(i)); }
 
   Handle<Map> first() const { return at(0); }
   Handle<Map> last() const { return at(length() - 1); }
 
  private:
   // The list stores pointers to Map*, that is Map**, so it's GC safe.
   SmallPointerList<Map*> list_;
 
   DISALLOW_COPY_AND_ASSIGN(SmallMapList);
 };
@@ skipping 96 matching lines @@
   Bounds bounds_;
   class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
   uint16_t bit_field_;
   // Ends with 16-bit field; deriving classes in turn begin with
   // 16-bit fields for optimum packing efficiency.
 };
 
 
 class BreakableStatement : public Statement {
  public:
-  enum BreakableType {
-    TARGET_FOR_ANONYMOUS,
-    TARGET_FOR_NAMED_ONLY
-  };
+  enum BreakableType { TARGET_FOR_ANONYMOUS, TARGET_FOR_NAMED_ONLY };
 
   // The labels associated with this statement. May be NULL;
   // if it is != NULL, guaranteed to contain at least one entry.
   ZoneList<const AstRawString*>* labels() const { return labels_; }
 
   // Type testing & conversion.
   BreakableStatement* AsBreakableStatement() final { return this; }
 
   // Code generation
   Label* break_target() { return &break_target_; }
@@ skipping 38 matching lines @@
  public:
   DECLARE_NODE_TYPE(Block)
 
   ZoneList<Statement*>* statements() { return &statements_; }
   bool ignore_completion_value() const { return ignore_completion_value_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId DeclsId() const { return BailoutId(local_id(0)); }
 
   bool IsJump() const override {
-    return !statements_.is_empty() && statements_.last()->IsJump()
-        && labels() == NULL;  // Good enough as an approximation...
+    return !statements_.is_empty() && statements_.last()->IsJump() &&
+           labels() == NULL;  // Good enough as an approximation...
   }
 
   Scope* scope() const { return scope_; }
   void set_scope(Scope* scope) { scope_ = scope; }
 
  protected:
   Block(Zone* zone, ZoneList<const AstRawString*>* labels, int capacity,
         bool ignore_completion_value, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_NAMED_ONLY, pos),
         statements_(capacity, zone),
@@ skipping 90 matching lines @@
  public:
   DECLARE_NODE_TYPE(FunctionDeclaration)
 
   FunctionLiteral* fun() const { return fun_; }
   InitializationFlag initialization() const override {
     return kCreatedInitialized;
   }
   bool IsInlineable() const override;
 
  protected:
-  FunctionDeclaration(Zone* zone,
-                      VariableProxy* proxy,
-                      VariableMode mode,
-                      FunctionLiteral* fun,
-                      Scope* scope,
-                      int pos)
-      : Declaration(zone, proxy, mode, scope, pos),
-        fun_(fun) {
+  FunctionDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
+                      FunctionLiteral* fun, Scope* scope, int pos)
+      : Declaration(zone, proxy, mode, scope, pos), fun_(fun) {
     DCHECK(mode == VAR || mode == LET || mode == CONST);
     DCHECK(fun != NULL);
   }
 
  private:
   FunctionLiteral* fun_;
 };
 
 
 class ImportDeclaration final : public Declaration {
@@ skipping 62 matching lines @@
 
   Statement* body() const { return body_; }
   void set_body(Statement* s) { body_ = s; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
   virtual BailoutId ContinueId() const = 0;
   virtual BailoutId StackCheckId() const = 0;
 
   // Code generation
-  Label* continue_target()  { return &continue_target_; }
+  Label* continue_target() { return &continue_target_; }
 
  protected:
   IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
         body_(NULL) {}
   static int parent_num_ids() { return BreakableStatement::num_ids(); }
   void Initialize(Statement* body) { body_ = body; }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
@@ skipping 56 matching lines @@
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   Expression* cond_;
 };
 
 
 class ForStatement final : public IterationStatement {
  public:
   DECLARE_NODE_TYPE(ForStatement)
 
-  void Initialize(Statement* init,
-                  Expression* cond,
-                  Statement* next,
+  void Initialize(Statement* init, Expression* cond, Statement* next,
                   Statement* body) {
     IterationStatement::Initialize(body);
     init_ = init;
     cond_ = cond;
     next_ = next;
   }
 
   Statement* init() const { return init_; }
   Expression* cond() const { return cond_; }
   Statement* next() const { return next_; }
@@ skipping 16 matching lines @@
 
   Statement* init_;
   Expression* cond_;
   Statement* next_;
 };
 
 
 class ForEachStatement : public IterationStatement {
  public:
   enum VisitMode {
-    ENUMERATE,   // for (each in subject) body;
-    ITERATE      // for (each of subject) body;
+    ENUMERATE,  // for (each in subject) body;
+    ITERATE     // for (each of subject) body;
   };
 
   void Initialize(Expression* each, Expression* subject, Statement* body) {
     IterationStatement::Initialize(body);
     each_ = each;
     subject_ = subject;
   }
 
   Expression* each() const { return each_; }
   Expression* subject() const { return subject_; }
@@ skipping 10 matching lines @@
   Expression* each_;
   Expression* subject_;
   FeedbackVectorSlot each_slot_;
 };
 
 
 class ForInStatement final : public ForEachStatement {
  public:
   DECLARE_NODE_TYPE(ForInStatement)
 
-  Expression* enumerable() const {
-    return subject();
-  }
+  Expression* enumerable() const { return subject(); }
 
   // Type feedback information.
   void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
                                  FeedbackVectorSlotCache* cache) override {
     ForEachStatement::AssignFeedbackVectorSlots(isolate, spec, cache);
     for_in_feedback_slot_ = spec->AddGeneralSlot();
   }
 
   FeedbackVectorSlot ForInFeedbackSlot() {
     DCHECK(!for_in_feedback_slot_.IsInvalid());
@@ skipping 24 matching lines @@
 
   ForInType for_in_type_;
   FeedbackVectorSlot for_in_feedback_slot_;
 };
 
 
 class ForOfStatement final : public ForEachStatement {
  public:
   DECLARE_NODE_TYPE(ForOfStatement)
 
-  void Initialize(Expression* each,
-                  Expression* subject,
-                  Statement* body,
-                  Expression* assign_iterator,
-                  Expression* next_result,
-                  Expression* result_done,
-                  Expression* assign_each) {
+  void Initialize(Expression* each, Expression* subject, Statement* body,
+                  Expression* assign_iterator, Expression* next_result,
+                  Expression* result_done, Expression* assign_each) {
     ForEachStatement::Initialize(each, subject, body);
     assign_iterator_ = assign_iterator;
     next_result_ = next_result;
     result_done_ = result_done;
     assign_each_ = assign_each;
   }
 
-  Expression* iterable() const {
-    return subject();
-  }
+  Expression* iterable() const { return subject(); }
 
   // iterator = subject[Symbol.iterator]()
-  Expression* assign_iterator() const {
-    return assign_iterator_;
-  }
+  Expression* assign_iterator() const { return assign_iterator_; }
 
   // result = iterator.next()  // with type check
-  Expression* next_result() const {
-    return next_result_;
-  }
+  Expression* next_result() const { return next_result_; }
 
   // result.done
-  Expression* result_done() const {
-    return result_done_;
-  }
+  Expression* result_done() const { return result_done_; }
 
   // each = result.value
-  Expression* assign_each() const {
-    return assign_each_;
-  }
+  Expression* assign_each() const { return assign_each_; }
 
   BailoutId ContinueId() const override { return EntryId(); }
   BailoutId StackCheckId() const override { return BackEdgeId(); }
 
   static int num_ids() { return parent_num_ids() + 1; }
   BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
 
  protected:
   ForOfStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
       : ForEachStatement(zone, labels, pos),
@@ skipping 16 matching lines @@
 class ExpressionStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(ExpressionStatement)
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
   bool IsJump() const override { return expression_->IsThrow(); }
 
  protected:
   ExpressionStatement(Zone* zone, Expression* expression, int pos)
-      : Statement(zone, pos), expression_(expression) { }
+      : Statement(zone, pos), expression_(expression) {}
 
  private:
   Expression* expression_;
 };
 
 
 class JumpStatement : public Statement {
  public:
   bool IsJump() const final { return true; }
 
  protected:
   explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
 };
 
 
 class ContinueStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(ContinueStatement)
 
   IterationStatement* target() const { return target_; }
 
  protected:
   explicit ContinueStatement(Zone* zone, IterationStatement* target, int pos)
-      : JumpStatement(zone, pos), target_(target) { }
+      : JumpStatement(zone, pos), target_(target) {}
 
  private:
   IterationStatement* target_;
 };
 
 
 class BreakStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(BreakStatement)
 
   BreakableStatement* target() const { return target_; }
 
  protected:
   explicit BreakStatement(Zone* zone, BreakableStatement* target, int pos)
-      : JumpStatement(zone, pos), target_(target) { }
+      : JumpStatement(zone, pos), target_(target) {}
 
  private:
   BreakableStatement* target_;
 };
 
 
 class ReturnStatement final : public JumpStatement {
  public:
   DECLARE_NODE_TYPE(ReturnStatement)
 
   Expression* expression() const { return expression_; }
 
  protected:
   explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
-      : JumpStatement(zone, pos), expression_(expression) { }
+      : JumpStatement(zone, pos), expression_(expression) {}
 
  private:
   Expression* expression_;
 };
 
 
 class WithStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(WithStatement)
 
@@ skipping 103 matching lines @@
   bool HasElseStatement() const { return !else_statement()->IsEmpty(); }
 
   Expression* condition() const { return condition_; }
   Statement* then_statement() const { return then_statement_; }
   Statement* else_statement() const { return else_statement_; }
 
   void set_then_statement(Statement* s) { then_statement_ = s; }
   void set_else_statement(Statement* s) { else_statement_ = s; }
 
   bool IsJump() const override {
-    return HasThenStatement() && then_statement()->IsJump()
-        && HasElseStatement() && else_statement()->IsJump();
+    return HasThenStatement() && then_statement()->IsJump() &&
+           HasElseStatement() && else_statement()->IsJump();
   }
 
   void set_base_id(int id) { base_id_ = id; }
   static int num_ids() { return parent_num_ids() + 3; }
   BailoutId IfId() const { return BailoutId(local_id(0)); }
   BailoutId ThenId() const { return BailoutId(local_id(1)); }
   BailoutId ElseId() const { return BailoutId(local_id(2)); }
 
  protected:
   IfStatement(Zone* zone, Expression* condition, Statement* then_statement,
@@ skipping 113 matching lines @@
 
   int base_id_;
 };
 
 
 class EmptyStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(EmptyStatement)
 
  protected:
-  explicit EmptyStatement(Zone* zone, int pos): Statement(zone, pos) {}
+  explicit EmptyStatement(Zone* zone, int pos) : Statement(zone, pos) {}
 };
 
 
 // Delegates to another statement, which may be overwritten.
 // This was introduced to implement ES2015 Annex B3.3 for conditionally making
 // sloppy-mode block-scoped functions have a var binding, which is changed
 // from one statement to another during parsing.
 class SloppyBlockFunctionStatement final : public Statement {
  public:
   DECLARE_NODE_TYPE(SloppyBlockFunctionStatement)
@@ skipping 117 matching lines @@
 
 // Property is used for passing information
 // about an object literal's properties from the parser
 // to the code generator.
 class ObjectLiteralProperty final : public ZoneObject {
  public:
   enum Kind {
     CONSTANT,              // Property with constant value (compile time).
     COMPUTED,              // Property with computed value (execution time).
     MATERIALIZED_LITERAL,  // Property value is a materialized literal.
-    GETTER, SETTER,        // Property is an accessor function.
-    PROTOTYPE              // Property is __proto__.
+    GETTER,
+    SETTER,    // Property is an accessor function.
+    PROTOTYPE  // Property is __proto__.
   };
 
   Expression* key() { return key_; }
   Expression* value() { return value_; }
   Kind kind() { return kind_; }
 
   // Type feedback information.
   bool IsMonomorphic() { return !receiver_type_.is_null(); }
   Handle<Map> GetReceiverType() { return receiver_type_; }
 
@@ skipping 84 matching lines @@
 
   enum Flags {
     kNoFlags = 0,
     kFastElements = 1,
     kHasFunction = 1 << 1,
     kShallowProperties = 1 << 2,
     kDisableMementos = 1 << 3,
     kIsStrong = 1 << 4
   };
 
-  struct Accessors: public ZoneObject {
+  struct Accessors : public ZoneObject {
     Accessors() : getter(NULL), setter(NULL) {}
     ObjectLiteralProperty* getter;
     ObjectLiteralProperty* setter;
   };
 
   BailoutId CreateLiteralId() const { return BailoutId(local_id(0)); }
 
   // Return an AST id for a property that is used in simulate instructions.
   BailoutId GetIdForProperty(int i) { return BailoutId(local_id(i + 1)); }
 
@@ skipping 464 matching lines @@
     callnew_feedback_slot_ = spec->AddGeneralSlot();
   }
 
   FeedbackVectorSlot CallNewFeedbackSlot() {
     DCHECK(!callnew_feedback_slot_.IsInvalid());
     return callnew_feedback_slot_;
   }
 
   bool IsMonomorphic() override { return is_monomorphic_; }
   Handle<JSFunction> target() const { return target_; }
-  Handle<AllocationSite> allocation_site() const {
-    return allocation_site_;
-  }
+  Handle<AllocationSite> allocation_site() const { return allocation_site_; }
 
   static int num_ids() { return parent_num_ids() + 1; }
   static int feedback_slots() { return 1; }
   BailoutId ReturnId() const { return BailoutId(local_id(0)); }
 
   void set_allocation_site(Handle<AllocationSite> site) {
     allocation_site_ = site;
   }
   void set_is_monomorphic(bool monomorphic) { is_monomorphic_ = monomorphic; }
   void set_target(Handle<JSFunction> target) { target_ = target; }
@@ skipping 465 matching lines @@
   Throw(Zone* zone, Expression* exception, int pos)
       : Expression(zone, pos), exception_(exception) {}
 
  private:
   Expression* exception_;
 };
 
 
 class FunctionLiteral final : public Expression {
  public:
-  enum FunctionType {
-    ANONYMOUS_EXPRESSION,
-    NAMED_EXPRESSION,
-    DECLARATION
-  };
+  enum FunctionType { ANONYMOUS_EXPRESSION, NAMED_EXPRESSION, DECLARATION };
 
   enum ParameterFlag {
     kNoDuplicateParameters = 0,
     kHasDuplicateParameters = 1
   };
 
-  enum IsFunctionFlag {
-    kGlobalOrEval,
-    kIsFunction
-  };
+  enum IsFunctionFlag { kGlobalOrEval, kIsFunction };
 
   enum EagerCompileHint { kShouldEagerCompile, kShouldLazyCompile };
 
   enum ShouldBeUsedOnceHint { kShouldBeUsedOnce, kDontKnowIfShouldBeUsedOnce };
 
-  enum ArityRestriction {
-    NORMAL_ARITY,
-    GETTER_ARITY,
-    SETTER_ARITY
-  };
+  enum ArityRestriction { NORMAL_ARITY, GETTER_ARITY, SETTER_ARITY };
 
   DECLARE_NODE_TYPE(FunctionLiteral)
 
   Handle<String> name() const { return raw_name_->string(); }
   const AstRawString* raw_name() const { return raw_name_; }
   Scope* scope() const { return scope_; }
   ZoneList<Statement*>* body() const { return body_; }
   void set_function_token_position(int pos) { function_token_position_ = pos; }
   int function_token_position() const { return function_token_position_; }
   int start_position() const;
@@ skipping 28 matching lines @@
       return raw_inferred_name_->string();
     }
     UNREACHABLE();
     return Handle<String>();
   }
 
   // Only one of {set_inferred_name, set_raw_inferred_name} should be called.
   void set_inferred_name(Handle<String> inferred_name) {
     DCHECK(!inferred_name.is_null());
     inferred_name_ = inferred_name;
-    DCHECK(raw_inferred_name_== NULL || raw_inferred_name_->IsEmpty());
+    DCHECK(raw_inferred_name_ == NULL || raw_inferred_name_->IsEmpty());
     raw_inferred_name_ = NULL;
   }
 
   void set_raw_inferred_name(const AstString* raw_inferred_name) {
     DCHECK(raw_inferred_name != NULL);
     raw_inferred_name_ = raw_inferred_name;
     DCHECK(inferred_name_.is_null());
     inferred_name_ = Handle<String>();
   }
 
@@ skipping 262 matching lines @@
 
 #undef DECLARE_NODE_TYPE
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
 class RegExpVisitor BASE_EMBEDDED {
  public:
-  virtual ~RegExpVisitor() { }
-#define MAKE_CASE(Name)                                              \
+  virtual ~RegExpVisitor() {}
+#define MAKE_CASE(Name) \
   virtual void* Visit##Name(RegExp##Name*, void* data) = 0;
   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
 #undef MAKE_CASE
 };
 
 
 class RegExpTree : public ZoneObject {
  public:
   static const int kInfinity = kMaxInt;
   virtual ~RegExpTree() {}
   virtual void* Accept(RegExpVisitor* visitor, void* data) = 0;
   virtual RegExpNode* ToNode(RegExpCompiler* compiler,
                              RegExpNode* on_success) = 0;
   virtual bool IsTextElement() { return false; }
   virtual bool IsAnchoredAtStart() { return false; }
   virtual bool IsAnchoredAtEnd() { return false; }
   virtual int min_match() = 0;
   virtual int max_match() = 0;
   // Returns the interval of registers used for captures within this
   // expression.
   virtual Interval CaptureRegisters() { return Interval::Empty(); }
   virtual void AppendToText(RegExpText* text, Zone* zone);
   std::ostream& Print(std::ostream& os, Zone* zone);  // NOLINT
-#define MAKE_ASTYPE(Name)                                                  \
-  virtual RegExp##Name* As##Name();                                        \
+#define MAKE_ASTYPE(Name)           \
+  virtual RegExp##Name* As##Name(); \
   virtual bool Is##Name();
   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ASTYPE)
 #undef MAKE_ASTYPE
 };
 
 
 class RegExpDisjunction final : public RegExpTree {
  public:
   explicit RegExpDisjunction(ZoneList<RegExpTree*>* alternatives);
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpDisjunction* AsDisjunction() override;
   Interval CaptureRegisters() override;
   bool IsDisjunction() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   int min_match() override { return min_match_; }
   int max_match() override { return max_match_; }
   ZoneList<RegExpTree*>* alternatives() { return alternatives_; }
+
  private:
   bool SortConsecutiveAtoms(RegExpCompiler* compiler);
   void RationalizeConsecutiveAtoms(RegExpCompiler* compiler);
   void FixSingleCharacterDisjunctions(RegExpCompiler* compiler);
   ZoneList<RegExpTree*>* alternatives_;
   int min_match_;
   int max_match_;
 };
 
 
 class RegExpAlternative final : public RegExpTree {
  public:
   explicit RegExpAlternative(ZoneList<RegExpTree*>* nodes);
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpAlternative* AsAlternative() override;
   Interval CaptureRegisters() override;
   bool IsAlternative() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   int min_match() override { return min_match_; }
   int max_match() override { return max_match_; }
   ZoneList<RegExpTree*>* nodes() { return nodes_; }
+
  private:
   ZoneList<RegExpTree*>* nodes_;
   int min_match_;
   int max_match_;
 };
 
 
 class RegExpAssertion final : public RegExpTree {
  public:
   enum AssertionType {
     START_OF_LINE,
     START_OF_INPUT,
     END_OF_LINE,
     END_OF_INPUT,
     BOUNDARY,
     NON_BOUNDARY
   };
-  explicit RegExpAssertion(AssertionType type) : assertion_type_(type) { }
+  explicit RegExpAssertion(AssertionType type) : assertion_type_(type) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpAssertion* AsAssertion() override;
   bool IsAssertion() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   int min_match() override { return 0; }
   int max_match() override { return 0; }
   AssertionType assertion_type() { return assertion_type_; }
+
  private:
   AssertionType assertion_type_;
 };
 
 
 class CharacterSet final BASE_EMBEDDED {
  public:
   explicit CharacterSet(uc16 standard_set_type)
-      : ranges_(NULL),
-        standard_set_type_(standard_set_type) {}
+      : ranges_(NULL), standard_set_type_(standard_set_type) {}
   explicit CharacterSet(ZoneList<CharacterRange>* ranges)
-      : ranges_(ranges),
-        standard_set_type_(0) {}
+      : ranges_(ranges), standard_set_type_(0) {}
   ZoneList<CharacterRange>* ranges(Zone* zone);
   uc16 standard_set_type() { return standard_set_type_; }
   void set_standard_set_type(uc16 special_set_type) {
     standard_set_type_ = special_set_type;
   }
   bool is_standard() { return standard_set_type_ != 0; }
   void Canonicalize();
+
  private:
   ZoneList<CharacterRange>* ranges_;
   // If non-zero, the value represents a standard set (e.g., all whitespace
   // characters) without having to expand the ranges.
   uc16 standard_set_type_;
 };
 
 
 class RegExpCharacterClass final : public RegExpTree {
  public:
   RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
-      : set_(ranges),
-        is_negated_(is_negated) { }
-  explicit RegExpCharacterClass(uc16 type)
-      : set_(type),
-        is_negated_(false) { }
+      : set_(ranges), is_negated_(is_negated) {}
+  explicit RegExpCharacterClass(uc16 type) : set_(type), is_negated_(false) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpCharacterClass* AsCharacterClass() override;
   bool IsCharacterClass() override;
   bool IsTextElement() override { return true; }
   int min_match() override { return 1; }
   int max_match() override { return 1; }
   void AppendToText(RegExpText* text, Zone* zone) override;
   CharacterSet character_set() { return set_; }
   // TODO(lrn): Remove need for complex version if is_standard that
@@ skipping 15 matching lines @@
   bool is_negated() { return is_negated_; }
 
  private:
   CharacterSet set_;
   bool is_negated_;
 };
 
 
 class RegExpAtom final : public RegExpTree {
  public:
-  explicit RegExpAtom(Vector<const uc16> data) : data_(data) { }
+  explicit RegExpAtom(Vector<const uc16> data) : data_(data) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpAtom* AsAtom() override;
   bool IsAtom() override;
   bool IsTextElement() override { return true; }
   int min_match() override { return data_.length(); }
   int max_match() override { return data_.length(); }
   void AppendToText(RegExpText* text, Zone* zone) override;
   Vector<const uc16> data() { return data_; }
   int length() { return data_.length(); }
+
  private:
   Vector<const uc16> data_;
 };
 
 
 class RegExpText final : public RegExpTree {
  public:
   explicit RegExpText(Zone* zone) : elements_(2, zone), length_(0) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpText* AsText() override;
   bool IsText() override;
   bool IsTextElement() override { return true; }
   int min_match() override { return length_; }
   int max_match() override { return length_; }
   void AppendToText(RegExpText* text, Zone* zone) override;
-  void AddElement(TextElement elm, Zone* zone)  {
+  void AddElement(TextElement elm, Zone* zone) {
     elements_.Add(elm, zone);
     length_ += elm.length();
   }
   ZoneList<TextElement>* elements() { return &elements_; }
+
  private:
   ZoneList<TextElement> elements_;
   int length_;
 };
 
 
 class RegExpQuantifier final : public RegExpTree {
  public:
   enum QuantifierType { GREEDY, NON_GREEDY, POSSESSIVE };
   RegExpQuantifier(int min, int max, QuantifierType type, RegExpTree* body)
       : body_(body),
         min_(min),
         max_(max),
         min_match_(min * body->min_match()),
         quantifier_type_(type) {
     if (max > 0 && body->max_match() > kInfinity / max) {
       max_match_ = kInfinity;
     } else {
       max_match_ = max * body->max_match();
     }
   }
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  static RegExpNode* ToNode(int min,
-                            int max,
-                            bool is_greedy,
-                            RegExpTree* body,
-                            RegExpCompiler* compiler,
-                            RegExpNode* on_success,
+  static RegExpNode* ToNode(int min, int max, bool is_greedy, RegExpTree* body,
+                            RegExpCompiler* compiler, RegExpNode* on_success,
                             bool not_at_start = false);
   RegExpQuantifier* AsQuantifier() override;
   Interval CaptureRegisters() override;
   bool IsQuantifier() override;
   int min_match() override { return min_match_; }
   int max_match() override { return max_match_; }
   int min() { return min_; }
   int max() { return max_; }
   bool is_possessive() { return quantifier_type_ == POSSESSIVE; }
   bool is_non_greedy() { return quantifier_type_ == NON_GREEDY; }
   bool is_greedy() { return quantifier_type_ == GREEDY; }
   RegExpTree* body() { return body_; }
 
  private:
   RegExpTree* body_;
   int min_;
   int max_;
   int min_match_;
   int max_match_;
   QuantifierType quantifier_type_;
 };
 
 
 class RegExpCapture final : public RegExpTree {
  public:
   explicit RegExpCapture(int index) : body_(NULL), index_(index) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
-  static RegExpNode* ToNode(RegExpTree* body,
-                            int index,
-                            RegExpCompiler* compiler,
-                            RegExpNode* on_success);
+  static RegExpNode* ToNode(RegExpTree* body, int index,
+                            RegExpCompiler* compiler, RegExpNode* on_success);
   RegExpCapture* AsCapture() override;
   bool IsAnchoredAtStart() override;
   bool IsAnchoredAtEnd() override;
   Interval CaptureRegisters() override;
   bool IsCapture() override;
   int min_match() override { return body_->min_match(); }
   int max_match() override { return body_->max_match(); }
   RegExpTree* body() { return body_; }
   void set_body(RegExpTree* body) { body_ = body; }
   int index() { return index_; }
@@ skipping 36 matching lines @@
   RegExpTree* body_;
   bool is_positive_;
   int capture_count_;
   int capture_from_;
   Type type_;
 };
 
 
 class RegExpBackReference final : public RegExpTree {
  public:
-  explicit RegExpBackReference(RegExpCapture* capture)
-      : capture_(capture) { }
+  explicit RegExpBackReference(RegExpCapture* capture) : capture_(capture) {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpBackReference* AsBackReference() override;
   bool IsBackReference() override;
   int min_match() override { return 0; }
   // The capture may not be completely parsed yet, if the reference occurs
   // before the capture. In the ordinary case, nothing has been captured yet,
   // so the back reference must have the length 0. If the back reference is
   // inside a lookbehind, effectively making it a forward reference, we return
   // 0 since lookbehinds have a length of 0.
   int max_match() override {
     return capture_->body() ? capture_->max_match() : 0;
   }
   int index() { return capture_->index(); }
   RegExpCapture* capture() { return capture_; }
+
  private:
   RegExpCapture* capture_;
 };
 
 
 class RegExpEmpty final : public RegExpTree {
  public:
-  RegExpEmpty() { }
+  RegExpEmpty() {}
   void* Accept(RegExpVisitor* visitor, void* data) override;
   RegExpNode* ToNode(RegExpCompiler* compiler, RegExpNode* on_success) override;
   RegExpEmpty* AsEmpty() override;
   bool IsEmpty() override;
   int min_match() override { return 0; }
   int max_match() override { return 0; }
 };
 
 
 // ----------------------------------------------------------------------------
 // Basic visitor
 // - leaf node visitors are abstract.
 
 class AstVisitor BASE_EMBEDDED {
  public:
   AstVisitor() {}
   virtual ~AstVisitor() {}
 
   // Stack overflow check and dynamic dispatch.
   virtual void Visit(AstNode* node) = 0;
 
   // Iteration left-to-right.
   virtual void VisitDeclarations(ZoneList<Declaration*>* declarations);
   virtual void VisitStatements(ZoneList<Statement*>* statements);
   virtual void VisitExpressions(ZoneList<Expression*>* expressions);
 
-  // Individual AST nodes.
-#define DEF_VISIT(type)                         \
-  virtual void Visit##type(type* node) = 0;
+// Individual AST nodes.
+#define DEF_VISIT(type) virtual void Visit##type(type* node) = 0;
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
 
 #define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS()               \
  public:                                                    \
   void Visit(AstNode* node) final {                         \
     if (!CheckStackOverflow()) node->Accept(this);          \
   }                                                         \
@@ skipping 42 matching lines @@
       VariableProxy* proxy, VariableMode mode, Scope* scope, int pos,
       bool is_class_declaration = false, int declaration_group_start = -1) {
     return new (parser_zone_)
         VariableDeclaration(parser_zone_, proxy, mode, scope, pos,
                             is_class_declaration, declaration_group_start);
   }
 
   FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
                                               VariableMode mode,
                                               FunctionLiteral* fun,
-                                              Scope* scope,
-                                              int pos) {
+                                              Scope* scope, int pos) {
     return new (parser_zone_)
         FunctionDeclaration(parser_zone_, proxy, mode, fun, scope, pos);
   }
 
   ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,
                                           const AstRawString* import_name,
                                           const AstRawString* module_specifier,
                                           Scope* scope, int pos) {
     return new (parser_zone_) ImportDeclaration(
         parser_zone_, proxy, import_name, module_specifier, scope, pos);
   }
 
-  ExportDeclaration* NewExportDeclaration(VariableProxy* proxy,
-                                          Scope* scope,
+  ExportDeclaration* NewExportDeclaration(VariableProxy* proxy, Scope* scope,
                                           int pos) {
     return new (parser_zone_)
         ExportDeclaration(parser_zone_, proxy, scope, pos);
   }
 
   Block* NewBlock(ZoneList<const AstRawString*>* labels, int capacity,
                   bool ignore_completion_value, int pos) {
     return new (local_zone_)
         Block(local_zone_, labels, capacity, ignore_completion_value, pos);
   }
@@ skipping 32 matching lines @@
   }
 
   BreakStatement* NewBreakStatement(BreakableStatement* target, int pos) {
     return new (local_zone_) BreakStatement(local_zone_, target, pos);
   }
 
   ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
     return new (local_zone_) ReturnStatement(local_zone_, expression, pos);
   }
 
-  WithStatement* NewWithStatement(Scope* scope,
-                                  Expression* expression,
-                                  Statement* statement,
-                                  int pos) {
+  WithStatement* NewWithStatement(Scope* scope, Expression* expression,
+                                  Statement* statement, int pos) {
     return new (local_zone_)
         WithStatement(local_zone_, scope, expression, statement, pos);
   }
 
-  IfStatement* NewIfStatement(Expression* condition,
-                              Statement* then_statement,
-                              Statement* else_statement,
-                              int pos) {
+  IfStatement* NewIfStatement(Expression* condition, Statement* then_statement,
+                              Statement* else_statement, int pos) {
     return new (local_zone_) IfStatement(local_zone_, condition, then_statement,
                                          else_statement, pos);
   }
 
   TryCatchStatement* NewTryCatchStatement(Block* try_block, Scope* scope,
                                           Variable* variable,
                                           Block* catch_block, int pos) {
     return new (local_zone_) TryCatchStatement(local_zone_, try_block, scope,
                                                variable, catch_block, pos);
   }
@@ skipping 11 matching lines @@
   EmptyStatement* NewEmptyStatement(int pos) {
     return new (local_zone_) EmptyStatement(local_zone_, pos);
   }
 
   SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(
       Statement* statement, Scope* scope) {
     return new (local_zone_)
         SloppyBlockFunctionStatement(local_zone_, statement, scope);
   }
 
-  CaseClause* NewCaseClause(
-      Expression* label, ZoneList<Statement*>* statements, int pos) {
+  CaseClause* NewCaseClause(Expression* label, ZoneList<Statement*>* statements,
+                            int pos) {
     return new (local_zone_) CaseClause(local_zone_, label, statements, pos);
   }
 
   Literal* NewStringLiteral(const AstRawString* string, int pos) {
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewString(string), pos);
   }
 
   // A JavaScript symbol (ECMA-262 edition 6).
   Literal* NewSymbolLiteral(const char* name, int pos) {
@@ skipping 25 matching lines @@
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewUndefined(), pos);
   }
 
   Literal* NewTheHoleLiteral(int pos) {
     return new (local_zone_)
         Literal(local_zone_, ast_value_factory_->NewTheHole(), pos);
   }
 
   ObjectLiteral* NewObjectLiteral(
-      ZoneList<ObjectLiteral::Property*>* properties,
-      int literal_index,
-      int boilerplate_properties,
-      bool has_function,
-      bool is_strong,
-      int pos) {
+      ZoneList<ObjectLiteral::Property*>* properties, int literal_index,
+      int boilerplate_properties, bool has_function, bool is_strong, int pos) {
     return new (local_zone_)
         ObjectLiteral(local_zone_, properties, literal_index,
                       boilerplate_properties, has_function, is_strong, pos);
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(
       Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
       bool is_static, bool is_computed_name) {
     return new (local_zone_)
         ObjectLiteral::Property(key, value, kind, is_static, is_computed_name);
   }
 
   ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
                                                     Expression* value,
                                                     bool is_static,
                                                     bool is_computed_name) {
     return new (local_zone_) ObjectLiteral::Property(
         ast_value_factory_, key, value, is_static, is_computed_name);
   }
 
   RegExpLiteral* NewRegExpLiteral(const AstRawString* pattern, int flags,
                                   int literal_index, bool is_strong, int pos) {
     return new (local_zone_) RegExpLiteral(local_zone_, pattern, flags,
                                            literal_index, is_strong, pos);
   }
 
   ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
-                                int literal_index,
-                                bool is_strong,
-                                int pos) {
+                                int literal_index, bool is_strong, int pos) {
     return new (local_zone_)
         ArrayLiteral(local_zone_, values, -1, literal_index, is_strong, pos);
   }
 
   ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
                                 int first_spread_index, int literal_index,
                                 bool is_strong, int pos) {
     return new (local_zone_) ArrayLiteral(
         local_zone_, values, first_spread_index, literal_index, is_strong, pos);
   }
@@ skipping 11 matching lines @@
                                   int end_position = RelocInfo::kNoPosition) {
     DCHECK_NOT_NULL(name);
     return new (parser_zone_) VariableProxy(parser_zone_, name, variable_kind,
                                             start_position, end_position);
   }
 
   Property* NewProperty(Expression* obj, Expression* key, int pos) {
     return new (local_zone_) Property(local_zone_, obj, key, pos);
   }
 
-  Call* NewCall(Expression* expression,
-                ZoneList<Expression*>* arguments,
+  Call* NewCall(Expression* expression, ZoneList<Expression*>* arguments,
                 int pos) {
     return new (local_zone_) Call(local_zone_, expression, arguments, pos);
   }
 
-  CallNew* NewCallNew(Expression* expression,
-                      ZoneList<Expression*>* arguments,
+  CallNew* NewCallNew(Expression* expression, ZoneList<Expression*>* arguments,
                       int pos) {
     return new (local_zone_) CallNew(local_zone_, expression, arguments, pos);
   }
 
   CallRuntime* NewCallRuntime(Runtime::FunctionId id,
                               ZoneList<Expression*>* arguments, int pos) {
     return new (local_zone_)
         CallRuntime(local_zone_, Runtime::FunctionForId(id), arguments, pos);
   }
 
   CallRuntime* NewCallRuntime(const Runtime::Function* function,
                               ZoneList<Expression*>* arguments, int pos) {
     return new (local_zone_) CallRuntime(local_zone_, function, arguments, pos);
   }
 
   CallRuntime* NewCallRuntime(int context_index,
                               ZoneList<Expression*>* arguments, int pos) {
     return new (local_zone_)
         CallRuntime(local_zone_, context_index, arguments, pos);
   }
 
-  UnaryOperation* NewUnaryOperation(Token::Value op,
-                                    Expression* expression,
+  UnaryOperation* NewUnaryOperation(Token::Value op, Expression* expression,
                                     int pos) {
     return new (local_zone_) UnaryOperation(local_zone_, op, expression, pos);
   }
 
-  BinaryOperation* NewBinaryOperation(Token::Value op,
-                                      Expression* left,
-                                      Expression* right,
-                                      int pos) {
+  BinaryOperation* NewBinaryOperation(Token::Value op, Expression* left,
+                                      Expression* right, int pos) {
     return new (local_zone_) BinaryOperation(local_zone_, op, left, right, pos);
   }
 
-  CountOperation* NewCountOperation(Token::Value op,
-                                    bool is_prefix,
-                                    Expression* expr,
-                                    int pos) {
+  CountOperation* NewCountOperation(Token::Value op, bool is_prefix,
+                                    Expression* expr, int pos) {
     return new (local_zone_)
         CountOperation(local_zone_, op, is_prefix, expr, pos);
   }
 
-  CompareOperation* NewCompareOperation(Token::Value op,
-                                        Expression* left,
-                                        Expression* right,
-                                        int pos) {
+  CompareOperation* NewCompareOperation(Token::Value op, Expression* left,
+                                        Expression* right, int pos) {
     return new (local_zone_)
         CompareOperation(local_zone_, op, left, right, pos);
   }
 
   Spread* NewSpread(Expression* expression, int pos) {
     return new (local_zone_) Spread(local_zone_, expression, pos);
   }
 
   Conditional* NewConditional(Expression* condition,
                               Expression* then_expression,
-                              Expression* else_expression,
-                              int position) {
+                              Expression* else_expression, int position) {
     return new (local_zone_) Conditional(
         local_zone_, condition, then_expression, else_expression, position);
   }
 
-  Assignment* NewAssignment(Token::Value op,
-                            Expression* target,
-                            Expression* value,
-                            int pos) {
+  Assignment* NewAssignment(Token::Value op, Expression* target,
+                            Expression* value, int pos) {
     DCHECK(Token::IsAssignmentOp(op));
     Assignment* assign =
         new (local_zone_) Assignment(local_zone_, op, target, value, pos);
     if (assign->is_compound()) {
       DCHECK(Token::IsAssignmentOp(op));
       assign->binary_operation_ =
           NewBinaryOperation(assign->binary_op(), target, value, pos + 1);
     }
     return assign;
   }
 
-  Yield* NewYield(Expression *generator_object,
-                  Expression* expression,
-                  Yield::Kind yield_kind,
-                  int pos) {
+  Yield* NewYield(Expression* generator_object, Expression* expression,
+                  Yield::Kind yield_kind, int pos) {
     if (!expression) expression = NewUndefinedLiteral(pos);
     return new (local_zone_)
         Yield(local_zone_, generator_object, expression, yield_kind, pos);
   }
 
   Throw* NewThrow(Expression* exception, int pos) {
     return new (local_zone_) Throw(local_zone_, exception, pos);
   }
 
   FunctionLiteral* NewFunctionLiteral(
@@ skipping 86 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_