[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
Stepping with natives and frameworks.
|
|
|
|
|
|
|
|
|
|
Running test: testNativeCodeStepOut
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#[1,2].map(v => v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => #v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
[1,2].map(v => v);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testNativeCodeStepOver
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#[1,2].map(v => v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => #v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
[1,2].map(v => v#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
[1,2].map(v => #v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
[1,2].map(v => v#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
[1,2].map(v => v);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testNativeCodeStepInto
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#[1,2].map(v => v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => #v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => v#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => #v);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
[1,2].map(v => v#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
2018-06-12 21:57:52 +00:00
|
|
|
[1,2].map(v => v);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCodeStepInto
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => 1#, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => 1, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => 1, () => 2#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCodeStepOver
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1#, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, () => 2#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCodeStepOut
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
|
|
|
|
callAll(() => 1, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkNextCallDeeperStepOut
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
|
|
|
|
callAll(() => 1, callAll.bind(null, () => #2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, callAll.bind(null, () => 2));#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkNextCallDeeperStepOutSameFunction
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(foo, callAll.bind(null, foo));
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(foo, callAll.bind(null, foo));#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkNextCallDeeperStepInto
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1#, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, callAll.bind(null, () => #2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, callAll.bind(null, () => 2#));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, callAll.bind(null, () => 2));#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkNextCallDeeperStepOver
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(() => 1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(() => #1, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1#, callAll.bind(null, () => 2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, callAll.bind(null, () => #2));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(() => 1, callAll.bind(null, () => 2#));
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(() => 1, callAll.bind(null, () => 2));#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCurrentCallDeeperStepOut
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(callAll.bind(null, () => 1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => #1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
|
|
|
|
callAll(callAll.bind(null, () => 1), () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(callAll.bind(null, () => 1), () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCurrentCallDeeperStepOutSameFunction
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(callAll.bind(null, foo), foo);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(callAll.bind(null, foo), foo);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCurrentCallDeeperStepOver
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(callAll.bind(null, () => 1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => #1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(callAll.bind(null, () => 1#), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(callAll.bind(null, () => 1), () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(callAll.bind(null, () => 1), () => 2#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(callAll.bind(null, () => 1), () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkCurrentCallDeeperStepInto
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(callAll.bind(null, () => 1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => #1), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => 1#), () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => 1), () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
callAll(callAll.bind(null, () => 1), () => 2#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(callAll.bind(null, () => 1), () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkStepOverMixed
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(foo, foo, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
foo = () => 1#
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
foo = () => 1#
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(foo, foo, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
callAll(foo, foo, () => 2#);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(foo, foo, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testFrameworkStepOutMixed
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(foo, foo, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
|
|
|
|
callAll(foo, foo, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(foo, foo, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|
|
|
|
|
|
|
|
|
|
Running test: testStepOutFrameworkSameFunctionAtReturn
|
|
|
|
|
Debugger.pause called
|
|
|
|
|
#callAll(foo, foo, () => 2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepInto called
|
|
|
|
|
foo = () => #1
|
|
|
|
|
|
|
|
|
|
Debugger.stepOver called
|
|
|
|
|
foo = () => 1#
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
|
|
|
|
callAll(foo, foo, () => #2);
|
|
|
|
|
|
|
|
|
|
Debugger.stepOut called
|
2018-06-12 21:57:52 +00:00
|
|
|
callAll(foo, foo, () => 2);#
|
[debugger] tuned StepNext and StepOut at return position
Proposed behaviour:
- StepNext at return position go into next function call (no changes with current behavior, but implemented in v8::Debug instead of hack on inspector side);
- StepOut at return position go into next non-current function call.
We need this to have better stepping in cases with native functions, blackboxed functions and/or different embedder calls (e.g. event listeners).
New behavior could be illustrated with two examples (for more see stepping-with-natives-and-frameworks test):
- let's assume that we've blackboxed callAll function, this function just takes its arguments and call one after another:
var foo = () => 1;
callAll(foo, foo, () => 2);
If we break inside of first call of function foo. Then on..
..StepNext - we're able to reach second call of function foo,
..StepOut - we're able to reach () => 2 call.
- let's consider case with native function:
[1,2,3].map(x => x * 2)
If we break inside of first callback call, then with StepNext we can iterate through all calls of callback, with StepOut we go to next statement after .map call.
Implementation details:
- when we request break we schedule step-in function call for any step action at return position and for step-in at any position,
- when we request StepOut at return position - we mark current function as needed-to-be-ignored inside of PrepareStepIn(function) call,
- when we request StepOut at not return position - we set break at return position and ask debugger to just repeat last step action on next stepping-related break.
Design doc: https://docs.google.com/document/d/1ihXHOIhP_q-fJCA0e2EiXz_Zr3B08KMjaPifcaqZ60Q/edit
BUG=v8:6118,chromium:583193
R=dgozman@chromium.org,yangguo@chromium.org
Review-Url: https://codereview.chromium.org/2758483002
Cr-Commit-Position: refs/heads/master@{#44028}
2017-03-22 14:16:18 +00:00
|
|
|
|
|
|
|
|
Debugger.resume called
|