CSE2410 Fall 2014 Bounce

#define EXPRESSION_NODE_LIST(V)                 \

  V(FunctionLiteral)                            \

  V(Conditional)                                \

  V(VariableProxy)                              \

  V(Literal)                                    \

  V(CompareOperation)                           \

  V(ThisFunction)

#define AST_NODE_LIST(V)                        \

  DECLARATION_NODE_LIST(V)                      \

  MODULE_NODE_LIST(V)                           \

  STATEMENT_NODE_LIST(V)                        \

// Forward declarations

class AstConstructionVisitor;

    return zone->New(static_cast<int>(size));

  }

  virtual ~AstNode() {}

  virtual void Accept(AstVisitor* v) = 0;

  virtual NodeType node_type() const = 0;

  // Type testing & conversion functions overridden by concrete subclasses.

#define DECLARE_NODE_FUNCTIONS(type)                  \

  void* operator new(size_t size);

  friend class CaseClause;  // Generates AST IDs.

};

class Statement : public AstNode {

 public:

  bool IsEmpty() { return AsEmptyStatement() != NULL; }

  virtual bool IsJump() const { return false; }

};

    kTest

  };

  virtual bool IsValidLeftHandSide() { return false; }

  // Helpers for ToBoolean conversion.

  TypeFeedbackId test_id() const { return test_id_; }

 protected:

        id_(GetNextId(isolate)),

        test_id_(GetNextId(isolate)) {}

  void set_to_boolean_types(byte types) { to_boolean_types_ = types; }

 protected:

  BreakableStatement(

        breakable_type_(breakable_type),

        entry_id_(GetNextId(isolate)),

        exit_id_(GetNextId(isolate)) {

        ZoneStringList* labels,

        int capacity,

        bool is_initializer_block,

        Zone* zone)

        statements_(capacity, zone),

        is_initializer_block_(is_initializer_block),

        scope_(NULL) {

 protected:

  Declaration(VariableProxy* proxy,

              VariableMode mode,

        mode_(mode),

        scope_(scope) {

    ASSERT(IsDeclaredVariableMode(mode));

 protected:

  VariableDeclaration(VariableProxy* proxy,

                      VariableMode mode,

  }

};

  FunctionDeclaration(VariableProxy* proxy,

                      VariableMode mode,

                      FunctionLiteral* fun,

        fun_(fun) {

    // At the moment there are no "const functions" in JavaScript...

    ASSERT(mode == VAR || mode == LET);

 protected:

  ModuleDeclaration(VariableProxy* proxy,

                    Module* module,

        module_(module) {

  }

 protected:

  ImportDeclaration(VariableProxy* proxy,

                    Module* module,

        module_(module) {

  }

  }

 protected:

};

  Block* body() const { return body_; }

 protected:

        body_(NULL) {}

        body_(body) {}

 private:

  DECLARE_NODE_TYPE(ModuleLiteral)

 protected:

};

  VariableProxy* proxy() const { return proxy_; }

 protected:

 private:

  VariableProxy* proxy_;

  Handle<String> name() const { return name_; }

 protected:

        module_(module),

        name_(name) {

  }

  Handle<String> url() const { return url_; }

 protected:

  }

 private:

  Block* body() const { return body_; }

 protected:

        body_(body) {

  }

  Label* continue_target()  { return &continue_target_; }

 protected:

        body_(NULL),

        osr_entry_id_(GetNextId(isolate)) {

  }

  Expression* cond() const { return cond_; }

  virtual BailoutId ContinueId() const V8_OVERRIDE { return continue_id_; }

  virtual BailoutId StackCheckId() const V8_OVERRIDE { return back_edge_id_; }

  BailoutId BackEdgeId() const { return back_edge_id_; }

 protected:

        cond_(NULL),

        continue_id_(GetNextId(isolate)),

        back_edge_id_(GetNextId(isolate)) {

  }

 private:

  Expression* cond_;

  const BailoutId continue_id_;

  const BailoutId back_edge_id_;

};

  BailoutId BodyId() const { return body_id_; }

 protected:

        cond_(NULL),

        may_have_function_literal_(true),

        body_id_(GetNextId(isolate)) {

  void set_loop_variable(Variable* var) { loop_variable_ = var; }

 protected:

        init_(NULL),

        cond_(NULL),

        next_(NULL),

  Expression* subject() const { return subject_; }

 protected:

        each_(NULL),

        subject_(NULL) {

  }

  virtual BailoutId StackCheckId() const V8_OVERRIDE { return body_id_; }

 protected:

        for_in_type_(SLOW_FOR_IN),

        body_id_(GetNextId(isolate)),

        prepare_id_(GetNextId(isolate)) {

  BailoutId BackEdgeId() const { return back_edge_id_; }

 protected:

        assign_iterator_(NULL),

        next_result_(NULL),

        result_done_(NULL),

  virtual bool IsJump() const V8_OVERRIDE { return expression_->IsThrow(); }

 protected:

 private:

  Expression* expression_;

  virtual bool IsJump() const V8_FINAL V8_OVERRIDE { return true; }

 protected:

};

  IterationStatement* target() const { return target_; }

 protected:

 private:

  IterationStatement* target_;

  BreakableStatement* target() const { return target_; }

 protected:

 private:

  BreakableStatement* target_;

  Expression* expression() const { return expression_; }

 protected:

 private:

  Expression* expression_;

  Statement* statement() const { return statement_; }

 protected:

        expression_(expression),

        statement_(statement) { }

};

 public:

  bool is_default() const { return label_ == NULL; }

  Expression* label() const {

  Label* body_target() { return &body_target_; }

  ZoneList<Statement*>* statements() const { return statements_; }

  BailoutId EntryId() const { return entry_id_; }

  // Type feedback information.

  Handle<Type> compare_type() { return compare_type_; }

 private:

  Expression* label_;

  Label body_target_;

  ZoneList<Statement*>* statements_;

  Handle<Type> compare_type_;

  const TypeFeedbackId compare_id_;

  void set_switch_type(SwitchType switch_type) { switch_type_ = switch_type; }

 protected:

        tag_(NULL),

        cases_(NULL) { }

  IfStatement(Isolate* isolate,

              Expression* condition,

              Statement* then_statement,

        then_statement_(then_statement),

        else_statement_(else_statement),

        if_id_(GetNextId(isolate)),

// stack in the compiler; this should probably be reworked.

class TargetCollector V8_FINAL : public AstNode {

 public:

  // Adds a jump target to the collector. The collector stores a pointer not

  // a copy of the target to make binding work, so make sure not to pass in

  ZoneList<Label*>* escaping_targets() const { return escaping_targets_; }

 protected:

        try_block_(try_block),

        escaping_targets_(NULL) { }

                    Block* try_block,

                    Scope* scope,

                    Variable* variable,

        scope_(scope),

        variable_(variable),

        catch_block_(catch_block) {

  Block* finally_block() const { return finally_block_; }

 protected:

        finally_block_(finally_block) { }

 private:

  DECLARE_NODE_TYPE(DebuggerStatement)

 protected:

};

  DECLARE_NODE_TYPE(EmptyStatement)

 protected:

};

  TypeFeedbackId LiteralFeedbackId() const { return reuse(id()); }

 protected:

        value_(value),

        isolate_(isolate) { }

  MaterializedLiteral(Isolate* isolate,

                      int literal_index,

                      bool is_simple,

        literal_index_(literal_index),

        is_simple_(is_simple),

        depth_(depth) {}

                bool fast_elements,

                int depth,

                bool may_store_doubles,

        constant_properties_(constant_properties),

        properties_(properties),

        fast_elements_(fast_elements),

  RegExpLiteral(Isolate* isolate,

                Handle<String> pattern,

                Handle<String> flags,

        pattern_(pattern),

        flags_(flags) {}

  Handle<String> flags_;

};

// An array literal has a literals object that is used

// for minimizing the work when constructing it at runtime.

class ArrayLiteral V8_FINAL : public MaterializedLiteral {

               ZoneList<Expression*>* values,

               int literal_index,

               bool is_simple,

        constant_elements_(constant_elements),

        values_(values),

        first_element_id_(ReserveIdRange(isolate, values->length())) {}

  Handle<String> name() const { return name_; }

  Variable* var() const { return var_; }

  bool is_this() const { return is_this_; }

  Interface* interface() const { return interface_; }

  void BindTo(Variable* var);

 protected:

  VariableProxy(Isolate* isolate,

                Handle<String> name,

  // True if this variable proxy is being used in an assignment

  // or with a increment/decrement operator.

  bool is_lvalue_;

  Interface* interface_;

};

  Expression* obj() const { return obj_; }

  Expression* key() const { return key_; }

  BailoutId LoadId() const { return load_id_; }

  bool IsStringAccess() const { return is_string_access_; }

  bool IsFunctionPrototype() const { return is_function_prototype_; }

    return STANDARD_STORE;

  }

  bool IsUninitialized() { return is_uninitialized_; }

  TypeFeedbackId PropertyFeedbackId() { return reuse(id()); }

 protected:

           Expression* obj,

           Expression* key,

           int pos)

        obj_(obj),

        key_(key),

        load_id_(GetNextId(isolate)),

        is_monomorphic_(false),

        is_uninitialized_(false),

        is_string_access_(false),

        is_function_prototype_(false) { }

 private:

  Expression* obj_;

  Expression* key_;

  const BailoutId load_id_;

  SmallMapList receiver_types_;

  bool is_monomorphic_ : 1;

  bool is_uninitialized_ : 1;

  bool is_string_access_ : 1;

  bool is_function_prototype_ : 1;

};

  Expression* expression() const { return expression_; }

  ZoneList<Expression*>* arguments() const { return arguments_; }

  // Type feedback information.

  TypeFeedbackId CallFeedbackId() const { return reuse(id()); }

       Expression* expression,

       ZoneList<Expression*>* arguments,

       int pos)

        expression_(expression),

        arguments_(arguments),

        is_monomorphic_(false),

        check_type_(RECEIVER_MAP_CHECK),

        return_id_(GetNextId(isolate)) { }

 private:

  Expression* expression_;

  ZoneList<Expression*>* arguments_;

  bool is_monomorphic_;

  CheckType check_type_;

  Expression* expression() const { return expression_; }

  ZoneList<Expression*>* arguments() const { return arguments_; }

  // Type feedback information.

  TypeFeedbackId CallNewFeedbackId() const { return reuse(id()); }

          Expression* expression,

          ZoneList<Expression*>* arguments,

          int pos)

        expression_(expression),

        arguments_(arguments),

        is_monomorphic_(false),

        elements_kind_(GetInitialFastElementsKind()),

        return_id_(GetNextId(isolate)) { }

 private:

  Expression* expression_;

  ZoneList<Expression*>* arguments_;

  bool is_monomorphic_;

  Handle<JSFunction> target_;

  CallRuntime(Isolate* isolate,

              Handle<String> name,

              const Runtime::Function* function,

        name_(name),

        function_(function),

        arguments_(arguments) { }

  Token::Value op() const { return op_; }

  Expression* expression() const { return expression_; }

  BailoutId MaterializeTrueId() { return materialize_true_id_; }

  BailoutId MaterializeFalseId() { return materialize_false_id_; }

                 Token::Value op,

                 Expression* expression,

                 int pos)

        op_(op),

        expression_(expression),

        materialize_true_id_(GetNextId(isolate)),

        materialize_false_id_(GetNextId(isolate)) {

    ASSERT(Token::IsUnaryOp(op));

 private:

  Token::Value op_;

  Expression* expression_;

  // For unary not (Token::NOT), the AST ids where true and false will

  // actually be materialized, respectively.

  Token::Value op() const { return op_; }

  Expression* left() const { return left_; }

  Expression* right() const { return right_; }

  BailoutId RightId() const { return right_id_; }

                  Expression* left,

                  Expression* right,

                  int pos)

        op_(op),

        left_(left),

        right_(right),

        right_id_(GetNextId(isolate)) {

    ASSERT(Token::IsBinaryOp(op));

  }

  Token::Value op_;

  Expression* left_;

  Expression* right_;

  // TODO(rossberg): the fixed arg should probably be represented as a Constant

  // type for the RHS.

  }

  Expression* expression() const { return expression_; }

  void RecordTypeFeedback(TypeFeedbackOracle* oracle, Zone* zone);

  virtual bool IsMonomorphic() V8_OVERRIDE { return is_monomorphic_; }

  virtual KeyedAccessStoreMode GetStoreMode() V8_OVERRIDE {

    return store_mode_;

  }

  BailoutId AssignmentId() const { return assignment_id_; }

                 bool is_prefix,

                 Expression* expr,

                 int pos)

        op_(op),

        is_prefix_(is_prefix),

        is_monomorphic_(false),

        store_mode_(STANDARD_STORE),

        expression_(expr),

        assignment_id_(GetNextId(isolate)),

        count_id_(GetNextId(isolate)) {}

  bool is_monomorphic_ : 1;

  KeyedAccessStoreMode store_mode_ : 5;  // Windows treats as signed,

                                         // must have extra bit.

  Expression* expression_;

  const BailoutId assignment_id_;

  const TypeFeedbackId count_id_;

  SmallMapList receiver_types_;

  Token::Value op() const { return op_; }

  Expression* left() const { return left_; }

  Expression* right() const { return right_; }

  // Type feedback information.

  TypeFeedbackId CompareOperationFeedbackId() const { return reuse(id()); }

                   Expression* left,

                   Expression* right,

                   int pos)

        op_(op),

        left_(left),

        right_(right),

    ASSERT(Token::IsCompareOp(op));

  }

  Token::Value op_;

  Expression* left_;

  Expression* right_;

  Handle<Type> combined_type_;

};

  Expression* then_expression() const { return then_expression_; }

  Expression* else_expression() const { return else_expression_; }

  BailoutId ThenId() const { return then_id_; }

  BailoutId ElseId() const { return else_id_; }

              Expression* condition,

              Expression* then_expression,

              Expression* else_expression,

        condition_(condition),

        then_expression_(then_expression),

        else_expression_(else_expression),

        then_id_(GetNextId(isolate)),

        else_id_(GetNextId(isolate)) { }

  Expression* condition_;

  Expression* then_expression_;

  Expression* else_expression_;

  const BailoutId then_id_;

  const BailoutId else_id_;

};

  Token::Value op() const { return op_; }

  Expression* target() const { return target_; }

  Expression* value() const { return value_; }

  BinaryOperation* binary_operation() const { return binary_operation_; }

  // This check relies on the definition order of token in token.h.

  void RecordTypeFeedback(TypeFeedbackOracle* oracle, Zone* zone);

  virtual bool IsMonomorphic() V8_OVERRIDE { return is_monomorphic_; }

  bool IsUninitialized() { return is_uninitialized_; }

  virtual SmallMapList* GetReceiverTypes() V8_OVERRIDE {

    return &receiver_types_;

  }

  void Init(Isolate* isolate, AstNodeFactory<Visitor>* factory) {

    ASSERT(Token::IsAssignmentOp(op_));

    if (is_compound()) {

    }

  }

  Token::Value op_;

  Expression* target_;

  Expression* value_;

  BinaryOperation* binary_operation_;

  const BailoutId assignment_id_;

  bool is_monomorphic_ : 1;

  bool is_uninitialized_ : 1;

  KeyedAccessStoreMode store_mode_ : 5;  // Windows treats as signed,

                                         // must have extra bit.

  SmallMapList receiver_types_;

  Expression* generator_object() const { return generator_object_; }

  Expression* expression() const { return expression_; }

  Kind yield_kind() const { return yield_kind_; }

  // Delegating yield surrounds the "yield" in a "try/catch".  This index

  // locates the catch handler in the handler table, and is equivalent to

        Expression* expression,

        Kind yield_kind,

        int pos)

        generator_object_(generator_object),

        expression_(expression),

        yield_kind_(yield_kind),

 private:

  Expression* generator_object_;

  Expression* expression_;

  Kind yield_kind_;

  int index_;

};

  DECLARE_NODE_TYPE(Throw)

  Expression* exception() const { return exception_; }

 protected:

  Throw(Isolate* isolate, Expression* exception, int pos)

 private:

  Expression* exception_;

};

                  ParameterFlag has_duplicate_parameters,

                  IsFunctionFlag is_function,

                  IsParenthesizedFlag is_parenthesized,

        name_(name),

        scope_(scope),

        body_(body),

};

 public:

 protected:

 private:

};

  DECLARE_NODE_TYPE(ThisFunction)

 protected:

};

#undef DECLARE_NODE_TYPE

// ----------------------------------------------------------------------------

// Out-of-line inline constructors (to side-step cyclic dependencies).

      proxy_(proxy) {

}

  VariableDeclaration* NewVariableDeclaration(VariableProxy* proxy,

                                              VariableMode mode,

    VariableDeclaration* decl =

    VISIT_AND_RETURN(VariableDeclaration, decl)

  }

  FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,

                                              VariableMode mode,

                                              FunctionLiteral* fun,

    FunctionDeclaration* decl =

    VISIT_AND_RETURN(FunctionDeclaration, decl)

  }

  ModuleDeclaration* NewModuleDeclaration(VariableProxy* proxy,

                                          Module* module,

    ModuleDeclaration* decl =

    VISIT_AND_RETURN(ModuleDeclaration, decl)

  }

  ImportDeclaration* NewImportDeclaration(VariableProxy* proxy,

                                          Module* module,

    ImportDeclaration* decl =

    VISIT_AND_RETURN(ImportDeclaration, decl)

  }

  ExportDeclaration* NewExportDeclaration(VariableProxy* proxy,

    ExportDeclaration* decl =

    VISIT_AND_RETURN(ExportDeclaration, decl)

  }

    VISIT_AND_RETURN(ModuleLiteral, module)

  }

    VISIT_AND_RETURN(ModuleVariable, module)

  }

    VISIT_AND_RETURN(ModulePath, module)

  }

    VISIT_AND_RETURN(ModuleUrl, module)

  }

  Block* NewBlock(ZoneStringList* labels,

                  int capacity,

    Block* block = new(zone_) Block(

    VISIT_AND_RETURN(Block, block)

  }

#define STATEMENT_WITH_LABELS(NodeType) \

    VISIT_AND_RETURN(NodeType, stmt); \

  }

  STATEMENT_WITH_LABELS(DoWhileStatement)

#undef STATEMENT_WITH_LABELS

  ForEachStatement* NewForEachStatement(ForEachStatement::VisitMode visit_mode,

    switch (visit_mode) {

      case ForEachStatement::ENUMERATE: {

        VISIT_AND_RETURN(ForInStatement, stmt);

      }

      case ForEachStatement::ITERATE: {

        VISIT_AND_RETURN(ForOfStatement, stmt);

      }

    }

    return NULL;

  }

    VISIT_AND_RETURN(ModuleStatement, stmt)

  }

    VISIT_AND_RETURN(ExpressionStatement, stmt)

  }

    VISIT_AND_RETURN(ContinueStatement, stmt)

  }

    VISIT_AND_RETURN(BreakStatement, stmt)

  }

    VISIT_AND_RETURN(ReturnStatement, stmt)

  }

  WithStatement* NewWithStatement(Scope* scope,

                                  Expression* expression,

    WithStatement* stmt = new(zone_) WithStatement(

    VISIT_AND_RETURN(WithStatement, stmt)

  }

  IfStatement* NewIfStatement(Expression* condition,

                              Statement* then_statement,

    IfStatement* stmt = new(zone_) IfStatement(

    VISIT_AND_RETURN(IfStatement, stmt)

  }

                                          Block* try_block,

                                          Scope* scope,

                                          Variable* variable,

    TryCatchStatement* stmt = new(zone_) TryCatchStatement(

    VISIT_AND_RETURN(TryCatchStatement, stmt)

  }

  TryFinallyStatement* NewTryFinallyStatement(int index,

                                              Block* try_block,

    TryFinallyStatement* stmt =

    VISIT_AND_RETURN(TryFinallyStatement, stmt)

  }

    VISIT_AND_RETURN(DebuggerStatement, stmt)

  }

  }

    VISIT_AND_RETURN(Literal, lit)

  }

  }

  ObjectLiteral* NewObjectLiteral(

      bool fast_elements,

      int depth,

      bool may_store_doubles,

    ObjectLiteral* lit = new(zone_) ObjectLiteral(

        isolate_, constant_properties, properties, literal_index,

    VISIT_AND_RETURN(ObjectLiteral, lit)

  }

  ObjectLiteral::Property* NewObjectLiteralProperty(bool is_getter,

    ObjectLiteral::Property* prop =

        new(zone_) ObjectLiteral::Property(is_getter, value);

    return prop;  // Not an AST node, will not be visited.

  }

  RegExpLiteral* NewRegExpLiteral(Handle<String> pattern,

                                  Handle<String> flags,

    RegExpLiteral* lit =

    VISIT_AND_RETURN(RegExpLiteral, lit);

  }

                                ZoneList<Expression*>* values,

                                int literal_index,

                                bool is_simple,

    ArrayLiteral* lit = new(zone_) ArrayLiteral(

    VISIT_AND_RETURN(ArrayLiteral, lit)

  }

    VISIT_AND_RETURN(VariableProxy, proxy)

  }

  CallRuntime* NewCallRuntime(Handle<String> name,

                              const Runtime::Function* function,

    CallRuntime* call =

    VISIT_AND_RETURN(CallRuntime, call)

  }

  Conditional* NewConditional(Expression* condition,

                              Expression* then_expression,

                              Expression* else_expression,

    Conditional* cond = new(zone_) Conditional(

    VISIT_AND_RETURN(Conditional, cond)

  }

      FunctionLiteral::FunctionType function_type,

      FunctionLiteral::IsFunctionFlag is_function,

      FunctionLiteral::IsParenthesizedFlag is_parenthesized,

    FunctionLiteral* lit = new(zone_) FunctionLiteral(

        isolate_, name, scope, body,

        materialized_literal_count, expected_property_count, handler_count,

        parameter_count, function_type, has_duplicate_parameters, is_function,

    // Top-level literal doesn't count for the AST's properties.

    if (is_function == FunctionLiteral::kIsFunction) {

      visitor_.VisitFunctionLiteral(lit);

    return lit;

  }

  }

    VISIT_AND_RETURN(ThisFunction, fun)

  }