7a8e24b48f
This reverts commit 4363a69335
.
Reason for revert: Seems to break layout tests: https://ci.chromium.org/buildbot/client.v8.fyi/V8-Blink%20Linux%2064/24146
Original change's description:
> [inspector] fixed location of top level function return
>
> We should pass false as has_braces argument to create FunctionLiteral
> for top level function.
>
> R=dgozman@chromium.org,bmeurer@chromium.org
> TBR=bmeurer@chromium.org
>
> Bug: none
> Change-Id: I397f31b562d32c71f3a12bfc9ceeed16c367aa80
> Reviewed-on: https://chromium-review.googlesource.com/1098018
> Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
> Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
> Reviewed-by: Yang Guo <yangguo@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#53769}
TBR=dgozman@chromium.org,yangguo@chromium.org,kozyatinskiy@chromium.org
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: none
Change-Id: I4495f6723daed63b7a38b0d3c3637724f6c2d484
Reviewed-on: https://chromium-review.googlesource.com/1104017
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53775}
1025 lines
14 KiB
Plaintext
1025 lines
14 KiB
Plaintext
Checks possible break locations.
|
|
|
|
Running test: testEval
|
|
break at:
|
|
function testEval() {
|
|
#eval('// comment only');
|
|
eval('// comment only\n');
|
|
|
|
break at:
|
|
// comment onl#y
|
|
|
|
break at:
|
|
eval('// comment only');
|
|
#eval('// comment only\n');
|
|
}
|
|
|
|
break at:
|
|
// comment only#
|
|
|
|
|
|
break at:
|
|
eval('// comment only\n');
|
|
#}
|
|
|
|
|
|
|
|
Running test: testProcedure
|
|
break at:
|
|
function testProcedure() {
|
|
#procedure();
|
|
}
|
|
|
|
break at:
|
|
function procedure() {
|
|
var a = #1;
|
|
var b = 2;
|
|
|
|
break at:
|
|
var a = 1;
|
|
var b = #2;
|
|
}
|
|
|
|
break at:
|
|
var b = 2;
|
|
#}
|
|
|
|
|
|
break at:
|
|
procedure();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testIf
|
|
break at:
|
|
var a;
|
|
if (true) #a = true;
|
|
if (!a) {
|
|
|
|
break at:
|
|
if (true) a = true;
|
|
#if (!a) {
|
|
a = true;
|
|
|
|
break at:
|
|
} else {
|
|
#a = false;
|
|
}
|
|
|
|
break at:
|
|
}
|
|
#if (returnTrue()) {
|
|
a = false;
|
|
|
|
break at:
|
|
function returnTrue() {
|
|
#return true;
|
|
}
|
|
|
|
break at:
|
|
function returnTrue() {
|
|
return true;#
|
|
}
|
|
|
|
break at:
|
|
if (returnTrue()) {
|
|
#a = false;
|
|
} else {
|
|
|
|
break at:
|
|
}
|
|
#}
|
|
|
|
|
|
|
|
Running test: testEmptyFunction
|
|
break at:
|
|
function testEmptyFunction() {
|
|
#emptyFunction();
|
|
}
|
|
|
|
break at:
|
|
|
|
function emptyFunction() {#}
|
|
|
|
|
|
break at:
|
|
emptyFunction();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testCallArguments
|
|
break at:
|
|
function testCallArguments() {
|
|
#twoArguments(emptyFunction(), emptyFunction());
|
|
}
|
|
|
|
break at:
|
|
|
|
function emptyFunction() {#}
|
|
|
|
|
|
break at:
|
|
function testCallArguments() {
|
|
twoArguments(emptyFunction(), #emptyFunction());
|
|
}
|
|
|
|
break at:
|
|
|
|
function emptyFunction() {#}
|
|
|
|
|
|
break at:
|
|
function testCallArguments() {
|
|
#twoArguments(emptyFunction(), emptyFunction());
|
|
}
|
|
|
|
break at:
|
|
function twoArguments(a1, a2) {
|
|
#}
|
|
|
|
|
|
break at:
|
|
twoArguments(emptyFunction(), emptyFunction());
|
|
#}
|
|
|
|
|
|
|
|
Running test: testNested
|
|
break at:
|
|
}
|
|
#nested1();
|
|
}
|
|
|
|
break at:
|
|
}
|
|
return #nested2();
|
|
}
|
|
|
|
break at:
|
|
}
|
|
#nested3();
|
|
return;
|
|
|
|
break at:
|
|
function nested3() {
|
|
#}
|
|
nested3();
|
|
|
|
break at:
|
|
nested3();
|
|
#return;
|
|
}
|
|
|
|
break at:
|
|
nested3();
|
|
return;#
|
|
}
|
|
|
|
break at:
|
|
}
|
|
return nested2();#
|
|
}
|
|
|
|
break at:
|
|
nested1();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testCallAtReturn
|
|
break at:
|
|
function testCallAtReturn() {
|
|
#return returnCall();
|
|
}
|
|
|
|
break at:
|
|
function returnCall() {
|
|
#return return42();
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
function returnCall() {
|
|
return return42();#
|
|
}
|
|
|
|
break at:
|
|
function testCallAtReturn() {
|
|
return returnCall();#
|
|
}
|
|
|
|
|
|
Running test: testWith
|
|
break at:
|
|
function testWith() {
|
|
#with (returnObject()) {
|
|
foo();
|
|
|
|
break at:
|
|
function returnObject() {
|
|
#return ({ foo: () => 42 });
|
|
}
|
|
|
|
break at:
|
|
function returnObject() {
|
|
return ({ foo: () => 42 });#
|
|
}
|
|
|
|
break at:
|
|
with (returnObject()) {
|
|
#foo();
|
|
}
|
|
|
|
break at:
|
|
function returnObject() {
|
|
return ({ foo: () => #42 });
|
|
}
|
|
|
|
break at:
|
|
function returnObject() {
|
|
return ({ foo: () => 42# });
|
|
}
|
|
|
|
break at:
|
|
}
|
|
#with({}) {
|
|
return;
|
|
|
|
break at:
|
|
with({}) {
|
|
#return;
|
|
}
|
|
|
|
break at:
|
|
with({}) {
|
|
return;#
|
|
}
|
|
|
|
|
|
Running test: testForLoop
|
|
break at:
|
|
function testForLoop() {
|
|
for (var i = #0; i < 1; ++i) {}
|
|
for (var i = 0; i < 1; ++i) i;
|
|
|
|
break at:
|
|
function testForLoop() {
|
|
for (var i = 0; i #< 1; ++i) {}
|
|
for (var i = 0; i < 1; ++i) i;
|
|
|
|
break at:
|
|
function testForLoop() {
|
|
for (var i = 0; i < 1; ++#i) {}
|
|
for (var i = 0; i < 1; ++i) i;
|
|
|
|
break at:
|
|
function testForLoop() {
|
|
for (var i = 0; i #< 1; ++i) {}
|
|
for (var i = 0; i < 1; ++i) i;
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) {}
|
|
for (var i = #0; i < 1; ++i) i;
|
|
for (var i = 0; i < 0; ++i) {}
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) {}
|
|
for (var i = 0; i #< 1; ++i) i;
|
|
for (var i = 0; i < 0; ++i) {}
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) {}
|
|
for (var i = 0; i < 1; ++#i) i;
|
|
for (var i = 0; i < 0; ++i) {}
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) {}
|
|
for (var i = 0; i #< 1; ++i) i;
|
|
for (var i = 0; i < 0; ++i) {}
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) i;
|
|
for (var i = #0; i < 0; ++i) {}
|
|
}
|
|
|
|
break at:
|
|
for (var i = 0; i < 1; ++i) i;
|
|
for (var i = 0; i #< 0; ++i) {}
|
|
}
|
|
|
|
break at:
|
|
for (var i = 0; i < 0; ++i) {}
|
|
#}
|
|
|
|
|
|
|
|
Running test: testForOfLoop
|
|
break at:
|
|
function testForOfLoop() {
|
|
for (var k of #[]) {}
|
|
for (var k of [1]) k;
|
|
|
|
break at:
|
|
function testForOfLoop() {
|
|
for (var #k of []) {}
|
|
for (var k of [1]) k;
|
|
|
|
break at:
|
|
for (var k of []) {}
|
|
for (var k of #[1]) k;
|
|
var a = [];
|
|
|
|
break at:
|
|
for (var k of []) {}
|
|
for (var #k of [1]) k;
|
|
var a = [];
|
|
|
|
break at:
|
|
for (var k of []) {}
|
|
for (var k of [1]) #k;
|
|
var a = [];
|
|
|
|
break at:
|
|
for (var k of []) {}
|
|
for (var #k of [1]) k;
|
|
var a = [];
|
|
|
|
break at:
|
|
for (var k of [1]) k;
|
|
var a = #[];
|
|
for (var k of a) {}
|
|
|
|
break at:
|
|
var a = [];
|
|
for (var k of #a) {}
|
|
}
|
|
|
|
break at:
|
|
var a = [];
|
|
for (var #k of a) {}
|
|
}
|
|
|
|
break at:
|
|
for (var k of a) {}
|
|
#}
|
|
|
|
|
|
|
|
Running test: testForInLoop
|
|
break at:
|
|
function testForInLoop() {
|
|
var o = #{};
|
|
for (var k in o) {}
|
|
|
|
break at:
|
|
var o = {};
|
|
for (var k in #o) {}
|
|
for (var k in o) k;
|
|
|
|
break at:
|
|
var o = {};
|
|
for (var #k in o) {}
|
|
for (var k in o) k;
|
|
|
|
break at:
|
|
for (var k in o) {}
|
|
for (var k in #o) k;
|
|
for (var k in { a:1 }) {}
|
|
|
|
break at:
|
|
for (var k in o) {}
|
|
for (var #k in o) k;
|
|
for (var k in { a:1 }) {}
|
|
|
|
break at:
|
|
for (var k in o) k;
|
|
for (var k in #{ a:1 }) {}
|
|
for (var k in { a:1 }) k;
|
|
|
|
break at:
|
|
for (var k in o) k;
|
|
for (var #k in { a:1 }) {}
|
|
for (var k in { a:1 }) k;
|
|
|
|
break at:
|
|
for (var k in { a:1 }) {}
|
|
for (var k in #{ a:1 }) k;
|
|
}
|
|
|
|
break at:
|
|
for (var k in { a:1 }) {}
|
|
for (var #k in { a:1 }) k;
|
|
}
|
|
|
|
break at:
|
|
for (var k in { a:1 }) {}
|
|
for (var k in { a:1 }) #k;
|
|
}
|
|
|
|
break at:
|
|
for (var k in { a:1 }) {}
|
|
for (var #k in { a:1 }) k;
|
|
}
|
|
|
|
break at:
|
|
for (var k in { a:1 }) k;
|
|
#}
|
|
|
|
|
|
|
|
Running test: testSimpleExpressions
|
|
break at:
|
|
1 + 2 + 3;
|
|
var a = #1;
|
|
++a;
|
|
|
|
break at:
|
|
var a = 1;
|
|
#++a;
|
|
a--;
|
|
|
|
break at:
|
|
++a;
|
|
#a--;
|
|
}
|
|
|
|
break at:
|
|
a--;
|
|
#}
|
|
|
|
|
|
|
|
Running test: testGetter
|
|
break at:
|
|
function testGetter() {
|
|
#getterFoo();
|
|
}
|
|
|
|
break at:
|
|
Object.defineProperty(this, 'getterFoo', {
|
|
get: () => #return42
|
|
});
|
|
|
|
break at:
|
|
Object.defineProperty(this, 'getterFoo', {
|
|
get: () => return42#
|
|
});
|
|
|
|
break at:
|
|
function testGetter() {
|
|
#getterFoo();
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
getterFoo();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testChainedCalls
|
|
break at:
|
|
function testChainedCalls() {
|
|
#obj.foo().boo()();
|
|
}
|
|
|
|
break at:
|
|
var obj = {
|
|
foo: () => (#{
|
|
boo: () => return42
|
|
|
|
break at:
|
|
boo: () => return42
|
|
})#
|
|
};
|
|
|
|
break at:
|
|
function testChainedCalls() {
|
|
obj.foo().#boo()();
|
|
}
|
|
|
|
break at:
|
|
foo: () => ({
|
|
boo: () => #return42
|
|
})
|
|
|
|
break at:
|
|
foo: () => ({
|
|
boo: () => return42#
|
|
})
|
|
|
|
break at:
|
|
function testChainedCalls() {
|
|
obj.foo().boo()#();
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
obj.foo().boo()();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testChainedWithNative
|
|
break at:
|
|
function testChainedWithNative() {
|
|
#Array.from([1]).concat([2]).map(v => v * 2);
|
|
}
|
|
|
|
break at:
|
|
function testChainedWithNative() {
|
|
Array.from([1]).concat([2]).map(v => v #* 2);
|
|
}
|
|
|
|
break at:
|
|
function testChainedWithNative() {
|
|
Array.from([1]).concat([2]).map(v => v * 2#);
|
|
}
|
|
|
|
break at:
|
|
function testChainedWithNative() {
|
|
Array.from([1]).concat([2]).map(v => v #* 2);
|
|
}
|
|
|
|
break at:
|
|
function testChainedWithNative() {
|
|
Array.from([1]).concat([2]).map(v => v * 2#);
|
|
}
|
|
|
|
break at:
|
|
Array.from([1]).concat([2]).map(v => v * 2);
|
|
#}
|
|
|
|
|
|
|
|
Running test: testPromiseThen
|
|
break at:
|
|
function testPromiseThen() {
|
|
#return Promise.resolve().then(v => v * 2).then(v => v * 2);
|
|
}
|
|
|
|
break at:
|
|
function testPromiseThen() {
|
|
return Promise.resolve().then(v => v * 2).then(v => v * 2);#
|
|
}
|
|
|
|
|
|
Running test: testSwitch
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = #0; i < 3; ++i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = 0; i #< 3; ++i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
for (var i = 0; i < 3; ++i) {
|
|
#switch(i) {
|
|
case 0: continue;
|
|
|
|
break at:
|
|
switch(i) {
|
|
case 0: #continue;
|
|
case 1: return42(); break;
|
|
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = 0; i < 3; ++#i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = 0; i #< 3; ++i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
for (var i = 0; i < 3; ++i) {
|
|
#switch(i) {
|
|
case 0: continue;
|
|
|
|
break at:
|
|
case 0: continue;
|
|
case 1: #return42(); break;
|
|
default: return;
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
case 0: continue;
|
|
case 1: return42(); #break;
|
|
default: return;
|
|
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = 0; i < 3; ++#i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
function testSwitch() {
|
|
for (var i = 0; i #< 3; ++i) {
|
|
switch(i) {
|
|
|
|
break at:
|
|
for (var i = 0; i < 3; ++i) {
|
|
#switch(i) {
|
|
case 0: continue;
|
|
|
|
break at:
|
|
case 1: return42(); break;
|
|
default: #return;
|
|
}
|
|
|
|
break at:
|
|
case 1: return42(); break;
|
|
default: return;#
|
|
}
|
|
|
|
|
|
Running test: testGenerator
|
|
break at:
|
|
function testGenerator() {
|
|
var gen = #idMaker();
|
|
return42();
|
|
|
|
break at:
|
|
function* idMaker() {
|
|
#yield 1;
|
|
yield 2;
|
|
|
|
break at:
|
|
gen.next().value;
|
|
#debugger;
|
|
gen.next().value;
|
|
|
|
break at:
|
|
debugger;
|
|
gen.#next().value;
|
|
return42();
|
|
|
|
break at:
|
|
yield 1;
|
|
#yield 2;
|
|
yield 3;
|
|
|
|
break at:
|
|
yield 2;
|
|
#yield 3;
|
|
}
|
|
|
|
break at:
|
|
yield 3;
|
|
#}
|
|
|
|
|
|
break at:
|
|
gen.next().value;
|
|
#}
|
|
|
|
|
|
|
|
Running test: testCaughtException
|
|
break at:
|
|
try {
|
|
#throwException()
|
|
} catch (e) {
|
|
|
|
break at:
|
|
function throwException() {
|
|
#throw new Error();
|
|
}
|
|
|
|
break at:
|
|
} catch (e) {
|
|
#return;
|
|
}
|
|
|
|
break at:
|
|
} catch (e) {
|
|
return;#
|
|
}
|
|
|
|
|
|
Running test: testClasses
|
|
break at:
|
|
}
|
|
#new Lion().speak();
|
|
}
|
|
|
|
break at:
|
|
constructor(name) {
|
|
#super(name);
|
|
}
|
|
|
|
break at:
|
|
constructor(name) {
|
|
#this.name = name;
|
|
}
|
|
|
|
break at:
|
|
this.name = name;
|
|
#}
|
|
|
|
|
|
break at:
|
|
super(name);
|
|
#}
|
|
|
|
|
|
break at:
|
|
}
|
|
new Lion().#speak();
|
|
}
|
|
|
|
break at:
|
|
speak() {
|
|
#super.speak();
|
|
}
|
|
|
|
break at:
|
|
speak() {
|
|
#}
|
|
}
|
|
|
|
break at:
|
|
super.speak();
|
|
#}
|
|
}
|
|
|
|
break at:
|
|
new Lion().speak();
|
|
#}
|
|
|
|
|
|
|
|
Running test: testAsyncAwait
|
|
break at:
|
|
async function testAsyncAwait() {
|
|
#await asyncFoo();
|
|
await awaitBoo();
|
|
|
|
break at:
|
|
async function asyncFoo() {
|
|
#await Promise.resolve().then(v => v * 2);
|
|
return42();
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
async function asyncBoo() {
|
|
#await Promise.resolve();
|
|
}
|
|
|
|
|
|
Running test: testPromiseAsyncWithCode
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = #new Promise(resolve => nextTest = resolve);
|
|
async function main() {
|
|
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = new Promise(resolve => nextTest #= resolve);
|
|
async function main() {
|
|
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = new Promise(resolve => nextTest = resolve#);
|
|
async function main() {
|
|
|
|
break at:
|
|
}
|
|
#main();
|
|
return testPromise;
|
|
|
|
break at:
|
|
}
|
|
#setTimeout(returnCall, 0);
|
|
await foo();
|
|
|
|
break at:
|
|
setTimeout(returnCall, 0);
|
|
await #foo();
|
|
await foo();
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = #new Promise(resolve => resolveNested = resolve);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = new Promise(resolve => resolveNested #= resolve);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = new Promise(resolve => resolveNested = resolve#);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var p = new Promise(resolve => resolveNested = resolve);
|
|
#setTimeout(resolveNested, 0);
|
|
await p;
|
|
|
|
break at:
|
|
setTimeout(resolveNested, 0);
|
|
#await p;
|
|
}
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = #new Promise(resolve => resolveNested = resolve);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = new Promise(resolve => resolveNested #= resolve);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var resolveNested;
|
|
var p = new Promise(resolve => resolveNested = resolve#);
|
|
setTimeout(resolveNested, 0);
|
|
|
|
break at:
|
|
var p = new Promise(resolve => resolveNested = resolve);
|
|
#setTimeout(resolveNested, 0);
|
|
await p;
|
|
|
|
break at:
|
|
setTimeout(resolveNested, 0);
|
|
#await p;
|
|
}
|
|
|
|
|
|
Running test: testPromiseComplex
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = #new Promise(resolve => nextTest = resolve);
|
|
async function main() {
|
|
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = new Promise(resolve => nextTest #= resolve);
|
|
async function main() {
|
|
|
|
break at:
|
|
var nextTest;
|
|
var testPromise = new Promise(resolve => nextTest = resolve#);
|
|
async function main() {
|
|
|
|
break at:
|
|
}
|
|
#main();
|
|
return testPromise;
|
|
|
|
break at:
|
|
}
|
|
var x = #1;
|
|
var y = 2;
|
|
|
|
break at:
|
|
var x = 1;
|
|
var y = #2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
|
|
|
|
break at:
|
|
var y = 2;
|
|
#returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
|
|
function emptyFunction() {#}
|
|
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, #returnCall())().a = await foo((a => 2 *a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
function returnCall() {
|
|
#return return42();
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
#return 42;
|
|
}
|
|
|
|
break at:
|
|
function return42() {
|
|
return 42;#
|
|
}
|
|
|
|
break at:
|
|
function returnCall() {
|
|
return return42();#
|
|
}
|
|
|
|
break at:
|
|
var y = 2;
|
|
#returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
function returnFunction() {
|
|
#return returnObject;
|
|
}
|
|
|
|
break at:
|
|
function returnFunction() {
|
|
return returnObject;#
|
|
}
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())#().a = await foo((a => 2 *a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
function returnObject() {
|
|
#return ({ foo: () => 42 });
|
|
}
|
|
|
|
break at:
|
|
function returnObject() {
|
|
return ({ foo: () => 42 });#
|
|
}
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a)#(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 #*a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await foo((a => 2 *a#)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
var y = 2;
|
|
returnFunction(emptyFunction(), x++, --y, x => 2 * x, returnCall())().a = await #foo((a => 2 *a)(5));
|
|
nextTest();
|
|
|
|
break at:
|
|
async function foo() {
|
|
#await Promise.resolve();
|
|
return 42;
|
|
|