blob: 00f35d53d1c433652b64c161822944b3e9455ccd [file] [log] [blame]
// Copyright 2015 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.
// Test Annex B 3.3 semantics for functions declared in blocks in sloppy mode.
// http://www.ecma-international.org/ecma-262/6.0/#sec-block-level-function-declarations-web-legacy-compatibility-semantics
(function overridingLocalFunction() {
var x = [];
assertEquals('function', typeof f);
function f() {
x.push(1);
}
f();
{
f();
function f() {
x.push(2);
}
f();
}
f();
{
f();
function f() {
x.push(3);
}
f();
}
f();
assertArrayEquals([1, 2, 2, 2, 3, 3, 3], x);
})();
(function newFunctionBinding() {
var x = [];
assertEquals('undefined', typeof f);
{
f();
function f() {
x.push(2);
}
f();
}
f();
{
f();
function f() {
x.push(3);
}
f();
}
f();
assertArrayEquals([2, 2, 2, 3, 3, 3], x);
})();
(function shadowingLetDoesntBind() {
let f = 1;
assertEquals(1, f);
{
let y = 3;
function f() {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals(1, f);
})();
(function shadowingLetDoesntBindGenerator() {
let f = function *f() {
while(true) {
yield 1;
}
};
assertEquals(1, f().next().value);
{
function *f() {
while(true) {
yield 2;
}
}
assertEquals(2, f().next().value);
}
assertEquals(1, f().next().value);
})();
(function shadowingClassDoesntBind() {
class f { }
assertEquals('class f { }', f.toString());
{
let y = 3;
function f() {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals('class f { }', f.toString());
})();
(function shadowingConstDoesntBind() {
const f = 1;
assertEquals(1, f);
{
let y = 3;
function f() {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals(1, f);
})();
(function shadowingVarBinds() {
var f = 1;
assertEquals(1, f);
{
let y = 3;
function f() {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals('function', typeof f);
})();
(function complexParams(a = 0) {
{
let y = 3;
function f(b = 0) {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals('function', typeof f);
})();
(function complexVarParams(a = 0) {
var f;
{
let y = 3;
function f(b = 0) {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals('function', typeof f);
})();
(function conditional() {
if (true) {
function f() { return 1; }
} else {
function f() { return 2; }
}
assertEquals(1, f());
if (false) {
function g() { return 1; }
} else {
function g() { return 2; }
}
assertEquals(2, g());
})();
(function skipExecution() {
{
function f() { return 1; }
}
assertEquals(1, f());
{
function f() { return 2; }
}
assertEquals(2, f());
L: {
assertEquals(3, f());
break L;
function f() { return 3; }
}
assertEquals(2, f());
})();
(function executionOrder() {
function getOuter() {
return f;
}
assertEquals('undefined', typeof getOuter());
{
assertEquals('function', typeof f);
assertEquals('undefined', typeof getOuter());
function f () {}
assertEquals('function', typeof f);
assertEquals('function', typeof getOuter());
}
assertEquals('function', typeof getOuter());
})();
(function reassignBindings() {
function getOuter() {
return f;
}
assertEquals('undefined', typeof getOuter());
{
assertEquals('function', typeof f);
assertEquals('undefined', typeof getOuter());
f = 1;
assertEquals('number', typeof f);
assertEquals('undefined', typeof getOuter());
function f () {}
assertEquals('number', typeof f);
assertEquals('number', typeof getOuter());
f = '';
assertEquals('string', typeof f);
assertEquals('number', typeof getOuter());
}
assertEquals('number', typeof getOuter());
})();
// Test that shadowing arguments is fine
(function shadowArguments(x) {
assertArrayEquals([1], arguments);
{
assertEquals('function', typeof arguments);
function arguments() {}
assertEquals('function', typeof arguments);
}
assertEquals('function', typeof arguments);
})(1);
// Don't shadow simple parameter
(function shadowingParameterDoesntBind(x) {
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})(1);
// Don't shadow complex parameter
(function shadowingDefaultParameterDoesntBind(x = 0) {
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})(1);
// Don't shadow nested complex parameter
(function shadowingNestedParameterDoesntBind([[x]]) {
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})([[1]]);
// Don't shadow rest parameter
(function shadowingRestParameterDoesntBind(...x) {
assertArrayEquals([1], x);
{
function x() {}
}
assertArrayEquals([1], x);
})(1);
// Don't shadow complex rest parameter
(function shadowingComplexRestParameterDoesntBind(...[x]) {
assertArrayEquals(1, x);
{
function x() {}
}
assertArrayEquals(1, x);
})(1);
// Previous tests with a var declaration thrown in.
// Don't shadow simple parameter
(function shadowingVarParameterDoesntBind(x) {
var x;
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})(1);
// Don't shadow complex parameter
(function shadowingVarDefaultParameterDoesntBind(x = 0) {
var x;
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})(1);
// Don't shadow nested complex parameter
(function shadowingVarNestedParameterDoesntBind([[x]]) {
var x;
assertEquals(1, x);
{
function x() {}
}
assertEquals(1, x);
})([[1]]);
// Don't shadow rest parameter
(function shadowingVarRestParameterDoesntBind(...x) {
var x;
assertArrayEquals([1], x);
{
function x() {}
}
assertArrayEquals([1], x);
})(1);
// Don't shadow complex rest parameter
(function shadowingVarComplexRestParameterDoesntBind(...[x]) {
var x;
assertArrayEquals(1, x);
{
function x() {}
}
assertArrayEquals(1, x);
})(1);
// Hoisting is not affected by other simple parameters
(function irrelevantParameterBinds(y, z) {
assertEquals(undefined, x);
{
function x() {}
}
assertEquals('function', typeof x);
})(1);
// Hoisting is not affected by other complex parameters
(function irrelevantComplexParameterBinds([y] = [], z) {
assertEquals(undefined, x);
{
function x() {}
}
assertEquals('function', typeof x);
})();
// Hoisting is not affected by rest parameters
(function irrelevantRestParameterBinds(y, ...z) {
assertEquals(undefined, x);
{
function x() {}
}
assertEquals('function', typeof x);
})();
// Hoisting is not affected by complex rest parameters
(function irrelevantRestParameterBinds(y, ...[z]) {
assertEquals(undefined, x);
{
function x() {}
}
assertEquals('function', typeof x);
})();
// Test that shadowing function name is fine
{
let called = false;
(function shadowFunctionName() {
if (called) assertUnreachable();
called = true;
{
function shadowFunctionName() {
return 0;
}
assertEquals(0, shadowFunctionName());
}
assertEquals(0, shadowFunctionName());
})();
}
{
let called = false;
(function shadowFunctionNameWithComplexParameter(...r) {
if (called) assertUnreachable();
called = true;
{
function shadowFunctionNameWithComplexParameter() {
return 0;
}
assertEquals(0, shadowFunctionNameWithComplexParameter());
}
assertEquals(0, shadowFunctionNameWithComplexParameter());
})();
}
(function shadowOuterVariable() {
{
let f = 0;
(function () {
assertEquals(undefined, f);
{
assertEquals(1, f());
function f() { return 1; }
assertEquals(1, f());
}
assertEquals(1, f());
})();
assertEquals(0, f);
}
})();
(function notInDefaultScope() {
var y = 1;
(function innerNotInDefaultScope(x = y) {
assertEquals('undefined', typeof y);
{
function y() {}
}
assertEquals('function', typeof y);
assertEquals(1, x);
})();
})();
(function noHoistingThroughNestedLexical() {
{
let f = 2;
{
let y = 3;
function f() {
y = 2;
}
f();
assertEquals(2, y);
}
assertEquals(2, f);
}
assertThrows(()=>f, ReferenceError);
})();
// Only the first function is hoisted; the second is blocked by the first.
// Contrast overridingLocalFunction, in which the outer function declaration
// is not lexical and so the inner declaration is hoisted.
(function noHoistingThroughNestedFunctions() {
assertEquals(undefined, f); // Also checks that the var-binding exists
{
assertEquals(4, f());
function f() {
return 4;
}
{
assertEquals(5, f());
function f() {
return 5;
}
assertEquals(5, f());
}
assertEquals(4, f());
}
assertEquals(4, f());
})();
// B.3.5 interacts with B.3.3 to allow this.
(function hoistingThroughSimpleCatch() {
assertEquals(undefined, f);
try {
throw 0;
} catch (f) {
{
assertEquals(4, f());
function f() {
return 4;
}
assertEquals(4, f());
}
assertEquals(0, f);
}
assertEquals(4, f());
})();
(function noHoistingIfLetOutsideSimpleCatch() {
assertThrows(()=>f, ReferenceError);
let f = 2;
assertEquals(2, f);
try {
throw 0;
} catch (f) {
{
assertEquals(4, f());
function f() {
return 4;
}
assertEquals(4, f());
}
assertEquals(0, f);
}
assertEquals(2, f);
})();
(function noHoistingThroughComplexCatch() {
try {
throw 0;
} catch ({f}) {
{
assertEquals(4, f());
function f() {
return 4;
}
assertEquals(4, f());
}
}
assertThrows(()=>f, ReferenceError);
})();
(function hoistingThroughWith() {
with ({f: 0}) {
assertEquals(0, f);
{
assertEquals(4, f());
function f() {
return 4;
}
assertEquals(4, f());
}
assertEquals(0, f);
}
assertEquals(4, f());
})();
// Test that hoisting from blocks does happen in global scope
function globalHoisted() { return 0; }
{
function globalHoisted() { return 1; }
}
assertEquals(1, globalHoisted());
// Also happens when not previously defined
assertEquals(undefined, globalUndefinedHoisted);
{
function globalUndefinedHoisted() { return 1; }
}
assertEquals(1, globalUndefinedHoisted());
var globalUndefinedHoistedDescriptor =
Object.getOwnPropertyDescriptor(this, "globalUndefinedHoisted");
assertFalse(globalUndefinedHoistedDescriptor.configurable);
assertTrue(globalUndefinedHoistedDescriptor.writable);
assertTrue(globalUndefinedHoistedDescriptor.enumerable);
assertEquals(1, globalUndefinedHoistedDescriptor.value());
// When a function property is hoisted, it should be
// made enumerable.
// BUG(v8:4451)
Object.defineProperty(this, "globalNonEnumerable", {
value: false,
configurable: true,
writable: true,
enumerable: false
});
eval("{function globalNonEnumerable() { return 1; }}");
var globalNonEnumerableDescriptor
= Object.getOwnPropertyDescriptor(this, "globalNonEnumerable");
// BUG(v8:4451): Should be made non-configurable
assertTrue(globalNonEnumerableDescriptor.configurable);
assertTrue(globalNonEnumerableDescriptor.writable);
// BUG(v8:4451): Should be made enumerable
assertFalse(globalNonEnumerableDescriptor.enumerable);
assertEquals(1, globalNonEnumerableDescriptor.value());
// When a function property is hoisted, it should be overwritten and
// made writable and overwritten, even if the property was non-writable.
Object.defineProperty(this, "globalNonWritable", {
value: false,
configurable: true,
writable: false,
enumerable: true
});
eval("{function globalNonWritable() { return 1; }}");
var globalNonWritableDescriptor
= Object.getOwnPropertyDescriptor(this, "globalNonWritable");
// BUG(v8:4451): Should be made non-configurable
assertTrue(globalNonWritableDescriptor.configurable);
// BUG(v8:4451): Should be made writable
assertFalse(globalNonWritableDescriptor.writable);
assertFalse(globalNonEnumerableDescriptor.enumerable);
// BUG(v8:4451): Should be overwritten
assertEquals(false, globalNonWritableDescriptor.value);
// Test that hoisting from blocks does happen in an eval
eval(`
function evalHoisted() { return 0; }
{
function evalHoisted() { return 1; }
}
assertEquals(1, evalHoisted());
`);
// Test that hoisting from blocks happens from eval in a function
!function() {
eval(`
function evalInFunctionHoisted() { return 0; }
{
function evalInFunctionHoisted() { return 1; }
}
assertEquals(1, evalInFunctionHoisted());
`);
}();
(function evalHoistingThroughSimpleCatch() {
try {
throw 0;
} catch (f) {
eval(`{ function f() {
return 4;
} }`);
assertEquals(0, f);
}
assertEquals(4, f());
})();
(function evalHoistingThroughWith() {
with ({f: 0}) {
eval(`{ function f() {
return 4;
} }`);
assertEquals(0, f);
}
assertEquals(4, f());
})();
let dontHoistGlobal;
{ function dontHoistGlobal() {} }
assertEquals(undefined, dontHoistGlobal);
let dontHoistEval;
var throws = false;
try {
eval("{ function dontHoistEval() {} }");
} catch (e) {
throws = true;
}
assertFalse(throws);
// When the global object is frozen, silently don't hoist
// Currently this actually throws BUG(v8:4452)
Object.freeze(this);
{
let throws = false;
try {
eval('{ function hoistWhenFrozen() {} }');
} catch (e) {
throws = true;
}
assertFalse(this.hasOwnProperty("hoistWhenFrozen"));
assertThrows(() => hoistWhenFrozen, ReferenceError);
// Should be assertFalse BUG(v8:4452)
assertTrue(throws);
}