Collect AstNode type information

src/ast.h

-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
@@ skipping 101 matching lines @@
 // Please do appreciate the required space in "> >".
 typedef ZoneList<Handle<String> > ZoneStringList;
 typedef ZoneList<Handle<Object> > ZoneObjectList;
 
 
 #define DECLARE_NODE_TYPE(type)                                         \
   virtual void Accept(AstVisitor* v);                                   \
   virtual AstNode::Type node_type() const { return AstNode::k##type; }  \
 
 
+class AstNodeType {
+ public:
+  enum FlagIndex {
+    kIfStatement = 0,
+    kContinueStatement,
+    kBreakStatement,
+    kReturnStatement,
+    kWithStatement,
+    kSwitchStatement,
+    kDoWhileStatement,
+    kWhileStatement,
+    kForStatement,
+    kForInStatement,
+    kTryCatchStatement,
+    kTryFinallyStatement,
+    kDebuggerStatement,
+    kFunctionLiteral,
+    kSharedFunctionInfoLiteral,
+    kConditional,
+    kRegExpLiteral,
+    kObjectLiteral,
+    kArrayLiteral,
+    kThrow,
+    kProperty,
+    kCall,
+    kCallNew,
+    kCallRuntime,
+    kThisFunction
+  };
+
+  typedef int Flag;

[Sven Panne, 2012/01/17 13:46:58]

Drive-by comment: One could use EnumSet<FlagIndex> instead of plain old int here
and kill all the masks. "FlagIndex" might need some better name then, too...

+
+  static const Flag kIfStatementMask = (1 << kIfStatement);
+  static const Flag kContinueStatementMask = (1 << kContinueStatement);
+  static const Flag kBreakStatementMask = (1 << kBreakStatement);
+  static const Flag kReturnStatementMask = (1 << kReturnStatement);
+  static const Flag kWithStatementMask = (1 << kWithStatement);
+  static const Flag kSwitchStatementMask = (1 << kSwitchStatement);
+  static const Flag kDoWhileStatementMask = (1 << kDoWhileStatement);
+  static const Flag kWhileStatementMask = (1 << kWhileStatement);
+  static const Flag kForStatementMask = (1 << kForStatement);
+  static const Flag kForInStatementMask = (1 << kForInStatement);
+  static const Flag kTryCatchStatementMask = (1 << kTryCatchStatement);
+  static const Flag kTryFinallyStatementMask = (1 << kTryFinallyStatement);
+  static const Flag kDebuggerStatementMask = (1 << kDebuggerStatement);
+  static const Flag kFunctionLiteralMask = (1 << kFunctionLiteral);
+  static const Flag kSharedFunctionInfoLiteralMask =
+      (1 << kSharedFunctionInfoLiteral);
+  static const Flag kConditionalMask = (1 << kConditional);
+  static const Flag kRegExpLiteralMask = (1 << kRegExpLiteral);
+  static const Flag kObjectLiteralMask = (1 << kObjectLiteral);
+  static const Flag kArrayLiteralMask = (1 << kArrayLiteral);
+  static const Flag kThrowMask = (1 << kThrow);
+  static const Flag kPropertyMask = (1 << kProperty);
+  static const Flag kCallMask = (1 << kCall);
+  static const Flag kCallNewMask = (1 << kCallNew);
+  static const Flag kCallRuntimeMask = (1 << kCallRuntime);
+  static const Flag kThisFunctionMask = (1 << kThisFunction);
+
+  static const Flag kContainsBackEdgesMask =
+      kDoWhileStatementMask |
+      kWhileStatementMask |
+      kForStatementMask |
+      kForInStatementMask;
+
+  static const Flag kContainsCallsMask =
+      kCallMask | kCallNewMask | kCallRuntimeMask;
+
+  static const Flag kPreventsOptimizationMask =
+      kWithStatementMask |
+      kForInStatementMask |
+      kTryCatchStatementMask |
+      kTryFinallyStatementMask |
+      kDebuggerStatementMask |
+      kSharedFunctionInfoLiteral;
+};
+
 class AstNode: public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum Type {
     AST_NODE_LIST(DECLARE_TYPE_ENUM)
     kInvalid = -1
   };
 #undef DECLARE_TYPE_ENUM
 
   static const int kNoNumber = -1;
@@ skipping 27 matching lines @@
   virtual Statement* AsStatement() { return NULL; }
   virtual Expression* AsExpression() { return NULL; }
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
 
   // True if the node is simple enough for us to inline calls containing it.
   virtual bool IsInlineable() const = 0;
 
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+    *node_count += 1;
+  }
+
   static int Count() { return Isolate::Current()->ast_node_count(); }
   static void ResetIds() { Isolate::Current()->set_ast_node_id(0); }
 
  protected:
   static unsigned GetNextId(Isolate* isolate) {
     return ReserveIdRange(isolate, 1);
   }
 
   static unsigned ReserveIdRange(Isolate* isolate, int n) {
     unsigned tmp = isolate->ast_node_id();
@@ skipping 182 matching lines @@
       : BreakableStatement(isolate, labels, TARGET_FOR_NAMED_ONLY),
         statements_(capacity),
         is_initializer_block_(is_initializer_block),
         block_scope_(NULL) {
   }
 
 
   DECLARE_NODE_TYPE(Block)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   void AddStatement(Statement* statement) { statements_.Add(statement); }
 
   ZoneList<Statement*>* statements() { return &statements_; }
   bool is_initializer_block() const { return is_initializer_block_; }
 
   Scope* block_scope() const { return block_scope_; }
   void set_block_scope(Scope* block_scope) { block_scope_ = block_scope; }
 
  private:
@@ skipping 20 matching lines @@
     // At the moment there are no "const functions"'s in JavaScript...
     ASSERT(fun == NULL || mode == VAR || mode == LET);
   }
 
   DECLARE_NODE_TYPE(Declaration)
 
   VariableProxy* proxy() const { return proxy_; }
   VariableMode mode() const { return mode_; }
   FunctionLiteral* fun() const { return fun_; }  // may be NULL
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
   Scope* scope() const { return scope_; }
 
  private:
   VariableProxy* proxy_;
   VariableMode mode_;
   FunctionLiteral* fun_;
 
   // Nested scope from which the declaration originated.
   Scope* scope_;
 };
@@ skipping 55 matching lines @@
   // the loop's condition a breakable location.
   int condition_position() { return condition_position_; }
   void set_condition_position(int pos) { condition_position_ = pos; }
 
   // Bailout support.
   virtual int ContinueId() const { return continue_id_; }
   virtual int StackCheckId() const { return back_edge_id_; }
   int BackEdgeId() const { return back_edge_id_; }
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Expression* cond_;
   int condition_position_;
   int continue_id_;
   int back_edge_id_;
 };
 
 
 class WhileStatement: public IterationStatement {
@@ skipping 13 matching lines @@
   }
 
   Expression* cond() const { return cond_; }
   bool may_have_function_literal() const {
     return may_have_function_literal_;
   }
   void set_may_have_function_literal(bool value) {
     may_have_function_literal_ = value;
   }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   // Bailout support.
   virtual int ContinueId() const { return EntryId(); }
   virtual int StackCheckId() const { return body_id_; }
   int BodyId() const { return body_id_; }
 
  private:
   Expression* cond_;
   // True if there is a function literal subexpression in the condition.
   bool may_have_function_literal_;
@@ skipping 39 matching lines @@
 
   // Bailout support.
   virtual int ContinueId() const { return continue_id_; }
   virtual int StackCheckId() const { return body_id_; }
   int BodyId() const { return body_id_; }
 
   bool is_fast_smi_loop() { return loop_variable_ != NULL; }
   Variable* loop_variable() { return loop_variable_; }
   void set_loop_variable(Variable* var) { loop_variable_ = var; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Statement* init_;
   Expression* cond_;
   Statement* next_;
   // True if there is a function literal subexpression in the condition.
   bool may_have_function_literal_;
   Variable* loop_variable_;
   int continue_id_;
   int body_id_;
@@ skipping 13 matching lines @@
 
   void Initialize(Expression* each, Expression* enumerable, Statement* body) {
     IterationStatement::Initialize(body);
     each_ = each;
     enumerable_ = enumerable;
   }
 
   Expression* each() const { return each_; }
   Expression* enumerable() const { return enumerable_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   // Bailout support.
   int AssignmentId() const { return assignment_id_; }
   virtual int ContinueId() const { return EntryId(); }
   virtual int StackCheckId() const { return EntryId(); }
 
  private:
   Expression* each_;
   Expression* enumerable_;
   int assignment_id_;
 };
 
 
 class ExpressionStatement: public Statement {
  public:
   explicit ExpressionStatement(Expression* expression)
       : expression_(expression) { }
 
   DECLARE_NODE_TYPE(ExpressionStatement)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   void set_expression(Expression* e) { expression_ = e; }
   Expression* expression() const { return expression_; }
 
  private:
   Expression* expression_;
 };
 
 
 class ContinueStatement: public Statement {
  public:
   explicit ContinueStatement(IterationStatement* target)
       : target_(target) { }
 
   DECLARE_NODE_TYPE(ContinueStatement)
 
   IterationStatement* target() const { return target_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   IterationStatement* target_;
 };
 
 
 class BreakStatement: public Statement {
  public:
   explicit BreakStatement(BreakableStatement* target)
       : target_(target) { }
 
   DECLARE_NODE_TYPE(BreakStatement)
 
   BreakableStatement* target() const { return target_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   BreakableStatement* target_;
 };
 
 
 class ReturnStatement: public Statement {
  public:
   explicit ReturnStatement(Expression* expression)
       : expression_(expression) { }
 
   DECLARE_NODE_TYPE(ReturnStatement)
 
   Expression* expression() const { return expression_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Expression* expression_;
 };
 
 
 class WithStatement: public Statement {
  public:
   WithStatement(Expression* expression, Statement* statement)
       : expression_(expression), statement_(statement) { }
 
   DECLARE_NODE_TYPE(WithStatement)
 
   Expression* expression() const { return expression_; }
   Statement* statement() const { return statement_; }
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Expression* expression_;
   Statement* statement_;
 };
 
 
 class CaseClause: public ZoneObject {
  public:
   CaseClause(Isolate* isolate,
@@ skipping 52 matching lines @@
   DECLARE_NODE_TYPE(SwitchStatement)
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
   }
 
   Expression* tag() const { return tag_; }
   ZoneList<CaseClause*>* cases() const { return cases_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Expression* tag_;
   ZoneList<CaseClause*>* cases_;
 };
 
 
 // If-statements always have non-null references to their then- and
 // else-parts. When parsing if-statements with no explicit else-part,
 // the parser implicitly creates an empty statement. Use the
 // HasThenStatement() and HasElseStatement() functions to check if a
 // given if-statement has a then- or an else-part containing code.
 class IfStatement: public Statement {
  public:
   IfStatement(Isolate* isolate,
               Expression* condition,
               Statement* then_statement,
               Statement* else_statement)
       : condition_(condition),
         then_statement_(then_statement),
         else_statement_(else_statement),
         if_id_(GetNextId(isolate)),
         then_id_(GetNextId(isolate)),
         else_id_(GetNextId(isolate)) {
   }
 
   DECLARE_NODE_TYPE(IfStatement)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   bool HasThenStatement() const { return !then_statement()->IsEmpty(); }
   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_; }
 
   int IfId() const { return if_id_; }
   int ThenId() const { return then_id_; }
@@ skipping 69 matching lines @@
         scope_(scope),
         variable_(variable),
         catch_block_(catch_block) {
   }
 
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
-  virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
 class TryFinallyStatement: public TryStatement {
  public:
   TryFinallyStatement(int index, Block* try_block, Block* finally_block)
       : TryStatement(index, try_block),
         finally_block_(finally_block) { }
 
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
   Block* finally_block() const { return finally_block_; }
-  virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Block* finally_block_;
 };
 
 
 class DebuggerStatement: public Statement {
  public:
   DECLARE_NODE_TYPE(DebuggerStatement)
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 };
 
 
 class EmptyStatement: public Statement {
  public:
   DECLARE_NODE_TYPE(EmptyStatement)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 };
 
 
 class Literal: public Expression {
  public:
   Literal(Isolate* isolate, Handle<Object> handle)
       : Expression(isolate), handle_(handle) { }
 
   DECLARE_NODE_TYPE(Literal)
 
@@ skipping 135 matching lines @@
   // is shadowed by a later occurrence of the same key. For the
   // marked expressions, no store code is emitted.
   void CalculateEmitStore();
 
   enum Flags {
     kNoFlags = 0,
     kFastElements = 1,
     kHasFunction = 1 << 1
   };
 
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
+
  private:
   Handle<FixedArray> constant_properties_;
   ZoneList<Property*>* properties_;
   bool fast_elements_;
   bool has_function_;
 };
 
 
 // Node for capturing a regexp literal.
 class RegExpLiteral: public MaterializedLiteral {
  public:
   RegExpLiteral(Isolate* isolate,
                 Handle<String> pattern,
                 Handle<String> flags,
                 int literal_index)
       : MaterializedLiteral(isolate, literal_index, false, 1),
         pattern_(pattern),
         flags_(flags) {}
 
   DECLARE_NODE_TYPE(RegExpLiteral)
 
   Handle<String> pattern() const { return pattern_; }
   Handle<String> flags() const { return flags_; }
 
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
+
  private:
   Handle<String> pattern_;
   Handle<String> flags_;
 };
 
 // An array literal has a literals object that is used
 // for minimizing the work when constructing it at runtime.
 class ArrayLiteral: public MaterializedLiteral {
  public:
   ArrayLiteral(Isolate* isolate,
                Handle<FixedArray> constant_elements,
                ZoneList<Expression*>* values,
                int literal_index,
                bool is_simple,
                int depth)
       : MaterializedLiteral(isolate, literal_index, is_simple, depth),
         constant_elements_(constant_elements),
         values_(values),
         first_element_id_(ReserveIdRange(isolate, values->length())) {}
 
   DECLARE_NODE_TYPE(ArrayLiteral)
 
   Handle<FixedArray> constant_elements() const { return constant_elements_; }
   ZoneList<Expression*>* values() const { return values_; }
 
   // Return an AST id for an element that is used in simulate instructions.
   int GetIdForElement(int i) { return first_element_id_ + i; }
 
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
+
  private:
   Handle<FixedArray> constant_elements_;
   ZoneList<Expression*>* values_;
   int first_element_id_;
 };
 
 
 class VariableProxy: public Expression {
  public:
   VariableProxy(Isolate* isolate, Variable* var);
@@ skipping 57 matching lines @@
         is_monomorphic_(false),
         is_array_length_(false),
         is_string_length_(false),
         is_string_access_(false),
         is_function_prototype_(false) { }
 
   DECLARE_NODE_TYPE(Property)
 
   virtual bool IsValidLeftHandSide() { return true; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
   virtual int position() const { return pos_; }
 
   bool IsStringLength() const { return is_string_length_; }
   bool IsStringAccess() const { return is_string_access_; }
   bool IsFunctionPrototype() const { return is_function_prototype_; }
 
   // Type feedback information.
@@ skipping 27 matching lines @@
         arguments_(arguments),
         pos_(pos),
         is_monomorphic_(false),
         check_type_(RECEIVER_MAP_CHECK),
         return_id_(GetNextId(isolate)) {
   }
 
   DECLARE_NODE_TYPE(Call)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   virtual int position() const { return pos_; }
 
   void RecordTypeFeedback(TypeFeedbackOracle* oracle,
                           CallKind call_kind);
   virtual SmallMapList* GetReceiverTypes() { return &receiver_types_; }
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   CheckType check_type() const { return check_type_; }
@@ skipping 35 matching lines @@
           ZoneList<Expression*>* arguments,
           int pos)
       : Expression(isolate),
         expression_(expression),
         arguments_(arguments),
         pos_(pos) { }
 
   DECLARE_NODE_TYPE(CallNew)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   virtual int position() const { return pos_; }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 };
@@ skipping 10 matching lines @@
               const Runtime::Function* function,
               ZoneList<Expression*>* arguments)
       : Expression(isolate),
         name_(name),
         function_(function),
         arguments_(arguments) { }
 
   DECLARE_NODE_TYPE(CallRuntime)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Handle<String> name() const { return name_; }
   const Runtime::Function* function() const { return function_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   bool is_jsruntime() const { return function_ == NULL; }
 
  private:
   Handle<String> name_;
   const Runtime::Function* function_;
   ZoneList<Expression*>* arguments_;
@@ skipping 15 matching lines @@
     ASSERT(Token::IsUnaryOp(op));
     if (op == Token::NOT) {
       materialize_true_id_ = GetNextId(isolate);
       materialize_false_id_ = GetNextId(isolate);
     }
   }
 
   DECLARE_NODE_TYPE(UnaryOperation)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   virtual bool ResultOverwriteAllowed();
 
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
   virtual int position() const { return pos_; }
 
   int MaterializeTrueId() { return materialize_true_id_; }
   int MaterializeFalseId() { return materialize_false_id_; }
 
@@ skipping 19 matching lines @@
       : Expression(isolate), op_(op), left_(left), right_(right), pos_(pos) {
     ASSERT(Token::IsBinaryOp(op));
     right_id_ = (op == Token::AND || op == Token::OR)
         ? static_cast<int>(GetNextId(isolate))
         : AstNode::kNoNumber;
   }
 
   DECLARE_NODE_TYPE(BinaryOperation)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   virtual bool ResultOverwriteAllowed();
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   virtual int position() const { return pos_; }
 
   // Bailout support.
   int RightId() const { return right_id_; }
@@ skipping 33 matching lines @@
   Token::Value binary_op() {
     return (op() == Token::INC) ? Token::ADD : Token::SUB;
   }
 
   Expression* expression() const { return expression_; }
   virtual int position() const { return pos_; }
 
   virtual void MarkAsStatement() { is_prefix_ = true; }
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   virtual SmallMapList* GetReceiverTypes() { return &receiver_types_; }
 
   // Bailout support.
   int AssignmentId() const { return assignment_id_; }
   int CountId() const { return count_id_; }
 
  private:
@@ skipping 25 matching lines @@
   }
 
   DECLARE_NODE_TYPE(CompareOperation)
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   virtual int position() const { return pos_; }
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   bool IsSmiCompare() { return compare_type_ == SMI_ONLY; }
   bool IsObjectCompare() { return compare_type_ == OBJECT_ONLY; }
 
   // Match special cases.
   bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
   bool IsLiteralCompareUndefined(Expression** expr);
   bool IsLiteralCompareNull(Expression** expr);
@@ skipping 23 matching lines @@
         else_expression_(else_expression),
         then_expression_position_(then_expression_position),
         else_expression_position_(else_expression_position),
         then_id_(GetNextId(isolate)),
         else_id_(GetNextId(isolate)) {
   }
 
   DECLARE_NODE_TYPE(Conditional)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
 
   int then_expression_position() const { return then_expression_position_; }
   int else_expression_position() const { return else_expression_position_; }
 
   int ThenId() const { return then_id_; }
   int ElseId() const { return else_id_; }
@@ skipping 13 matching lines @@
  public:
   Assignment(Isolate* isolate,
              Token::Value op,
              Expression* target,
              Expression* value,
              int pos);
 
   DECLARE_NODE_TYPE(Assignment)
 
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return op_; }
   Expression* target() const { return target_; }
   Expression* value() const { return value_; }
   virtual int position() const { return pos_; }
   BinaryOperation* binary_operation() const { return binary_operation_; }
@@ skipping 39 matching lines @@
 class Throw: public Expression {
  public:
   Throw(Isolate* isolate, Expression* exception, int pos)
       : Expression(isolate), exception_(exception), pos_(pos) {}
 
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
   virtual int position() const { return pos_; }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Expression* exception_;
   int pos_;
 };
 
 
 class FunctionLiteral: public Expression {
  public:
   enum Type {
@@ skipping 67 matching lines @@
   }
 
   Handle<String> inferred_name() const { return inferred_name_; }
   void set_inferred_name(Handle<String> inferred_name) {
     inferred_name_ = inferred_name;
   }
 
   bool pretenure() { return Pretenure::decode(bitfield_); }
   void set_pretenure() { bitfield_ |= Pretenure::encode(true); }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
   bool has_duplicate_parameters() {
     return HasDuplicateParameters::decode(bitfield_);
   }
 
+  bool ShouldSelfOptimize();
+  int AstNodeCount();
+
  private:
   Handle<String> name_;
   Scope* scope_;
   ZoneList<Statement*>* body_;
   Handle<FixedArray> this_property_assignments_;
   Handle<String> inferred_name_;
 
   int materialized_literal_count_;
   int expected_property_count_;
   int handler_count_;
@@ skipping 15 matching lines @@
       Isolate* isolate,
       Handle<SharedFunctionInfo> shared_function_info)
       : Expression(isolate), shared_function_info_(shared_function_info) { }
 
   DECLARE_NODE_TYPE(SharedFunctionInfoLiteral)
 
   Handle<SharedFunctionInfo> shared_function_info() const {
     return shared_function_info_;
   }
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 
  private:
   Handle<SharedFunctionInfo> shared_function_info_;
 };
 
 
 class ThisFunction: public Expression {
  public:
   explicit ThisFunction(Isolate* isolate) : Expression(isolate) {}
   DECLARE_NODE_TYPE(ThisFunction)
   virtual bool IsInlineable() const;
+  virtual void CollectInfo(AstNodeType::Flag* flags, int* node_count) const;
 };
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
 class RegExpVisitor BASE_EMBEDDED {
  public:
   virtual ~RegExpVisitor() { }
@@ skipping 386 matching lines @@
 
  private:
   Isolate* isolate_;
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_