// 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.
// Flags: --harmony-do-expressions --harmony-sloppy-let --allow-natives-syntax
// Flags: --harmony-default-parameters --harmony-destructuring-bind
// Flags: --harmony-completion
function returnValue(v) { return v; }
function MyError() {}
var global = this;
function TestBasic() {
// Looping and lexical declarations
assertEquals(512, returnValue(do {
let n = 2;
for (let i = 0; i < 4; i++) n <<= 2;
}));
// Strings do the right thing
assertEquals("spooky halloween", returnValue(do {
"happy halloween".replace('happy', 'spooky');
}));
// Do expressions with no completion produce an undefined value
assertEquals(undefined, returnValue(do {}));
assertEquals(undefined, returnValue(do { var x = 99; }));
assertEquals(undefined, returnValue(do { function f() {}; }));
assertEquals(undefined, returnValue(do { let z = 33; }));
// Propagation of exception
assertThrows(function() {
(do {
throw new MyError();
"potatoes";
});
}, MyError);
assertThrows(function() {
return do {
throw new MyError();
"potatoes";
};
}, MyError);
// Return value within do-block overrides `return |do-expression|`
assertEquals("inner-return", (function() {
return "outer-return" + do {
return "inner-return";
"";
};
})());
var count = 0, n = 1;
// Breaking out |do-expression|
assertEquals(3, (function() {
for (var i = 0; i < 10; ++i) (count += 2 * do { if (i === 3) break; ++n });
return i;
})());
// (2 * 2) + (2 * 3) + (2 * 4)
assertEquals(18, count);
// Continue in |do-expression|
count = 0, n = 1;
assertEquals([1, 3, 5, 7, 9], (function() {
var values = [];
for (var i = 0; i < 10; ++i) {
count += 2 * (do {
if ((i & 1) === 0) continue;
values.push(i);
++n;
}) + 1;
}
// (2*2) + 1 + (2*3) + 1 + (2*4) + 1 + (2*5) + 1 + (2*6) + 1
return values;
})());
assertEquals(count, 45);
assertThrows("(do { break; });", SyntaxError);
assertThrows("(do { continue; });", SyntaxError);
// Real-world use case for desugaring
var array = [1, 2, 3, 4, 5], iterable = [6, 7, 8,9];
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9], do {
for (var element of iterable) array.push(element);
array;
});
// Nested do-expressions
assertEquals(125, do { (do { (do { 5 * 5 * 5 }) }) });
// Directives are not honoured
(do {
"use strict";
foo = 80;
assertEquals(foo, 80);
});
// Non-empty operand stack testing
var O = {
method1() {
let x = 256;
return x + do {
for (var i = 0; i < 4; ++i) x += i;
} + 17;
},
method2() {
let x = 256;
this.reset();
return x + do {
for (var i = 0; i < this.length(); ++i) x += this.index() * 2;
};
},
_index: 0,
index() {
return ++this._index;
},
_length: 4,
length() { return this._length; },
reset() { this._index = 0; }
};
assertEquals(535, O["method" + do { 1 } + ""]());
assertEquals(532, O["method" + do { ({ valueOf() { return "2"; } }); }]());
assertEquals(532, O[
do { let s = ""; for (let c of "method") s += c; } + "2"]());
}
TestBasic();
function TestDeoptimization1() {
function f(v) {
return 88 + do {
v.a * v.b + v.c;
};
}
var o1 = {};
o1.a = 10;
o1.b = 5;
o1.c = 50;
var o2 = {};
o2.c = 100;
o2.a = 10;
o2.b = 10;
assertEquals(188, f(o1));
assertEquals(188, f(o1));
%OptimizeFunctionOnNextCall(f);
assertEquals(188, f(o1));
assertOptimized(f);
assertEquals(288, f(o2));
assertUnoptimized(f);
assertEquals(288, f(o2));
}
TestDeoptimization1();
function TestInParameterInitializers() {
var first_name = "George";
var last_name = "Jetson";
function fn1(name = do { first_name + " " + last_name }) {
return name;
}
assertEquals("George Jetson", fn1());
var _items = [1, 2, 3, NaN, 4, 5];
function fn2(items = do {
let items = [];
for (var el of _items) {
if (el !== el) {
items;
break;
}
items.push(el), items;
}
}) {
return items;
}
assertEquals([1, 2, 3], fn2());
function thrower() { throw new MyError(); }
function fn3(exception = do { try { thrower(); } catch (e) { e } }) {
return exception;
}
assertDoesNotThrow(fn3);
assertInstanceof(fn3(), MyError);
function fn4(exception = do { throw new MyError() }) {}
function catcher(fn) {
try {
fn();
assertUnreachable("fn() initializer should throw");
} catch (e) {
assertInstanceof(e, MyError);
}
}
catcher(fn4);
}
TestInParameterInitializers();
function TestWithEval() {
(function sloppy1() {
assertEquals(do { eval("var x = 5"), x }, 5);
assertEquals(x, 5);
})();
assertThrows(function strict1() {
"use strict";
(do { eval("var x = 5"), x }, 5);
}, ReferenceError);
assertThrows(function strict2() {
(do { eval("'use strict'; var x = 5"), x }, 5);
}, ReferenceError);
}
TestWithEval();
function TestHoisting() {
(do { var a = 1; });
assertEquals(a, 1);
assertEquals(global.a, undefined);
(do {
for (let it of [1, 2, 3, 4, 5]) {
var b = it;
}
});
assertEquals(b, 5);
assertEquals(global.b, undefined);
{
let x = 1
// TODO(caitp): ensure VariableStatements in |do-expressions| in parameter
// initializers, are evaluated in the same VariableEnvironment as they would
// be for eval().
// function f1(a = do { var x = 2 }, b = x) { return b }
// assertEquals(1, f1())
// function f2(a = x, b = do { var x = 2 }) { return a }
// assertEquals(1, f2())
function f3({a = do { var x = 2 }, b = x}) { return b }
assertEquals(2, f3({}))
function f4({a = x, b = do { var x = 2 }}) { return b }
assertEquals(undefined, f4({}))
function f5(a = do { var y = 0 }) {}
assertThrows(() => y, ReferenceError)
}
// TODO(caitp): Always block-scope function declarations in |do| expressions
//(do {
// assertEquals(true, inner_func());
// function inner_func() { return true; }
//});
//assertThrows(function() { return innerFunc(); }, ReferenceError);
}
TestHoisting();
// v8:4661
function tryFinallySimple() { (do { try {} finally {} }); }
tryFinallySimple();
tryFinallySimple();
tryFinallySimple();
tryFinallySimple();
var finallyRanCount = 0;
function tryFinallyDoExpr() {
return (do {
try {
throw "BOO";
} catch (e) {
"Caught: " + e + " (" + finallyRanCount + ")"
} finally {
++finallyRanCount;
}
});
}
assertEquals("Caught: BOO (0)", tryFinallyDoExpr());
assertEquals(1, finallyRanCount);
assertEquals("Caught: BOO (1)", tryFinallyDoExpr());
assertEquals(2, finallyRanCount);
assertEquals("Caught: BOO (2)", tryFinallyDoExpr());
assertEquals(3, finallyRanCount);
assertEquals("Caught: BOO (3)", tryFinallyDoExpr());
assertEquals(4, finallyRanCount);
function TestOSR() {
var numbers = do {
let nums = [];
for (let i = 0; i < 1000; ++i) {
let value = (Math.random() * 100) | 0;
nums.push(value === 0 ? 1 : value), nums;
}
};
assertEquals(numbers.length, 1000);
}
for (var i = 0; i < 64; ++i) TestOSR();