src/parser.cc - Issue 9221011: Collect AstNode type information

Unified Diff: src/parser.cc

Issue 9221011: Collect AstNode type information (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: refactor to AstVisitor approach Created 8 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/parser.cc

diff --git a/src/parser.cc b/src/parser.cc

index 5be1a6dc2b98ae4874b9a762c8ca2ac8a98272aa..5eebcaa7e172f1a07023081e3fa8effc2266e17c 100644

--- a/src/parser.cc

+++ b/src/parser.cc

@@ -481,62 +481,6 @@ class Parser::BlockState BASE_EMBEDDED {

};

-class Parser::FunctionState BASE_EMBEDDED {

- public:

- FunctionState(Parser* parser, Scope* scope, Isolate* isolate);

- ~FunctionState();

- int NextMaterializedLiteralIndex() {

- return next_materialized_literal_index_++;

- }

- int materialized_literal_count() {

- return next_materialized_literal_index_ - JSFunction::kLiteralsPrefixSize;

- }

- int NextHandlerIndex() { return next_handler_index_++; }

- int handler_count() { return next_handler_index_; }

- void SetThisPropertyAssignmentInfo(

- bool only_simple_this_property_assignments,

- Handle<FixedArray> this_property_assignments) {

- only_simple_this_property_assignments_ =

- only_simple_this_property_assignments;

- this_property_assignments_ = this_property_assignments;

- }

- bool only_simple_this_property_assignments() {

- return only_simple_this_property_assignments_;

- }

- Handle<FixedArray> this_property_assignments() {

- return this_property_assignments_;

- }

- void AddProperty() { expected_property_count_++; }

- int expected_property_count() { return expected_property_count_; }

- private:

- // Used to assign an index to each literal that needs materialization in

- // the function. Includes regexp literals, and boilerplate for object and

- // array literals.

- int next_materialized_literal_index_;

- // Used to assign a per-function index to try and catch handlers.

- int next_handler_index_;

- // Properties count estimation.

- int expected_property_count_;

- // Keeps track of assignments to properties of this. Used for

- // optimizing constructors.

- bool only_simple_this_property_assignments_;

- Handle<FixedArray> this_property_assignments_;

- Parser* parser_;

- FunctionState* outer_function_state_;

- Scope* outer_scope_;

- unsigned saved_ast_node_id_;

-};

Parser::FunctionState::FunctionState(Parser* parser,

Scope* scope,

Isolate* isolate)

@@ -596,6 +540,7 @@ Parser::Parser(Handle<Script> script,

reusable_preparser_(NULL),

top_scope_(NULL),

current_function_state_(NULL),

+ ast_node_factory_(NULL),

target_stack_(NULL),

extension_(extension),

pre_data_(pre_data),

@@ -608,6 +553,7 @@ Parser::Parser(Handle<Script> script,

if ((parser_flags & kLanguageModeMask) == EXTENDED_MODE) {

scanner().SetHarmonyScoping(true);

}

+ ast_node_factory_ = new AstNodeFactory(isolate_);

}

@@ -660,6 +606,9 @@ FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,

scope->set_start_position(0);

scope->set_end_position(source->length());

FunctionState function_state(this, scope, isolate());

+ AstProperties* ast_properties = new(zone()) AstProperties();

+ info->ast_construction_visitor()->set_ast_properties(ast_properties);

+ factory()->set_visitor(info->ast_construction_visitor());

top_scope_->SetLanguageMode(info->language_mode());

ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16);

bool ok = true;

@@ -674,8 +623,7 @@ FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,

}

if (ok) {

- result = new(zone()) FunctionLiteral(

- isolate(),

+ result = factory()->NewFunctionLiteral(

no_name,

top_scope_,

body,

@@ -686,10 +634,13 @@ FunctionLiteral* Parser::DoParseProgram(CompilationInfo* info,

function_state.this_property_assignments(),

FunctionLiteral::ANONYMOUS_EXPRESSION,

- false); // Does not have duplicate parameters.

+ false, // Does not have duplicate parameters.

+ false); // Top-level literal doesn't count for the AST's properties.

+ result->set_ast_properties(ast_properties);

} else if (stack_overflow_) {

isolate()->StackOverflow();

}

+ factory()->set_visitor(NULL);

}

// Make sure the target stack is empty.

@@ -752,6 +703,7 @@ FunctionLiteral* Parser::ParseLazy(CompilationInfo* info,

scope = Scope::DeserializeScopeChain(info->closure()->context(), scope);

}

FunctionState function_state(this, scope, isolate());

+ factory()->set_visitor(info->ast_construction_visitor());

ASSERT(scope->language_mode() != STRICT_MODE || !info->is_classic_mode());

ASSERT(scope->language_mode() != EXTENDED_MODE ||

info->is_extended_mode());

@@ -1274,7 +1226,7 @@ Statement* Parser::ParseStatement(ZoneStringList* labels, bool* ok) {

case Token::SEMICOLON:

Next();

- return EmptyStatement();

+ return factory()->NewEmptyStatement();

case Token::IF:

stmt = ParseIfStatement(labels, ok);

@@ -1322,7 +1274,7 @@ Statement* Parser::ParseStatement(ZoneStringList* labels, bool* ok) {

// one must take great care not to treat it as a

// fall-through. It is much easier just to wrap the entire

// try-statement in a statement block and put the labels there

- Block* result = new(zone()) Block(isolate(), labels, 1, false);

+ Block* result = factory()->NewBlock(labels, 1, false);

Target target(&this->target_stack_, result);

TryStatement* statement = ParseTryStatement(CHECK_OK);

if (statement) {

@@ -1454,9 +1406,9 @@ VariableProxy* Parser::Declare(Handle<String> name,

// a performance issue since it may lead to repeated

// Runtime::DeclareContextSlot() calls.

VariableProxy* proxy = declaration_scope->NewUnresolved(

- name, scanner().location().beg_pos);

+ factory(), name, scanner().location().beg_pos);

declaration_scope->AddDeclaration(

- new(zone()) Declaration(proxy, mode, fun, top_scope_));

+ factory()->NewDeclaration(proxy, mode, fun, top_scope_));

if ((mode == CONST || mode == CONST_HARMONY) &&

declaration_scope->is_global_scope()) {

@@ -1564,10 +1516,11 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) {

// introduced dynamically when we meet their declarations, whereas

// other functions are set up when entering the surrounding scope.

SharedFunctionInfoLiteral* lit =

- new(zone()) SharedFunctionInfoLiteral(isolate(), shared);

+ factory()->NewSharedFunctionInfoLiteral(shared);

VariableProxy* var = Declare(name, VAR, NULL, true, CHECK_OK);

- return new(zone()) ExpressionStatement(new(zone()) Assignment(

- isolate(), Token::INIT_VAR, var, lit, RelocInfo::kNoPosition));

+ return factory()->NewExpressionStatement(

+ factory()->NewAssignment(

+ Token::INIT_VAR, var, lit, RelocInfo::kNoPosition));

}

@@ -1589,7 +1542,7 @@ Statement* Parser::ParseFunctionDeclaration(bool* ok) {

// initial value upon entering the corresponding scope.

VariableMode mode = is_extended_mode() ? LET : VAR;

Declare(name, mode, fun, true, CHECK_OK);

- return EmptyStatement();

+ return factory()->NewEmptyStatement();

}

@@ -1603,7 +1556,7 @@ Block* Parser::ParseBlock(ZoneStringList* labels, bool* ok) {

// (ECMA-262, 3rd, 12.2)

// Construct block expecting 16 statements.

- Block* result = new(zone()) Block(isolate(), labels, 16, false);

+ Block* result = factory()->NewBlock(labels, 16, false);

Target target(&this->target_stack_, result);

Expect(Token::LBRACE, CHECK_OK);

InitializationBlockFinder block_finder(top_scope_, target_stack_);

@@ -1626,7 +1579,7 @@ Block* Parser::ParseScopedBlock(ZoneStringList* labels, bool* ok) {

// '{' SourceElement* '}'

// Construct block expecting 16 statements.

- Block* body = new(zone()) Block(isolate(), labels, 16, false);

+ Block* body = factory()->NewBlock(labels, 16, false);

Scope* block_scope = NewScope(top_scope_, BLOCK_SCOPE);

// Parse the statements and collect escaping labels.

@@ -1786,7 +1739,7 @@ Block* Parser::ParseVariableDeclarations(

// is inside an initializer block, it is ignored.

// Create new block with one expected declaration.

- Block* block = new(zone()) Block(isolate(), NULL, 1, true);

+ Block* block = factory()->NewBlock(NULL, 1, true);

int nvars = 0; // the number of variables declared

Handle<String> name;

do {

@@ -1907,7 +1860,7 @@ Block* Parser::ParseVariableDeclarations(

// Compute the arguments for the runtime call.

ZoneList<Expression*>* arguments = new(zone()) ZoneList<Expression*>(3);

// We have at least 1 parameter.

- arguments->Add(NewLiteral(name));

+ arguments->Add(factory()->NewLiteral(name));

CallRuntime* initialize;

if (is_const) {

@@ -1918,17 +1871,15 @@ Block* Parser::ParseVariableDeclarations(

// and add it to the initialization statement block.

// Note that the function does different things depending on

// the number of arguments (1 or 2).

- initialize =

- new(zone()) CallRuntime(

- isolate(),

- isolate()->factory()->InitializeConstGlobal_symbol(),

- Runtime::FunctionForId(Runtime::kInitializeConstGlobal),

- arguments);

+ initialize = factory()->NewCallRuntime(

+ isolate()->factory()->InitializeConstGlobal_symbol(),

+ Runtime::FunctionForId(Runtime::kInitializeConstGlobal),

+ arguments);

} else {

// Add strict mode.

// We may want to pass singleton to avoid Literal allocations.

LanguageMode language_mode = initialization_scope->language_mode();

- arguments->Add(NewNumberLiteral(language_mode));

+ arguments->Add(factory()->NewNumberLiteral(language_mode));

// Be careful not to assign a value to the global variable if

// we're in a with. The initialization value should not

@@ -1943,15 +1894,13 @@ Block* Parser::ParseVariableDeclarations(

// and add it to the initialization statement block.

// Note that the function does different things depending on

// the number of arguments (2 or 3).

- initialize =

- new(zone()) CallRuntime(

- isolate(),

- isolate()->factory()->InitializeVarGlobal_symbol(),

- Runtime::FunctionForId(Runtime::kInitializeVarGlobal),

- arguments);

+ initialize = factory()->NewCallRuntime(

+ isolate()->factory()->InitializeVarGlobal_symbol(),

+ Runtime::FunctionForId(Runtime::kInitializeVarGlobal),

+ arguments);

}

- block->AddStatement(new(zone()) ExpressionStatement(initialize));

+ block->AddStatement(factory()->NewExpressionStatement(initialize));

} else if (needs_init) {

// Constant initializations always assign to the declared constant which

// is always at the function scope level. This is only relevant for

@@ -1964,8 +1913,8 @@ Block* Parser::ParseVariableDeclarations(

ASSERT(proxy->var() != NULL);

ASSERT(value != NULL);

Assignment* assignment =

- new(zone()) Assignment(isolate(), init_op, proxy, value, position);

- block->AddStatement(new(zone()) ExpressionStatement(assignment));

+ factory()->NewAssignment(init_op, proxy, value, position);

+ block->AddStatement(factory()->NewExpressionStatement(assignment));

value = NULL;

}

@@ -1976,10 +1925,11 @@ Block* Parser::ParseVariableDeclarations(

// 'var' initializations are simply assignments (with all the consequences

// if they are inside a 'with' statement - they may change a 'with' object

// property).

- VariableProxy* proxy = initialization_scope->NewUnresolved(name);

+ VariableProxy* proxy =

+ initialization_scope->NewUnresolved(factory(), name);

Assignment* assignment =

- new(zone()) Assignment(isolate(), init_op, proxy, value, position);

- block->AddStatement(new(zone()) ExpressionStatement(assignment));

+ factory()->NewAssignment(init_op, proxy, value, position);

+ block->AddStatement(factory()->NewExpressionStatement(assignment));

}

if (fni_ != NULL) fni_->Leave();

@@ -2059,7 +2009,7 @@ Statement* Parser::ParseExpressionOrLabelledStatement(ZoneStringList* labels,

// Parsed expression statement.

ExpectSemicolon(CHECK_OK);

- return new(zone()) ExpressionStatement(expr);

+ return factory()->NewExpressionStatement(expr);

}

@@ -2077,10 +2027,9 @@ IfStatement* Parser::ParseIfStatement(ZoneStringList* labels, bool* ok) {

Next();

else_statement = ParseStatement(labels, CHECK_OK);

} else {

- else_statement = EmptyStatement();

+ else_statement = factory()->NewEmptyStatement();

}

- return new(zone()) IfStatement(

- isolate(), condition, then_statement, else_statement);

+ return factory()->NewIfStatement(condition, then_statement, else_statement);

}

@@ -2110,7 +2059,7 @@ Statement* Parser::ParseContinueStatement(bool* ok) {

return NULL;

}

ExpectSemicolon(CHECK_OK);

- return new(zone()) ContinueStatement(target);

+ return factory()->NewContinueStatement(target);

}

@@ -2128,7 +2077,7 @@ Statement* Parser::ParseBreakStatement(ZoneStringList* labels, bool* ok) {

// Parse labeled break statements that target themselves into

// empty statements, e.g. 'l1: l2: l3: break l2;'

if (!label.is_null() && ContainsLabel(labels, label)) {

- return EmptyStatement();

+ return factory()->NewEmptyStatement();

}

BreakableStatement* target = NULL;

target = LookupBreakTarget(label, CHECK_OK);

@@ -2145,7 +2094,7 @@ Statement* Parser::ParseBreakStatement(ZoneStringList* labels, bool* ok) {

return NULL;

}

ExpectSemicolon(CHECK_OK);

- return new(zone()) BreakStatement(target);

+ return factory()->NewBreakStatement(target);

}

@@ -2165,11 +2114,11 @@ Statement* Parser::ParseReturnStatement(bool* ok) {

tok == Token::RBRACE ||

tok == Token::EOS) {

ExpectSemicolon(CHECK_OK);

- result = new(zone()) ReturnStatement(GetLiteralUndefined());

+ result = factory()->NewReturnStatement(GetLiteralUndefined());

} else {

Expression* expr = ParseExpression(true, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- result = new(zone()) ReturnStatement(expr);

+ result = factory()->NewReturnStatement(expr);

}

// An ECMAScript program is considered syntactically incorrect if it

@@ -2182,7 +2131,7 @@ Statement* Parser::ParseReturnStatement(bool* ok) {

declaration_scope->is_eval_scope()) {

Handle<String> type = isolate()->factory()->illegal_return_symbol();

Expression* throw_error = NewThrowSyntaxError(type, Handle<Object>::null());

- return new(zone()) ExpressionStatement(throw_error);

+ return factory()->NewExpressionStatement(throw_error);

}

return result;

}

@@ -2212,7 +2161,7 @@ Statement* Parser::ParseWithStatement(ZoneStringList* labels, bool* ok) {

stmt = ParseStatement(labels, CHECK_OK);

with_scope->set_end_position(scanner().location().end_pos);

}

- return new(zone()) WithStatement(expr, stmt);

+ return factory()->NewWithStatement(expr, stmt);

}

@@ -2254,7 +2203,7 @@ SwitchStatement* Parser::ParseSwitchStatement(ZoneStringList* labels,

// SwitchStatement ::

// 'switch' '(' Expression ')' '{' CaseClause* '}'

- SwitchStatement* statement = new(zone()) SwitchStatement(isolate(), labels);

+ SwitchStatement* statement = factory()->NewSwitchStatement(labels);

Target target(&this->target_stack_, statement);

Expect(Token::SWITCH, CHECK_OK);

@@ -2290,8 +2239,7 @@ Statement* Parser::ParseThrowStatement(bool* ok) {

Expression* exception = ParseExpression(true, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- return new(zone()) ExpressionStatement(

- new(zone()) Throw(isolate(), exception, pos));

+ return factory()->NewExpressionStatement(factory()->NewThrow(exception, pos));

}

@@ -2378,13 +2326,10 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

// If we have both, create an inner try/catch.

ASSERT(catch_scope != NULL && catch_variable != NULL);

int index = current_function_state_->NextHandlerIndex();

- TryCatchStatement* statement = new(zone()) TryCatchStatement(index,

- try_block,

- catch_scope,

- catch_variable,

- catch_block);

+ TryCatchStatement* statement = factory()->NewTryCatchStatement(

+ index, try_block, catch_scope, catch_variable, catch_block);

statement->set_escaping_targets(try_collector.targets());

- try_block = new(zone()) Block(isolate(), NULL, 1, false);

+ try_block = factory()->NewBlock(NULL, 1, false);

try_block->AddStatement(statement);

catch_block = NULL; // Clear to indicate it's been handled.

}

@@ -2394,17 +2339,12 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {

ASSERT(finally_block == NULL);

ASSERT(catch_scope != NULL && catch_variable != NULL);

int index = current_function_state_->NextHandlerIndex();

- result = new(zone()) TryCatchStatement(index,

- try_block,

- catch_scope,

- catch_variable,

- catch_block);

+ result = factory()->NewTryCatchStatement(

+ index, try_block, catch_scope, catch_variable, catch_block);

} else {

ASSERT(finally_block != NULL);

int index = current_function_state_->NextHandlerIndex();

- result = new(zone()) TryFinallyStatement(index,

- try_block,

- finally_block);

+ result = factory()->NewTryFinallyStatement(index, try_block, finally_block);

// Combine the jump targets of the try block and the possible catch block.

try_collector.targets()->AddAll(*catch_collector.targets());

}

@@ -2419,7 +2359,7 @@ DoWhileStatement* Parser::ParseDoWhileStatement(ZoneStringList* labels,

// DoStatement ::

// 'do' Statement 'while' '(' Expression ')' ';'

- DoWhileStatement* loop = new(zone()) DoWhileStatement(isolate(), labels);

+ DoWhileStatement* loop = factory()->NewDoWhileStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::DO, CHECK_OK);

@@ -2450,7 +2390,7 @@ WhileStatement* Parser::ParseWhileStatement(ZoneStringList* labels, bool* ok) {

// WhileStatement ::

// 'while' '(' Expression ')' Statement

- WhileStatement* loop = new(zone()) WhileStatement(isolate(), labels);

+ WhileStatement* loop = factory()->NewWhileStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::WHILE, CHECK_OK);

@@ -2485,8 +2425,8 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

ParseVariableDeclarations(kForStatement, NULL, &name, CHECK_OK);

if (peek() == Token::IN && !name.is_null()) {

- VariableProxy* each = top_scope_->NewUnresolved(name);

- ForInStatement* loop = new(zone()) ForInStatement(isolate(), labels);

+ VariableProxy* each = top_scope_->NewUnresolved(factory(), name);

+ ForInStatement* loop = factory()->NewForInStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::IN, CHECK_OK);

@@ -2495,7 +2435,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Statement* body = ParseStatement(NULL, CHECK_OK);

loop->Initialize(each, enumerable, body);

- Block* result = new(zone()) Block(isolate(), NULL, 2, false);

+ Block* result = factory()->NewBlock(NULL, 2, false);

result->AddStatement(variable_statement);

result->AddStatement(loop);

top_scope_ = saved_scope;

@@ -2533,9 +2473,9 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

// TODO(keuchel): Move the temporary variable to the block scope, after

// implementing stack allocated block scoped variables.

Variable* temp = top_scope_->DeclarationScope()->NewTemporary(name);

- VariableProxy* temp_proxy = new(zone()) VariableProxy(isolate(), temp);

- VariableProxy* each = top_scope_->NewUnresolved(name);

- ForInStatement* loop = new(zone()) ForInStatement(isolate(), labels);

+ VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);

+ VariableProxy* each = top_scope_->NewUnresolved(factory(), name);

+ ForInStatement* loop = factory()->NewForInStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::IN, CHECK_OK);

@@ -2543,14 +2483,11 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Expect(Token::RPAREN, CHECK_OK);

Statement* body = ParseStatement(NULL, CHECK_OK);

- Block* body_block = new(zone()) Block(isolate(), NULL, 3, false);

- Assignment* assignment = new(zone()) Assignment(isolate(),

- Token::ASSIGN,

- each,

- temp_proxy,

- RelocInfo::kNoPosition);

+ Block* body_block = factory()->NewBlock(NULL, 3, false);

+ Assignment* assignment = factory()->NewAssignment(

+ Token::ASSIGN, each, temp_proxy, RelocInfo::kNoPosition);

Statement* assignment_statement =

- new(zone()) ExpressionStatement(assignment);

+ factory()->NewExpressionStatement(assignment);

body_block->AddStatement(variable_statement);

body_block->AddStatement(assignment_statement);

body_block->AddStatement(body);

@@ -2577,7 +2514,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

isolate()->factory()->invalid_lhs_in_for_in_symbol();

expression = NewThrowReferenceError(type);

}

- ForInStatement* loop = new(zone()) ForInStatement(isolate(), labels);

+ ForInStatement* loop = factory()->NewForInStatement(labels);

Target target(&this->target_stack_, loop);

Expect(Token::IN, CHECK_OK);

@@ -2594,13 +2531,13 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

return loop;

} else {

- init = new(zone()) ExpressionStatement(expression);

+ init = factory()->NewExpressionStatement(expression);

}

// Standard 'for' loop

- ForStatement* loop = new(zone()) ForStatement(isolate(), labels);

+ ForStatement* loop = factory()->NewForStatement(labels);

Target target(&this->target_stack_, loop);

// Parsed initializer at this point.

@@ -2615,7 +2552,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

Statement* next = NULL;

if (peek() != Token::RPAREN) {

Expression* exp = ParseExpression(true, CHECK_OK);

- next = new(zone()) ExpressionStatement(exp);

+ next = factory()->NewExpressionStatement(exp);

}

Expect(Token::RPAREN, CHECK_OK);

@@ -2635,7 +2572,7 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) {

// for (; c; n) b

// }

ASSERT(init != NULL);

- Block* result = new(zone()) Block(isolate(), NULL, 2, false);

+ Block* result = factory()->NewBlock(NULL, 2, false);

result->AddStatement(init);

result->AddStatement(loop);

result->set_block_scope(for_scope);

@@ -2659,8 +2596,8 @@ Expression* Parser::ParseExpression(bool accept_IN, bool* ok) {

Expect(Token::COMMA, CHECK_OK);

int position = scanner().location().beg_pos;

Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

- result = new(zone()) BinaryOperation(

- isolate(), Token::COMMA, result, right, position);

+ result =

+ factory()->NewBinaryOperation(Token::COMMA, result, right, position);

}

return result;

}

@@ -2735,7 +2672,7 @@ Expression* Parser::ParseAssignmentExpression(bool accept_IN, bool* ok) {

fni_->Leave();

}

- return new(zone()) Assignment(isolate(), op, expression, right, pos);

+ return factory()->NewAssignment(op, expression, right, pos);

}

@@ -2757,8 +2694,8 @@ Expression* Parser::ParseConditionalExpression(bool accept_IN, bool* ok) {

Expect(Token::COLON, CHECK_OK);

int right_position = scanner().peek_location().beg_pos;

Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

- return new(zone()) Conditional(

- isolate(), expression, left, right, left_position, right_position);

+ return factory()->NewConditional(

+ expression, left, right, left_position, right_position);

}

@@ -2789,41 +2726,47 @@ Expression* Parser::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) {

switch (op) {

case Token::ADD:

- x = NewNumberLiteral(x_val + y_val);

+ x = factory()->NewNumberLiteral(x_val + y_val);

continue;

case Token::SUB:

- x = NewNumberLiteral(x_val - y_val);

+ x = factory()->NewNumberLiteral(x_val - y_val);

continue;

case Token::MUL:

- x = NewNumberLiteral(x_val * y_val);

+ x = factory()->NewNumberLiteral(x_val * y_val);

continue;

case Token::DIV:

- x = NewNumberLiteral(x_val / y_val);

+ x = factory()->NewNumberLiteral(x_val / y_val);

continue;

- case Token::BIT_OR:

- x = NewNumberLiteral(DoubleToInt32(x_val) | DoubleToInt32(y_val));

+ case Token::BIT_OR: {

+ int value = DoubleToInt32(x_val) | DoubleToInt32(y_val);

+ x = factory()->NewNumberLiteral(value);

continue;

- case Token::BIT_AND:

- x = NewNumberLiteral(DoubleToInt32(x_val) & DoubleToInt32(y_val));

+ }

+ case Token::BIT_AND: {

+ int value = DoubleToInt32(x_val) & DoubleToInt32(y_val);

+ x = factory()->NewNumberLiteral(value);

continue;

- case Token::BIT_XOR:

- x = NewNumberLiteral(DoubleToInt32(x_val) ^ DoubleToInt32(y_val));

+ }

+ case Token::BIT_XOR: {

+ int value = DoubleToInt32(x_val) ^ DoubleToInt32(y_val);

+ x = factory()->NewNumberLiteral(value);

continue;

+ }

case Token::SHL: {

int value = DoubleToInt32(x_val) << (DoubleToInt32(y_val) & 0x1f);

- x = NewNumberLiteral(value);

+ x = factory()->NewNumberLiteral(value);

continue;

}

case Token::SHR: {

uint32_t shift = DoubleToInt32(y_val) & 0x1f;

uint32_t value = DoubleToUint32(x_val) >> shift;

- x = NewNumberLiteral(value);

+ x = factory()->NewNumberLiteral(value);

continue;

}

case Token::SAR: {

uint32_t shift = DoubleToInt32(y_val) & 0x1f;

int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift);

- x = NewNumberLiteral(value);

+ x = factory()->NewNumberLiteral(value);

continue;

}

default:

@@ -2842,15 +2785,15 @@ Expression* Parser::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) {

case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;

default: break;

}

- x = new(zone()) CompareOperation(isolate(), cmp, x, y, position);

+ x = factory()->NewCompareOperation(cmp, x, y, position);

if (cmp != op) {

// The comparison was negated - add a NOT.

- x = new(zone()) UnaryOperation(isolate(), Token::NOT, x, position);

+ x = factory()->NewUnaryOperation(Token::NOT, x, position);

}

} else {

// We have a "normal" binary operation.

- x = new(zone()) BinaryOperation(isolate(), op, x, y, position);

+ x = factory()->NewBinaryOperation(op, x, y, position);

}

@@ -2883,7 +2826,7 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

// Convert the literal to a boolean condition and negate it.

bool condition = literal->ToBoolean()->IsTrue();

Handle<Object> result(isolate()->heap()->ToBoolean(!condition));

- return NewLiteral(result);

+ return factory()->NewLiteral(result);

} else if (literal->IsNumber()) {

// Compute some expressions involving only number literals.

double value = literal->Number();

@@ -2891,9 +2834,9 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

case Token::ADD:

return expression;

case Token::SUB:

- return NewNumberLiteral(-value);

+ return factory()->NewNumberLiteral(-value);

case Token::BIT_NOT:

- return NewNumberLiteral(~DoubleToInt32(value));

+ return factory()->NewNumberLiteral(~DoubleToInt32(value));

default:

break;

}

@@ -2910,7 +2853,7 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

}

- return new(zone()) UnaryOperation(isolate(), op, expression, position);

+ return factory()->NewUnaryOperation(op, expression, position);

} else if (Token::IsCountOp(op)) {

op = Next();

@@ -2932,11 +2875,10 @@ Expression* Parser::ParseUnaryExpression(bool* ok) {

MarkAsLValue(expression);

int position = scanner().location().beg_pos;

- return new(zone()) CountOperation(isolate(),

- op,

- true /* prefix */,

- expression,

- position);

+ return factory()->NewCountOperation(op,

+ true /* prefix */,

+ expression,

+ position);

} else {

return ParsePostfixExpression(ok);

@@ -2970,11 +2912,10 @@ Expression* Parser::ParsePostfixExpression(bool* ok) {

Token::Value next = Next();

int position = scanner().location().beg_pos;

expression =

- new(zone()) CountOperation(isolate(),

- next,

- false /* postfix */,

- expression,

- position);

+ factory()->NewCountOperation(next,

+ false /* postfix */,

+ expression,

+ position);

}

return expression;

}

@@ -2997,7 +2938,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) {

Consume(Token::LBRACK);

int pos = scanner().location().beg_pos;

Expression* index = ParseExpression(true, CHECK_OK);

- result = new(zone()) Property(isolate(), result, index, pos);

+ result = factory()->NewProperty(result, index, pos);

Expect(Token::RBRACK, CHECK_OK);

break;

}

@@ -3030,7 +2971,7 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) {

callee->IsVariable(isolate()->factory()->eval_symbol())) {

top_scope_->DeclarationScope()->RecordEvalCall();

}

- result = NewCall(result, args, pos);

+ result = factory()->NewCall(result, args, pos);

break;

}

@@ -3038,10 +2979,8 @@ Expression* Parser::ParseLeftHandSideExpression(bool* ok) {

Consume(Token::PERIOD);

int pos = scanner().location().beg_pos;

Handle<String> name = ParseIdentifierName(CHECK_OK);

- result = new(zone()) Property(isolate(),

- result,

- NewLiteral(name),

- pos);

+ result =

+ factory()->NewProperty(result, factory()->NewLiteral(name), pos);

if (fni_ != NULL) fni_->PushLiteralName(name);

break;

}

@@ -3077,10 +3016,8 @@ Expression* Parser::ParseNewPrefix(PositionStack* stack, bool* ok) {

if (!stack->is_empty()) {

int last = stack->pop();

- result = new(zone()) CallNew(isolate(),

- result,

- new(zone()) ZoneList<Expression*>(0),

- last);

+ result = factory()->NewCallNew(

+ result, new(zone()) ZoneList<Expression*>(0), last);

}

return result;

}

@@ -3132,7 +3069,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,

Consume(Token::LBRACK);

int pos = scanner().location().beg_pos;

Expression* index = ParseExpression(true, CHECK_OK);

- result = new(zone()) Property(isolate(), result, index, pos);

+ result = factory()->NewProperty(result, index, pos);

if (fni_ != NULL) {

if (index->IsPropertyName()) {

fni_->PushLiteralName(index->AsLiteral()->AsPropertyName());

@@ -3148,10 +3085,8 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,

Consume(Token::PERIOD);

int pos = scanner().location().beg_pos;

Handle<String> name = ParseIdentifierName(CHECK_OK);

- result = new(zone()) Property(isolate(),

- result,

- NewLiteral(name),

- pos);

+ result =

+ factory()->NewProperty(result, factory()->NewLiteral(name), pos);

if (fni_ != NULL) fni_->PushLiteralName(name);

break;

}

@@ -3160,7 +3095,7 @@ Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,

// Consume one of the new prefixes (already parsed).

ZoneList<Expression*>* args = ParseArguments(CHECK_OK);

int last = stack->pop();

- result = new(zone()) CallNew(isolate(), result, args, last);

+ result = factory()->NewCallNew(result, args, last);

break;

}

default:

@@ -3179,7 +3114,7 @@ DebuggerStatement* Parser::ParseDebuggerStatement(bool* ok) {

Expect(Token::DEBUGGER, CHECK_OK);

ExpectSemicolon(CHECK_OK);

- return new(zone()) DebuggerStatement();

+ return factory()->NewDebuggerStatement();

}

@@ -3244,33 +3179,31 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) {

switch (peek()) {

case Token::THIS: {

Consume(Token::THIS);

- result = new(zone()) VariableProxy(isolate(), top_scope_->receiver());

+ result = factory()->NewVariableProxy(top_scope_->receiver());

break;

}

case Token::NULL_LITERAL:

Consume(Token::NULL_LITERAL);

- result = new(zone()) Literal(

- isolate(), isolate()->factory()->null_value());

+ result = factory()->NewLiteral(isolate()->factory()->null_value());

break;

case Token::TRUE_LITERAL:

Consume(Token::TRUE_LITERAL);

- result = new(zone()) Literal(

- isolate(), isolate()->factory()->true_value());

+ result = factory()->NewLiteral(isolate()->factory()->true_value());

break;

case Token::FALSE_LITERAL:

Consume(Token::FALSE_LITERAL);

- result = new(zone()) Literal(

- isolate(), isolate()->factory()->false_value());

+ result = factory()->NewLiteral(isolate()->factory()->false_value());

break;

case Token::IDENTIFIER:

case Token::FUTURE_STRICT_RESERVED_WORD: {

Handle<String> name = ParseIdentifier(CHECK_OK);

if (fni_ != NULL) fni_->PushVariableName(name);

- result = top_scope_->NewUnresolved(name, scanner().location().beg_pos);

+ result = top_scope_->NewUnresolved(

+ factory(), name, scanner().location().beg_pos);

break;

}

@@ -3280,14 +3213,14 @@ Expression* Parser::ParsePrimaryExpression(bool* ok) {

double value = StringToDouble(isolate()->unicode_cache(),

scanner().literal_ascii_string(),

ALLOW_HEX | ALLOW_OCTALS);

- result = NewNumberLiteral(value);

+ result = factory()->NewNumberLiteral(value);

break;

}

case Token::STRING: {

Consume(Token::STRING);

Handle<String> symbol = GetSymbol(CHECK_OK);

- result = NewLiteral(symbol);

+ result = factory()->NewLiteral(symbol);

if (fni_ != NULL) fni_->PushLiteralName(symbol);

break;

}

@@ -3481,8 +3414,8 @@ Expression* Parser::ParseArrayLiteral(bool* ok) {

literals->set(0, Smi::FromInt(elements_kind));

literals->set(1, *element_values);

- return new(zone()) ArrayLiteral(

- isolate(), literals, values, literal_index, is_simple, depth);

+ return factory()->NewArrayLiteral(

+ literals, values, literal_index, is_simple, depth);

}

@@ -3760,7 +3693,7 @@ ObjectLiteral::Property* Parser::ParseObjectLiteralGetSet(bool is_getter,

// Allow any number of parameters for compatibilty with JSC.

// Specification only allows zero parameters for get and one for set.

ObjectLiteral::Property* property =

- new(zone()) ObjectLiteral::Property(is_getter, value);

+ new(zone()) ObjectLiteral::Property(is_getter, value, factory());

return property;

} else {

ReportUnexpectedToken(next);

@@ -3826,7 +3759,7 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

}

// Failed to parse as get/set property, so it's just a property

// called "get" or "set".

- key = NewLiteral(id);

+ key = factory()->NewLiteral(id);

break;

}

case Token::STRING: {

@@ -3835,10 +3768,10 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

if (fni_ != NULL) fni_->PushLiteralName(string);

uint32_t index;

if (!string.is_null() && string->AsArrayIndex(&index)) {

- key = NewNumberLiteral(index);

+ key = factory()->NewNumberLiteral(index);

break;

}

- key = NewLiteral(string);

+ key = factory()->NewLiteral(string);

break;

}

case Token::NUMBER: {

@@ -3847,14 +3780,14 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

double value = StringToDouble(isolate()->unicode_cache(),

scanner().literal_ascii_string(),

ALLOW_HEX | ALLOW_OCTALS);

- key = NewNumberLiteral(value);

+ key = factory()->NewNumberLiteral(value);

break;

}

default:

if (Token::IsKeyword(next)) {

Consume(next);

Handle<String> string = GetSymbol(CHECK_OK);

- key = NewLiteral(string);

+ key = factory()->NewLiteral(string);

} else {

// Unexpected token.

Token::Value next = Next();

@@ -3909,14 +3842,13 @@ Expression* Parser::ParseObjectLiteral(bool* ok) {

&is_simple,

&fast_elements,

&depth);

- return new(zone()) ObjectLiteral(isolate(),

- constant_properties,

- properties,

- literal_index,

- is_simple,

- fast_elements,

- depth,

- has_function);

+ return factory()->NewObjectLiteral(constant_properties,

+ properties,

+ literal_index,

+ is_simple,

+ fast_elements,

+ depth,

+ has_function);

}

@@ -3935,8 +3867,7 @@ Expression* Parser::ParseRegExpLiteral(bool seen_equal, bool* ok) {

Handle<String> js_flags = NextLiteralString(TENURED);

Next();

- return new(zone()) RegExpLiteral(

- isolate(), js_pattern, js_flags, literal_index);

+ return factory()->NewRegExpLiteral(js_pattern, js_flags, literal_index);

}

@@ -3967,7 +3898,7 @@ ZoneList<Expression*>* Parser::ParseArguments(bool* ok) {

class SingletonLogger : public ParserRecorder {

public:

SingletonLogger() : has_error_(false), start_(-1), end_(-1) { }

- ~SingletonLogger() { }

+ virtual ~SingletonLogger() { }

void Reset() { has_error_ = false; }

@@ -4088,6 +4019,12 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> function_name,

bool only_simple_this_property_assignments;

Handle<FixedArray> this_property_assignments;

bool has_duplicate_parameters = false;

+ AstConstructionVisitor* visitor =

+ reinterpret_cast<AstConstructionVisitor*>(factory()->visitor());

+ ASSERT(visitor != NULL);

+ AstProperties* enclosing_ast_properties(visitor->properties());

+ AstProperties* ast_properties = new(zone()) AstProperties();

+ visitor->set_ast_properties(ast_properties);

// Parse function body.

{ FunctionState function_state(this, scope, isolate());

top_scope_->SetScopeName(function_name);

@@ -4150,7 +4087,8 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> function_name,

} else {

fvar_mode = CONST;

}

- fvar = top_scope_->DeclareFunctionVar(function_name, fvar_mode);

+ fvar =

+ top_scope_->DeclareFunctionVar(function_name, fvar_mode, factory());

}

// Determine whether the function will be lazily compiled.

@@ -4237,14 +4175,14 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> function_name,

if (!is_lazily_compiled) {

body = new(zone()) ZoneList<Statement*>(8);

if (fvar != NULL) {

- VariableProxy* fproxy = top_scope_->NewUnresolved(function_name);

+ VariableProxy* fproxy =

+ top_scope_->NewUnresolved(factory(), function_name);

fproxy->BindTo(fvar);

- body->Add(new(zone()) ExpressionStatement(

- new(zone()) Assignment(isolate(),

- fvar_init_op,

- fproxy,

- new(zone()) ThisFunction(isolate()),

- RelocInfo::kNoPosition)));

+ body->Add(factory()->NewExpressionStatement(

+ factory()->NewAssignment(fvar_init_op,

+ fproxy,

+ factory()->NewThisFunction(),

+ RelocInfo::kNoPosition)));

}

ParseSourceElements(body, Token::RBRACE, CHECK_OK);

@@ -4310,21 +4248,23 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> function_name,

if (is_extended_mode()) {

CheckConflictingVarDeclarations(scope, CHECK_OK);

}

+ // The FunctionLiteral itself counts towards the AST that contains it.

+ visitor->set_ast_properties(enclosing_ast_properties);

FunctionLiteral* function_literal =

- new(zone()) FunctionLiteral(isolate(),

- function_name,

- scope,

- body,

- materialized_literal_count,

- expected_property_count,

- handler_count,

- only_simple_this_property_assignments,

- this_property_assignments,

- num_parameters,

- type,

- has_duplicate_parameters);

+ factory()->NewFunctionLiteral(function_name,

+ scope,

+ body,

+ materialized_literal_count,

+ expected_property_count,

+ handler_count,

+ only_simple_this_property_assignments,

+ this_property_assignments,

+ num_parameters,

+ type,

+ has_duplicate_parameters);

function_literal->set_function_token_position(function_token_position);

+ function_literal->set_ast_properties(ast_properties);

if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);

return function_literal;

@@ -4394,7 +4334,7 @@ Expression* Parser::ParseV8Intrinsic(bool* ok) {

}

// We have a valid intrinsics call or a call to a builtin.

- return new(zone()) CallRuntime(isolate(), name, function, args);

+ return factory()->NewCallRuntime(name, function, args);

}

@@ -4450,17 +4390,12 @@ void Parser::ExpectSemicolon(bool* ok) {

Literal* Parser::GetLiteralUndefined() {

- return NewLiteral(isolate()->factory()->undefined_value());

+ return factory()->NewLiteral(isolate()->factory()->undefined_value());

}

Literal* Parser::GetLiteralTheHole() {

- return NewLiteral(isolate()->factory()->the_hole_value());

-Literal* Parser::GetLiteralNumber(double value) {

- return NewNumberLiteral(value);

+ return factory()->NewLiteral(isolate()->factory()->the_hole_value());

}

@@ -4638,11 +4573,6 @@ void Parser::RegisterTargetUse(Label* target, Target* stop) {

}

-Literal* Parser::NewNumberLiteral(double number) {

- return NewLiteral(isolate()->factory()->NewNumber(number, TENURED));

Expression* Parser::NewThrowReferenceError(Handle<String> type) {

return NewThrowError(isolate()->factory()->MakeReferenceError_symbol(),

type, HandleVector<Object>(NULL, 0));

@@ -4686,15 +4616,11 @@ Expression* Parser::NewThrowError(Handle<String> constructor,

elements, FAST_ELEMENTS, TENURED);

ZoneList<Expression*>* args = new(zone()) ZoneList<Expression*>(2);

- args->Add(NewLiteral(type));

- args->Add(NewLiteral(array));

- CallRuntime* call_constructor = new(zone()) CallRuntime(isolate(),

- constructor,

- NULL,

- args);

- return new(zone()) Throw(isolate(),

- call_constructor,

- scanner().location().beg_pos);

+ args->Add(factory()->NewLiteral(type));

+ args->Add(factory()->NewLiteral(array));

+ CallRuntime* call_constructor =

+ factory()->NewCallRuntime(constructor, NULL, args);

+ return factory()->NewThrow(call_constructor, scanner().location().beg_pos);

}

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

@@ -5666,7 +5592,7 @@ bool ParserApi::Parse(CompilationInfo* info, int parsing_flags) {

parsing_flags |= EXTENDED_MODE;

}

if (FLAG_allow_natives_syntax || info->is_native()) {

- // We requre %identifier(..) syntax.

+ // We require %identifier(..) syntax.

parsing_flags |= kAllowNativesSyntax;

}

if (info->is_lazy()) {

« src/parser.h ('K') | « src/parser.h ('k') | src/rewriter.cc » ('j') | src/rewriter.cc » ('J')