From 6f4e70a1dc338409f8aee99b6b9aebb168c4a42c Mon Sep 17 00:00:00 2001 From: "keuchel@chromium.org" Date: Mon, 17 Oct 2011 12:19:06 +0000 Subject: [PATCH] Let bound iteration variables in for-loops TEST=mjsunit/harmony/block-for.js Review URL: http://codereview.chromium.org/7837028 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@9658 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/parser.cc | 108 +++++++++++++++++++++-- src/parser.h | 7 ++ src/preparser.cc | 12 ++- src/preparser.h | 7 ++ test/mjsunit/harmony/block-for.js | 142 ++++++++++++++++++++++++++++++ test/mjsunit/harmony/debug-blockscopes.js | 109 +++++++++++++++++++++++ 6 files changed, 377 insertions(+), 8 deletions(-) create mode 100644 test/mjsunit/harmony/block-for.js diff --git a/src/parser.cc b/src/parser.cc index 6df216d..0960c83 100644 --- a/src/parser.cc +++ b/src/parser.cc @@ -1631,6 +1631,7 @@ Block* Parser::ParseVariableStatement(VariableDeclarationContext var_context, Handle ignore; Block* result = ParseVariableDeclarations(var_context, + NULL, &ignore, CHECK_OK); ExpectSemicolon(CHECK_OK); @@ -1649,9 +1650,11 @@ bool Parser::IsEvalOrArguments(Handle string) { // *var is untouched; in particular, it is the caller's responsibility // to initialize it properly. This mechanism is used for the parsing // of 'for-in' loops. -Block* Parser::ParseVariableDeclarations(VariableDeclarationContext var_context, - Handle* out, - bool* ok) { +Block* Parser::ParseVariableDeclarations( + VariableDeclarationContext var_context, + VariableDeclarationProperties* decl_props, + Handle* out, + bool* ok) { // VariableDeclarations :: // ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[','] @@ -1789,6 +1792,7 @@ Block* Parser::ParseVariableDeclarations(VariableDeclarationContext var_context, } else { fni_->RemoveLastFunction(); } + if (decl_props != NULL) *decl_props = kHasInitializers; } // Make sure that 'const x' and 'let x' initialize 'x' to undefined. @@ -2369,13 +2373,21 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Statement* init = NULL; + // Create an in-between scope for let-bound iteration variables. + Scope* saved_scope = top_scope_; + Scope* for_scope = NewScope(top_scope_, Scope::BLOCK_SCOPE); + if (top_scope_->is_strict_mode()) { + for_scope->EnableStrictMode(); + } + top_scope_ = for_scope; + Expect(Token::FOR, CHECK_OK); Expect(Token::LPAREN, CHECK_OK); if (peek() != Token::SEMICOLON) { if (peek() == Token::VAR || peek() == Token::CONST) { Handle name; Block* variable_statement = - ParseVariableDeclarations(kForStatement, &name, CHECK_OK); + ParseVariableDeclarations(kForStatement, NULL, &name, CHECK_OK); if (peek() == Token::IN && !name.is_null()) { VariableProxy* each = top_scope_->NewUnresolved(name); @@ -2391,12 +2403,71 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Block* result = new(zone()) Block(isolate(), NULL, 2, false); result->AddStatement(variable_statement); result->AddStatement(loop); + top_scope_ = saved_scope; + for_scope = for_scope->FinalizeBlockScope(); + ASSERT(for_scope == NULL); // Parsed for-in loop w/ variable/const declaration. return result; } else { init = variable_statement; } + } else if (peek() == Token::LET) { + Handle name; + VariableDeclarationProperties decl_props = kHasNoInitializers; + Block* variable_statement = + ParseVariableDeclarations(kForStatement, + &decl_props, + &name, + CHECK_OK); + bool accept_IN = !name.is_null() && decl_props != kHasInitializers; + if (peek() == Token::IN && accept_IN) { + // Rewrite a for-in statement of the form + // + // for (let x in e) b + // + // into + // + // + // for (x' in e) { + // let x; + // x = x'; + // b; + // } + + // 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, inside_with()); + ForInStatement* loop = new(zone()) ForInStatement(isolate(), labels); + Target target(&this->target_stack_, loop); + + Expect(Token::IN, CHECK_OK); + Expression* enumerable = ParseExpression(true, CHECK_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); + Statement* assignment_statement = + new(zone()) ExpressionStatement(assignment); + body_block->AddStatement(variable_statement); + body_block->AddStatement(assignment_statement); + body_block->AddStatement(body); + loop->Initialize(temp_proxy, enumerable, body_block); + top_scope_ = saved_scope; + for_scope = for_scope->FinalizeBlockScope(); + body_block->set_block_scope(for_scope); + // Parsed for-in loop w/ let declaration. + return loop; + } else { + init = variable_statement; + } } else { Expression* expression = ParseExpression(false, CHECK_OK); if (peek() == Token::IN) { @@ -2418,6 +2489,9 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Statement* body = ParseStatement(NULL, CHECK_OK); if (loop) loop->Initialize(expression, enumerable, body); + top_scope_ = saved_scope; + for_scope = for_scope->FinalizeBlockScope(); + ASSERT(for_scope == NULL); // Parsed for-in loop. return loop; @@ -2448,8 +2522,30 @@ Statement* Parser::ParseForStatement(ZoneStringList* labels, bool* ok) { Expect(Token::RPAREN, CHECK_OK); Statement* body = ParseStatement(NULL, CHECK_OK); - if (loop) loop->Initialize(init, cond, next, body); - return loop; + top_scope_ = saved_scope; + for_scope = for_scope->FinalizeBlockScope(); + if (for_scope != NULL) { + // Rewrite a for statement of the form + // + // for (let x = i; c; n) b + // + // into + // + // { + // let x = i; + // for (; c; n) b + // } + ASSERT(init != NULL); + Block* result = new(zone()) Block(isolate(), NULL, 2, false); + result->AddStatement(init); + result->AddStatement(loop); + result->set_block_scope(for_scope); + if (loop) loop->Initialize(NULL, cond, next, body); + return result; + } else { + if (loop) loop->Initialize(init, cond, next, body); + return loop; + } } diff --git a/src/parser.h b/src/parser.h index 72561e0..96fa980 100644 --- a/src/parser.h +++ b/src/parser.h @@ -460,6 +460,12 @@ class Parser { kForStatement }; + // If a list of variable declarations includes any initializers. + enum VariableDeclarationProperties { + kHasInitializers, + kHasNoInitializers + }; + Isolate* isolate() { return isolate_; } Zone* zone() { return isolate_->zone(); } @@ -497,6 +503,7 @@ class Parser { Block* ParseVariableStatement(VariableDeclarationContext var_context, bool* ok); Block* ParseVariableDeclarations(VariableDeclarationContext var_context, + VariableDeclarationProperties* decl_props, Handle* out, bool* ok); Statement* ParseExpressionOrLabelledStatement(ZoneStringList* labels, diff --git a/src/preparser.cc b/src/preparser.cc index beb868c..92d47cb 100644 --- a/src/preparser.cc +++ b/src/preparser.cc @@ -312,6 +312,7 @@ PreParser::Statement PreParser::ParseVariableStatement( Statement result = ParseVariableDeclarations(var_context, NULL, + NULL, CHECK_OK); ExpectSemicolon(CHECK_OK); return result; @@ -325,6 +326,7 @@ PreParser::Statement PreParser::ParseVariableStatement( // of 'for-in' loops. PreParser::Statement PreParser::ParseVariableDeclarations( VariableDeclarationContext var_context, + VariableDeclarationProperties* decl_props, int* num_decl, bool* ok) { // VariableDeclarations :: @@ -375,6 +377,7 @@ PreParser::Statement PreParser::ParseVariableDeclarations( if (peek() == i::Token::ASSIGN) { Expect(i::Token::ASSIGN, CHECK_OK); ParseAssignmentExpression(var_context != kForStatement, CHECK_OK); + if (decl_props != NULL) *decl_props = kHasInitializers; } } while (peek() == i::Token::COMMA); @@ -569,9 +572,14 @@ PreParser::Statement PreParser::ParseForStatement(bool* ok) { if (peek() != i::Token::SEMICOLON) { if (peek() == i::Token::VAR || peek() == i::Token::CONST || peek() == i::Token::LET) { + bool is_let = peek() == i::Token::LET; int decl_count; - ParseVariableDeclarations(kForStatement, &decl_count, CHECK_OK); - if (peek() == i::Token::IN && decl_count == 1) { + VariableDeclarationProperties decl_props = kHasNoInitializers; + ParseVariableDeclarations( + kForStatement, &decl_props, &decl_count, CHECK_OK); + bool accept_IN = decl_count == 1 && + !(is_let && decl_props == kHasInitializers); + if (peek() == i::Token::IN && accept_IN) { Expect(i::Token::IN, CHECK_OK); ParseExpression(true, CHECK_OK); Expect(i::Token::RPAREN, CHECK_OK); diff --git a/src/preparser.h b/src/preparser.h index cb1d5fb..f3fd24a 100644 --- a/src/preparser.h +++ b/src/preparser.h @@ -179,6 +179,12 @@ class PreParser { kForStatement }; + // If a list of variable declarations includes any initializers. + enum VariableDeclarationProperties { + kHasInitializers, + kHasNoInitializers + }; + class Expression; class Identifier { @@ -493,6 +499,7 @@ class PreParser { Statement ParseVariableStatement(VariableDeclarationContext var_context, bool* ok); Statement ParseVariableDeclarations(VariableDeclarationContext var_context, + VariableDeclarationProperties* decl_props, int* num_decl, bool* ok); Statement ParseExpressionOrLabelledStatement(bool* ok); diff --git a/test/mjsunit/harmony/block-for.js b/test/mjsunit/harmony/block-for.js new file mode 100644 index 0000000..1f68037 --- /dev/null +++ b/test/mjsunit/harmony/block-for.js @@ -0,0 +1,142 @@ +// Copyright 2011 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. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Flags: --harmony-scoping + +function props(x) { + var array = []; + for (let p in x) array.push(p); + return array.sort(); +} + +assertEquals(0, props({}).length); +assertEquals(1, props({x:1}).length); +assertEquals(2, props({x:1, y:2}).length); + +assertArrayEquals(["x"], props({x:1})); +assertArrayEquals(["x", "y"], props({x:1, y:2})); +assertArrayEquals(["x", "y", "zoom"], props({x:1, y:2, zoom:3})); + +assertEquals(0, props([]).length); +assertEquals(1, props([1]).length); +assertEquals(2, props([1,2]).length); + +assertArrayEquals(["0"], props([1])); +assertArrayEquals(["0", "1"], props([1,2])); +assertArrayEquals(["0", "1", "2"], props([1,2,3])); + +var o = {}; +var a = []; +let i = "outer_i"; +let s = "outer_s"; +for (let i = 0x0020; i < 0x01ff; i+=2) { + let s = 'char:' + String.fromCharCode(i); + a.push(s); + o[s] = i; +} +assertArrayEquals(a, props(o)); +assertEquals(i, "outer_i"); +assertEquals(s, "outer_s"); + +var a = []; +assertEquals(0, props(a).length); +a[Math.pow(2,30)-1] = 0; +assertEquals(1, props(a).length); +a[Math.pow(2,31)-1] = 0; +assertEquals(2, props(a).length); +a[1] = 0; +assertEquals(3, props(a).length); + +var result = ''; +for (let p in {a : [0], b : 1}) { result += p; } +assertEquals('ab', result); + +var result = ''; +for (let p in {a : {v:1}, b : 1}) { result += p; } +assertEquals('ab', result); + +var result = ''; +for (let p in { get a() {}, b : 1}) { result += p; } +assertEquals('ab', result); + +var result = ''; +for (let p in { get a() {}, set a(x) {}, b : 1}) { result += p; } +assertEquals('ab', result); + + +// Check that there is exactly one variable without initializer +// in a for-in statement with let variables. +assertThrows("function foo() { for (let in {}) { } }", SyntaxError); +assertThrows("function foo() { for (let x = 3 in {}) { } }", SyntaxError); +assertThrows("function foo() { for (let x, y in {}) { } }", SyntaxError); +assertThrows("function foo() { for (let x = 3, y in {}) { } }", SyntaxError); +assertThrows("function foo() { for (let x, y = 4 in {}) { } }", SyntaxError); +assertThrows("function foo() { for (let x = 3, y = 4 in {}) { } }", SyntaxError); + + +// In a normal for statement the iteration variable is not +// freshly allocated for each iteration. +function closures1() { + let a = []; + for (let i = 0; i < 5; ++i) { + a.push(function () { return i; }); + } + for (let j = 0; j < 5; ++j) { + assertEquals(5, a[j]()); + } +} +closures1(); + + +function closures2() { + let a = [], b = []; + for (let i = 0, j = 10; i < 5; ++i, ++j) { + a.push(function () { return i; }); + b.push(function () { return j; }); + } + for (let k = 0; k < 5; ++k) { + assertEquals(5, a[k]()); + assertEquals(15, b[k]()); + } +} +closures2(); + + +// In a for-in statement the iteration variable is fresh +// for earch iteration. +function closures3(x) { + let a = []; + for (let p in x) { + a.push(function () { return p; }); + } + let k = 0; + for (let q in x) { + assertEquals(q, a[k]()); + ++k; + } +} +closures3({a : [0], b : 1, c : {v : 1}, get d() {}, set e(x) {}}); diff --git a/test/mjsunit/harmony/debug-blockscopes.js b/test/mjsunit/harmony/debug-blockscopes.js index 020f527..4c49d9a 100644 --- a/test/mjsunit/harmony/debug-blockscopes.js +++ b/test/mjsunit/harmony/debug-blockscopes.js @@ -464,3 +464,112 @@ listener_delegate = function(exec_state) { }; closure_1(1)(); EndTest(); + + +// Simple for-in loop over the keys of an object. +BeginTest("For loop 1"); + +function for_loop_1() { + for (let x in {y:undefined}) { + debugger; + } +} + +listener_delegate = function(exec_state) { + CheckScopeChain([debug.ScopeType.Block, + debug.ScopeType.Local, + debug.ScopeType.Global], exec_state); + CheckScopeContent({x:'y'}, 0, exec_state); + // The function scope contains a temporary iteration variable. + CheckScopeContent({x:'y'}, 1, exec_state); +}; +for_loop_1(); +EndTest(); + + +// For-in loop over the keys of an object with a block scoped let variable +// shadowing the iteration variable. +BeginTest("For loop 2"); + +function for_loop_2() { + for (let x in {y:undefined}) { + let x = 3; + debugger; + } +} + +listener_delegate = function(exec_state) { + CheckScopeChain([debug.ScopeType.Block, + debug.ScopeType.Block, + debug.ScopeType.Local, + debug.ScopeType.Global], exec_state); + CheckScopeContent({x:3}, 0, exec_state); + CheckScopeContent({x:'y'}, 1, exec_state); + // The function scope contains a temporary iteration variable. + CheckScopeContent({x:'y'}, 2, exec_state); +}; +for_loop_2(); +EndTest(); + + +// Simple for loop. +BeginTest("For loop 3"); + +function for_loop_3() { + for (let x = 3; x < 4; ++x) { + debugger; + } +} + +listener_delegate = function(exec_state) { + CheckScopeChain([debug.ScopeType.Block, + debug.ScopeType.Local, + debug.ScopeType.Global], exec_state); + CheckScopeContent({x:3}, 0, exec_state); + CheckScopeContent({}, 1, exec_state); +}; +for_loop_3(); +EndTest(); + + +// For loop with a block scoped let variable shadowing the iteration variable. +BeginTest("For loop 4"); + +function for_loop_4() { + for (let x = 3; x < 4; ++x) { + let x = 5; + debugger; + } +} + +listener_delegate = function(exec_state) { + CheckScopeChain([debug.ScopeType.Block, + debug.ScopeType.Block, + debug.ScopeType.Local, + debug.ScopeType.Global], exec_state); + CheckScopeContent({x:5}, 0, exec_state); + CheckScopeContent({x:3}, 1, exec_state); + CheckScopeContent({}, 2, exec_state); +}; +for_loop_4(); +EndTest(); + + +// For loop with two variable declarations. +BeginTest("For loop 5"); + +function for_loop_5() { + for (let x = 3, y = 5; x < 4; ++x) { + debugger; + } +} + +listener_delegate = function(exec_state) { + CheckScopeChain([debug.ScopeType.Block, + debug.ScopeType.Local, + debug.ScopeType.Global], exec_state); + CheckScopeContent({x:3,y:5}, 0, exec_state); + CheckScopeContent({}, 1, exec_state); +}; +for_loop_5(); +EndTest(); -- 2.7.4