[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
Tests breakable locations in variable initializations.
|
|
|
|
|
|
|
|
Running test: testBreakLocations
|
|
|
|
|
|
|
|
Running test: testStepInto
|
|
|
|
|
|
|
|
function testFunction() {
|
|
|
|
var obj1 = |_|{a : 1};
|
|
|
|
var arr1 = |_|[1];
|
|
|
|
var promise = |_|Promise.|C|resolve(1).|C|then(x => x |_|* 2|R|).|C|then(x => x |_|/ 2|R|);
|
|
|
|
|_|Promise.|C|resolve(1).|C|then(x => x |_|* 2|R|).|C|then(x => x |_|/ 2|R|);
|
|
|
|
|_|promise = Promise.|C|resolve(1).|C|then(x => x |_|* 2|R|).|C|then(x => x |_|/ 2|R|);
|
|
|
|
var a = |_|1;
|
|
|
|
const x = |_|(a = 20);
|
|
|
|
var y = |_|(a = 100);
|
|
|
|
var z = |_|x + (a = 1) + (a = 2) + (a = 3) + |C|f();
|
|
|
|
function f() {
|
2019-01-09 13:21:06 +00:00
|
|
|
for (let { |_|x, |_|y } = |_|{ x: 0, y: 1 }; y |_|> 0; --|_|y) { let z = |_|x + y; }
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|R|}
|
2017-07-17 19:02:35 +00:00
|
|
|
var b = obj1.|_|a;
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|_|(async function asyncF() {
|
|
|
|
let r = |_|await Promise.|C|resolve(42);
|
[async] Improve async function handling.
This change introduces new intrinsics used to desugar async functions
in the Parser and the BytecodeGenerator, namely we introduce a new
%_AsyncFunctionEnter intrinsic that constructs the generator object
for the async function (and in the future will also create the outer
promise for the async function). This generator object is internal
and never escapes to user code, plus since async functions don't have
a "prototype" property, we can just a single map here instead of tracking
the prototype/initial_map on every async function. This saves one word
per async function plus one initial_map per async function that was
invoked at least once.
We also introduce two new intrinsics %_AsyncFunctionReject, which
rejects the outer promise with the caught exception, and another
%_AsyncFunctionResolve, which resolves the outer promise with the
right hand side of the `return` statement. These functions also perform
the DevTools part of the job (aka popping from the promise stack and
sending the debug event). This allows us to get rid of the implicit
try-finally from async functions completely; because the finally
block only called to the %AsyncFunctionPromiseRelease builtin, which
was used to inform DevTools.
In essence we now turn an async function like
```js
async function f(x) { return await bar(x); }
```
into something like this (in Parser and BytecodeGenerator respectively):
```
function f(x) {
.generator_object = %_AsyncFunctionEnter(.closure, this);
.promise = %AsyncFunctionCreatePromise();
try {
.tmp = await bar(x);
return %_AsyncFunctionResolve(.promise, .tmp);
} catch (e) {
return %_AsyncFunctionReject(.promise, e);
}
}
```
Overall the bytecode for async functions gets significantly shorter
already (and will get even shorter once we put the outer promise into
the async function generator object). For example the bytecode for a
simple async function
```js
async function f(x) { return await x; }
```
goes from 175 bytes to 110 bytes (a ~38% reduction in size), which
is in particular due to the simplification around the try-finally
removal.
Overall this seems to improve the doxbee-async-es2017-native test by
around 2-3%. On the test case mentioned in v8:8276 we go from
1124ms to 441ms, which corresponds to a 60% reduction in total
execution time!
Tbr: marja@chromium.org
Bug: v8:7253, v8:7522, v8:8276
Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel;luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Id29dc92de7490b387ff697860c900cee44c9a7a4
Reviewed-on: https://chromium-review.googlesource.com/c/1269041
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Reviewed-by: Maya Lekova <mslekova@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56502}
2018-10-10 05:54:39 +00:00
|
|
|
|_|return r;|R|
|
2021-04-30 04:54:17 +00:00
|
|
|
})|C|();
|
2017-07-14 17:50:09 +00:00
|
|
|
|_|return promise;|R|
|
|
|
|
}
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
|
|
|
|
|
|
|
|
testFunction (test.js:2:13)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function testFunction() {
|
|
|
|
var obj1 = #{a : 1};
|
|
|
|
var arr1 = [1];
|
|
|
|
|
|
|
|
testFunction (test.js:3:13)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var obj1 = {a : 1};
|
|
|
|
var arr1 = #[1];
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
testFunction (test.js:4:16)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var arr1 = [1];
|
|
|
|
var promise = #Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
testFunction (test.js:5:2)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
#Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
testFunction (test.js:6:2)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
#promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
var a = 1;
|
|
|
|
|
|
|
|
testFunction (test.js:7:10)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
var a = #1;
|
|
|
|
const x = (a = 20);
|
|
|
|
|
|
|
|
testFunction (test.js:8:12)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var a = 1;
|
|
|
|
const x = #(a = 20);
|
|
|
|
var y = (a = 100);
|
|
|
|
|
|
|
|
testFunction (test.js:9:10)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
const x = (a = 20);
|
|
|
|
var y = #(a = 100);
|
|
|
|
var z = x + (a = 1) + (a = 2) + (a = 3) + f();
|
|
|
|
|
|
|
|
testFunction (test.js:10:10)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var y = (a = 100);
|
|
|
|
var z = #x + (a = 1) + (a = 2) + (a = 3) + f();
|
|
|
|
function f() {
|
|
|
|
|
|
|
|
f (test.js:12:24)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = #{ x: 0, y: 1 }; y > 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
2019-01-09 13:21:06 +00:00
|
|
|
f (test.js:12:15)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { #x, y } = { x: 0, y: 1 }; y > 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
|
|
|
f (test.js:12:18)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, #y } = { x: 0, y: 1 }; y > 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
f (test.js:12:42)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = { x: 0, y: 1 }; y #> 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
|
|
|
f (test.js:12:62)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = { x: 0, y: 1 }; y > 0; --y) { let z = #x + y; }
|
|
|
|
}
|
|
|
|
|
|
|
|
f (test.js:12:49)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = { x: 0, y: 1 }; y > 0; --#y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
|
|
|
f (test.js:12:42)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = { x: 0, y: 1 }; y #> 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|
|
|
|
f (test.js:13:2)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
for (let { x, y } = { x: 0, y: 1 }; y > 0; --y) { let z = x + y; }
|
|
|
|
#}
|
|
|
|
var b = obj1.a;
|
|
|
|
|
2017-07-17 19:02:35 +00:00
|
|
|
testFunction (test.js:14:15)
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
}
|
2017-07-17 19:02:35 +00:00
|
|
|
var b = obj1.#a;
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
(async function asyncF() {
|
|
|
|
|
|
|
|
testFunction (test.js:15:2)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var b = obj1.a;
|
|
|
|
#(async function asyncF() {
|
|
|
|
let r = await Promise.resolve(42);
|
|
|
|
|
|
|
|
asyncF (test.js:16:12)
|
|
|
|
testFunction (test.js:18:4)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
(async function asyncF() {
|
|
|
|
let r = #await Promise.resolve(42);
|
|
|
|
return r;
|
|
|
|
|
|
|
|
asyncF (test.js:17:4)
|
|
|
|
let r = await Promise.resolve(42);
|
|
|
|
#return r;
|
|
|
|
})();
|
|
|
|
|
[async] Improve async function handling.
This change introduces new intrinsics used to desugar async functions
in the Parser and the BytecodeGenerator, namely we introduce a new
%_AsyncFunctionEnter intrinsic that constructs the generator object
for the async function (and in the future will also create the outer
promise for the async function). This generator object is internal
and never escapes to user code, plus since async functions don't have
a "prototype" property, we can just a single map here instead of tracking
the prototype/initial_map on every async function. This saves one word
per async function plus one initial_map per async function that was
invoked at least once.
We also introduce two new intrinsics %_AsyncFunctionReject, which
rejects the outer promise with the caught exception, and another
%_AsyncFunctionResolve, which resolves the outer promise with the
right hand side of the `return` statement. These functions also perform
the DevTools part of the job (aka popping from the promise stack and
sending the debug event). This allows us to get rid of the implicit
try-finally from async functions completely; because the finally
block only called to the %AsyncFunctionPromiseRelease builtin, which
was used to inform DevTools.
In essence we now turn an async function like
```js
async function f(x) { return await bar(x); }
```
into something like this (in Parser and BytecodeGenerator respectively):
```
function f(x) {
.generator_object = %_AsyncFunctionEnter(.closure, this);
.promise = %AsyncFunctionCreatePromise();
try {
.tmp = await bar(x);
return %_AsyncFunctionResolve(.promise, .tmp);
} catch (e) {
return %_AsyncFunctionReject(.promise, e);
}
}
```
Overall the bytecode for async functions gets significantly shorter
already (and will get even shorter once we put the outer promise into
the async function generator object). For example the bytecode for a
simple async function
```js
async function f(x) { return await x; }
```
goes from 175 bytes to 110 bytes (a ~38% reduction in size), which
is in particular due to the simplification around the try-finally
removal.
Overall this seems to improve the doxbee-async-es2017-native test by
around 2-3%. On the test case mentioned in v8:8276 we go from
1124ms to 441ms, which corresponds to a 60% reduction in total
execution time!
Tbr: marja@chromium.org
Bug: v8:7253, v8:7522, v8:8276
Cq-Include-Trybots: luci.chromium.try:linux_chromium_headless_rel;luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Id29dc92de7490b387ff697860c900cee44c9a7a4
Reviewed-on: https://chromium-review.googlesource.com/c/1269041
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org>
Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Reviewed-by: Maya Lekova <mslekova@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56502}
2018-10-10 05:54:39 +00:00
|
|
|
asyncF (test.js:17:13)
|
|
|
|
let r = await Promise.resolve(42);
|
|
|
|
return r;#
|
|
|
|
})();
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|
2019-01-11 15:22:21 +00:00
|
|
|
(anonymous) (test.js:4:64)
|
|
|
|
var arr1 = [1];
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x #/ 2);
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
(anonymous) (test.js:4:67)
|
|
|
|
var arr1 = [1];
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2#);
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
(anonymous) (test.js:5:50)
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x #/ 2);
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
(anonymous) (test.js:5:53)
|
|
|
|
var promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2#);
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
|
|
|
|
(anonymous) (test.js:6:60)
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x #/ 2);
|
|
|
|
var a = 1;
|
|
|
|
|
|
|
|
(anonymous) (test.js:6:63)
|
|
|
|
Promise.resolve(1).then(x => x * 2).then(x => x / 2);
|
|
|
|
promise = Promise.resolve(1).then(x => x * 2).then(x => x / 2#);
|
|
|
|
var a = 1;
|
|
|
|
|
[inspector] moved var initialization break location before init expression (reland)
This CL improves break locations for expressions like 'var a = <expr>'. Without CL we use <expr> position as break location for initialization statement, with this CL we use position of first character after '=' as position.
Benefits (see test for details):
- only one break in expressions which includes mix of property lookup and calls, e.g. var p = Promise.resolve().then(x => x * 2),
- removed redundant break location for expressions like: let { x, y } = { x: 1, y: 2}.
TBR=dgozman@chromium.org,rmcilroy@chromium.org,machenbach@chromium.org,marja@chromium.org,kozyatinskiy@chromium.org,devtools-reviews@chromium.org,v8-reviews@googlegroups.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: v8:5909
Change-Id: Ie84fa79afeed09e28cf8478ba610a0cfbfdfc294
Reviewed-on: https://chromium-review.googlesource.com/518116
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#45598}
2017-05-30 12:25:55 +00:00
|
|
|
|
|
|
|
Running test: testStepIntoAfterBreakpoint
|
|
|
|
testFunction (test.js:10:10)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
var y = (a = 100);
|
|
|
|
var z = #x + (a = 1) + (a = 2) + (a = 3) + f();
|
|
|
|
function f() {
|
|
|
|
|
|
|
|
f (test.js:12:24)
|
|
|
|
testFunction (test.js:10:44)
|
|
|
|
(anonymous) (expr.js:0:0)
|
|
|
|
function f() {
|
|
|
|
for (let { x, y } = #{ x: 0, y: 1 }; y > 0; --y) { let z = x + y; }
|
|
|
|
}
|
|
|
|
|