AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
a0206daa78
v8/test/inspector/debugger/step-into-expected.txt
Alexey Kozyatinskiy 0b690227f8 Reland "[inspector] fixed location of top level function return" 
This is a reland of 4363a69335

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

Bug: v8:7858
Change-Id: Ie636bc101f9d29d9d40bd10b96e62da6505c2734
Reviewed-on: https://chromium-review.googlesource.com/1104497
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53808}
2018-06-18 21:37:49 +00:00

1025 lines
14 KiB
Plaintext
Raw Blame History

Checks possible break locations.
Running test: testEval
break at:
function testEval() {
#eval('// comment only');
eval('// comment only\n');
break at:
// comment only#
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;
Reference in New Issue View Git Blame Copy Permalink