AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Disable lazy parsing inside eval (see bug).

Browse Source 
If the eval contains a let, we need to know whether an inner function
refers to the variable to be able to decide its context allocation
status.

The added test needs https://codereview.chromium.org/2435023002/ too
in order to pass.

BUG=v8:5736

Review-Url: https://codereview.chromium.org/2574753002
Cr-Commit-Position: refs/heads/master@{#41723}
This commit is contained in:
marja 2016-12-15 06:26:58 -08:00 committed by Commit bot
parent f1441384ff
commit ed080e6966
3 changed files with 24 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/ast/scopes.cc
View File

@ -1179,10 +1179,7 @@ bool Scope::AllowsLazyParsingWithoutUnresolvedVariables(
// the parse, since context allocation of those variables is already
// guaranteed to be correct.
for (const Scope* s = this; s != outer; s = s->outer_scope_) {
// Eval forces context allocation on all outer scopes, so we don't need to
// look at those scopes. Sloppy eval makes all top-level variables dynamic,
// whereas strict-mode requires context allocation.
if (s->is_eval_scope()) return !is_strict(s->language_mode());
if (s->is_eval_scope()) return false;
// Catch scopes force context allocation of all variables.
if (s->is_catch_scope()) continue;
// With scopes do not introduce variables that need allocation.

39
test/mjsunit/bugs/bug-2728.js
View File

@ -1,39 +0,0 @@
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// from test/webkit/fast/js/kde/parse.js
assertThrows("function test() { while(0) break lab; } lab: 1");
assertThrows("function test() { while(0) continue lab; } lab: 1");
assertThrows("function test() { while(0) break lab } lab: 1");
assertThrows("function test() { while(0) continue lab } lab: 1");
// from test/webkit/fast/js/parser-syntax-check.js
assertThrows("break ; break your_limits ; continue ; continue living ; debugger");
assertThrows("function f() { break ; break your_limits ; continue ; continue living ; debugger }");
assertThrows("try { break } catch(e) {}");
assertThrows("function f() { try { break } catch(e) {} }");
assertThrows("L: L: ;");
assertThrows("function f() { L: L: ; }");
assertThrows("L: L1: L: ;");
assertThrows("function f() { L: L1: L: ; }");
assertThrows("L: L1: L2: L3: L4: L: ;");
assertThrows("function f() { L: L1: L2: L3: L4: L: ; }");
// from test/mjsunit/es6/async-destructuring.js
assertThrows("'use strict'; async function f(x) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; async function f({x}) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; async function f(x) { const x = 0; }", SyntaxError);
assertThrows("'use strict'; async function f({x}) { const x = 0; }", SyntaxError);
// from test/mjsunit/es6/destructuring.js
assertThrows("'use strict'; function f(x) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; function f({x}) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; function f(x) { const x = 0; }", SyntaxError);
assertThrows("'use strict'; function f({x}) { const x = 0; }", SyntaxError);
// from test/mjsunit/es6/generator-destructuring.js
assertThrows("'use strict'; function* f(x) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; function* f({x}) { let x = 0; }", SyntaxError);
assertThrows("'use strict'; function* f(x) { const x = 0; }", SyntaxError);
assertThrows("'use strict'; function* f({x}) { const x = 0; }", SyntaxError);

23
test/mjsunit/regress/regress-5736.js Normal file
View File

@ -0,0 +1,23 @@
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var my_global = 0;
// The problem was that we allowed lazy functions inside evals, but did not
// force context allocation on the eval scope. Thus, foo was not context
// allocated since we didn't realize that a lazy function referred to it.
eval(`let foo = 1;
let maybe_lazy = function() { foo = 2; }
maybe_lazy();
my_global = foo;`);
assertEquals(2, my_global);
(function TestVarInStrictEval() {
"use strict";
eval(`var foo = 3;
let maybe_lazy = function() { foo = 4; }
maybe_lazy();
my_global = foo;`);
assertEquals(4, my_global);
})();