[inspector] introduced stepIntoAsync for chained callbacks

test/inspector/debugger/async-step-into-for-promise-expected.txt

Index: test/inspector/debugger/async-step-into-for-promise-expected.txt
diff --git a/test/inspector/debugger/async-step-into-for-promise-expected.txt b/test/inspector/debugger/async-step-into-for-promise-expected.txt
new file mode 100644
index 0000000000000000000000000000000000000000..532a0e69b60f66a9ec79a6567934e4e5fa99a546
--- /dev/null
+++ b/test/inspector/debugger/async-step-into-for-promise-expected.txt
@@ -0,0 +1,237 @@
+Checks Protocol.Debugger.stepIntoAsync() for promises
+
+Running test: testPromiseThen

[kozy, 2017/01/27 20:54:58]

function promiseThen() {
  var resolve1;
  var p1 = new Promise(resolve => resolve1 = resolve);
  debugger;
  var p2 = p1.then(foo1);
  resolve1();
  return p2
}

- first debugger breaks at debugger statement,
- after step-in debugger breaks after "p1" and before dot in next line,
- after step-in debugger breaks at the same position because of
asyncTaskCreated.

Looks like second break happens because of assignment: var p1 = .., locations of
this break looks confusing to me, it should be in between of "=" and "p1".

With additional information about "function to be called" in v8::Break event we
can automatically do additional step-in on second break and show user only first
and third one when function is Promise.then..

[Yang, 2017/01/30 20:04:32]

I think this is expected. The reason is that we break at statement positions,
calls and returns. The assignment happens after the call to .then. However, I
think there is some weirdness because of variable declaration "var p1", and the
assignment immediately after.

+reason: other
+promiseThen (test.js:17:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThen (test.js:18:14)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseThen (test.js:18:14)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+reason: other
+foo1 (test.js:8:13)
+-- Promise.resolve (test.js:18:14)--
+promiseThen (test.js:19:2)
+(anonymous) (expr.js:0:0)
+executing resume
+
+
+Running test: testPromiseThenWithoutAssignment

[kozy, 2017/01/27 20:54:58]

function promiseThenWithoutAssignment() {
  var nextTest;
  var testPromise = new Promise(resolve => nextTest = resolve);

  var resolve1;
  var p1 = new Promise(resolve => resolve1 = resolve);
  debugger;
  p1.then(foo1).then(nextTest);
  resolve1();
  return testPromise;
}

- first debugger breaks at debugger stmt;
- second time at begin of next line;
- third time before .then call because of asyncTaskCreated;

Here we could not automatically skip one step in between but we don't really
want to skip it because it happens before "calculating" p1 variable.

[Yang, 2017/01/30 20:04:32]

Let's not skip. We are stopping before the statement.

+reason: other
+promiseThenWithoutAssignment (test.js:29:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThenWithoutAssignment (test.js:30:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseThenWithoutAssignment (test.js:30:5)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+reason: other
+foo1 (test.js:8:13)
+-- Promise.resolve (test.js:30:5)--
+promiseThenWithoutAssignment (test.js:31:2)
+(anonymous) (expr.js:0:0)
+executing resume
+
+
+Running test: testPromiseAll

[kozy, 2017/01/27 20:54:58]

This test case highlight one more issue.

function promiseAll() {
  var resolve1;
  var resolve2;
  var p1 = new Promise(resolve => resolve1 = resolve);
  var p2 = new Promise(resolve => resolve2 = resolve);
  debugger;
  var p3 = Promise.all([ p1, p2 ]).then(foo1);
  resolve1();
  resolve2();
  return p3;
}

- first break at debugger stmt;
- second break right after "Promise.all([ p1, p2 ])" looks weird and I think we
continue incorrectly calculate assignment location;
- third break at dot after "Promise", before all call,
- two following asyncTaskCreated breaks are related to instrumentation which
called for internal promises inside Promise.all implementation, we shouldn't
send async instrumentation for them.
- one more break after "Promise.all([ p1, p2 ])." before actual "then" call, we
could skip this break in the way described before. I think here we break before
.then call because Promise.all is regular JS function declared in promise.js.
- break on asyncTaskCreated - good one.

[Yang, 2017/01/30 20:04:32]

These issues seem to be unrelated to async stepping, but rather related to
assignment and function calls. Can you file a bug with a small repro so that I
can take a look?

+reason: other
+promiseAll (test.js:40:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:35)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:19)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAll (test.js:41:19)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAll (test.js:41:19)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:35)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAll (test.js:41:35)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+reason: other
+foo1 (test.js:8:13)
+-- Promise.resolve (test.js:41:35)--
+-- Promise.resolve (test.js:41:19)--
+promiseAll (test.js:43:2)
+(anonymous) (expr.js:0:0)
+executing resume
+
+
+Running test: testPromiseAllWithoutAssignment

[kozy, 2017/01/27 20:54:58]

function promiseAllWithoutAssignment() {
  var nextTest;
  var testPromise = new Promise(resolve => nextTest = resolve);

  var resolve1;
  var resolve2;
  var p1 = new Promise(resolve => resolve1 = resolve);
  var p2 = new Promise(resolve => resolve2 = resolve);

  debugger;
  Promise.all([ p1, p2 ]).then(foo1).then(nextTest);
  resolve1();
  resolve2();
  return testPromise;
}

WIthout assignment we breaks:
- at debugger statement;
- at the begin of next line;
- on two internal asyncTaskCreated instrumentation call;
- on real asyncTaskCreated instrumentation call.

Here we don't break before .then call after Promise.all without asyncTaskCreated
instrumentation. By module of two internal asyncTaskCreated instrumentation
works perfect.

+reason: other
+promiseAllWithoutAssignment (test.js:56:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAllWithoutAssignment (test.js:57:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAllWithoutAssignment (test.js:57:10)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAllWithoutAssignment (test.js:57:10)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: callbackScheduled
+promiseAllWithoutAssignment (test.js:57:26)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+reason: other
+foo1 (test.js:8:13)
+-- Promise.resolve (test.js:57:26)--
+-- Promise.resolve (test.js:57:10)--
+promiseAllWithoutAssignment (test.js:59:2)
+(anonymous) (expr.js:0:0)
+executing resume
+
+
+Running test: switchAsyncOff
+
+Running test: testPromiseThen

[kozy, 2017/01/27 20:54:58]

FYI: following test expectations show current step-int behavior with promises
and assignments.

+reason: other
+promiseThen (test.js:17:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThen (test.js:18:14)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThen (test.js:19:2)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+{
+    error : {
+        code : -32000
+        message : No scheduled chained callback
+    }
+    id : <messageId>
+}
+
+Running test: testPromiseThenWithoutAssignment
+reason: other
+promiseThenWithoutAssignment (test.js:29:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThenWithoutAssignment (test.js:30:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseThenWithoutAssignment (test.js:31:2)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+{
+    error : {
+        code : -32000
+        message : No scheduled chained callback
+    }
+    id : <messageId>
+}
+
+Running test: testPromiseAll
+reason: other
+promiseAll (test.js:40:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:35)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:19)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:41:35)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAll (test.js:42:2)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+{
+    error : {
+        code : -32000
+        message : No scheduled chained callback
+    }
+    id : <messageId>
+}
+
+Running test: testPromiseAllWithoutAssignment
+reason: other
+promiseAllWithoutAssignment (test.js:56:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAllWithoutAssignment (test.js:57:2)
+(anonymous) (expr.js:0:0)
+executing stepInto
+
+reason: other
+promiseAllWithoutAssignment (test.js:58:2)
+(anonymous) (expr.js:0:0)
+executing stepIntoAsync
+
+{
+    error : {
+        code : -32000
+        message : No scheduled chained callback
+    }
+    id : <messageId>
+}