From 8bba55aed4d3345f69aa3a4da286b66d6130e077 Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Thu, 5 Dec 2019 14:41:49 +0100
Subject: [PATCH] repl: support previews by eager evaluating input

This adds input previews by using the inspectors eager evaluation
functionality.
It is implemented as additional line that is not counted towards
the actual input. In case no colors are supported, it will be visible
as comment. Otherwise it's grey.
It will be triggered on any line change. It is heavily tested against
edge cases and adheres to "dumb" terminals (previews are deactived
in that case).

Fixes: https://github.com/nodejs/node/issues/20977
---
 doc/api/repl.md                               |   6 +
 lib/internal/repl/utils.js                    | 169 +++++++++++++++++-
 lib/repl.js                                   |  18 +-
 test/parallel/test-repl-history-navigation.js |  28 ++-
 test/parallel/test-repl-multiline.js          |  62 ++++---
 test/parallel/test-repl-preview.js            | 131 ++++++++++++++
 test/parallel/test-repl-top-level-await.js    | 101 +++++++----
 7 files changed, 444 insertions(+), 71 deletions(-)
 create mode 100644 test/parallel/test-repl-preview.js

diff --git a/doc/api/repl.md b/doc/api/repl.md
index 967336710ce3a1..e853086cb21a8a 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -510,6 +510,10 @@ with REPL instances programmatically.
 <!-- YAML
 added: v0.1.91
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/30811
+    description: The `preview` option is available from now on. The input
+                 generates output previews from now on.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/26518
     description: The `terminal` option now follows the default description in
@@ -562,6 +566,8 @@ changes:
   * `breakEvalOnSigint` {boolean} Stop evaluating the current piece of code when
     `SIGINT` is received, such as when `Ctrl+C` is pressed. This cannot be used
     together with a custom `eval` function. **Default:** `false`.
+  * `preview` {boolean} Defines if the repl prints output previews or not.
+     **Default:** `true`. Always `false` in case `terminal` is falsy.
 * Returns: {repl.REPLServer}
 
 The `repl.start()` method creates and starts a [`repl.REPLServer`][] instance.
diff --git a/lib/internal/repl/utils.js b/lib/internal/repl/utils.js
index 6c011e8533f8c3..b03ad6f48df057 100644
--- a/lib/internal/repl/utils.js
+++ b/lib/internal/repl/utils.js
@@ -4,7 +4,10 @@ const {
   Symbol,
 } = primordials;
 
-const acorn = require('internal/deps/acorn/acorn/dist/acorn');
+const { MathMin } = primordials;
+
+const { tokTypes: tt, Parser: AcornParser } =
+  require('internal/deps/acorn/acorn/dist/acorn');
 const privateMethods =
   require('internal/deps/acorn-plugins/acorn-private-methods/index');
 const classFields =
@@ -13,7 +16,30 @@ const numericSeparator =
   require('internal/deps/acorn-plugins/acorn-numeric-separator/index');
 const staticClassFeatures =
   require('internal/deps/acorn-plugins/acorn-static-class-features/index');
-const { tokTypes: tt, Parser: AcornParser } = acorn;
+
+const { sendInspectorCommand } = require('internal/util/inspector');
+
+const {
+  ERR_INSPECTOR_NOT_AVAILABLE
+} = require('internal/errors').codes;
+
+const {
+  clearLine,
+  cursorTo,
+  moveCursor,
+} = require('readline');
+
+const { inspect } = require('util');
+
+const debug = require('internal/util/debuglog').debuglog('repl');
+
+const inspectOptions = {
+  depth: 1,
+  colors: false,
+  compact: true,
+  breakLength: Infinity
+};
+const inspectedOptions = inspect(inspectOptions, { colors: false });
 
 // If the error is that we've unexpectedly ended the input,
 // then let the user try to recover by adding more input.
@@ -91,7 +117,144 @@ function isRecoverableError(e, code) {
   }
 }
 
+function setupPreview(repl, contextSymbol, bufferSymbol, active) {
+  // Simple terminals can't handle previews.
+  if (process.env.TERM === 'dumb' || !active) {
+    return { showInputPreview() {}, clearPreview() {} };
+  }
+
+  let preview = null;
+  let lastPreview = '';
+
+  const clearPreview = () => {
+    if (preview !== null) {
+      moveCursor(repl.output, 0, 1);
+      clearLine(repl.output);
+      moveCursor(repl.output, 0, -1);
+      lastPreview = preview;
+      preview = null;
+    }
+  };
+
+  // This returns a code preview for arbitrary input code.
+  function getPreviewInput(input, callback) {
+    // For similar reasons as `defaultEval`, wrap expressions starting with a
+    // curly brace with parenthesis.
+    if (input.startsWith('{') && !input.endsWith(';')) {
+      input = `(${input})`;
+    }
+    sendInspectorCommand((session) => {
+      session.post('Runtime.evaluate', {
+        expression: input,
+        throwOnSideEffect: true,
+        timeout: 333,
+        contextId: repl[contextSymbol],
+      }, (error, preview) => {
+        if (error) {
+          callback(error);
+          return;
+        }
+        const { result } = preview;
+        if (result.value !== undefined) {
+          callback(null, inspect(result.value, inspectOptions));
+        // Ignore EvalErrors, SyntaxErrors and ReferenceErrors. It is not clear
+        // where they came from and if they are recoverable or not. Other errors
+        // may be inspected.
+        } else if (preview.exceptionDetails &&
+                   (result.className === 'EvalError' ||
+                     result.className === 'SyntaxError' ||
+                     result.className === 'ReferenceError')) {
+          callback(null, null);
+        } else if (result.objectId) {
+          session.post('Runtime.callFunctionOn', {
+            functionDeclaration: `(v) => util.inspect(v, ${inspectedOptions})`,
+            objectId: result.objectId,
+            arguments: [result]
+          }, (error, preview) => {
+            if (error) {
+              callback(error);
+            } else {
+              callback(null, preview.result.value);
+            }
+          });
+        } else {
+          // Either not serializable or undefined.
+          callback(null, result.unserializableValue || result.type);
+        }
+      });
+    }, () => callback(new ERR_INSPECTOR_NOT_AVAILABLE()));
+  }
+
+  const showInputPreview = () => {
+    // Prevent duplicated previews after a refresh.
+    if (preview !== null) {
+      return;
+    }
+
+    const line = repl.line.trim();
+
+    // Do not preview if the command is buffered or if the line is empty.
+    if (repl[bufferSymbol] || line === '') {
+      return;
+    }
+
+    getPreviewInput(line, (error, inspected) => {
+      // Ignore the output if the value is identical to the current line and the
+      // former preview is not identical to this preview.
+      if ((line === inspected && lastPreview !== inspected) ||
+          inspected === null) {
+        return;
+      }
+      if (error) {
+        debug('Error while generating preview', error);
+        return;
+      }
+      // Do not preview `undefined` if colors are deactivated or explicitly
+      // requested.
+      if (inspected === 'undefined' &&
+          (!repl.useColors || repl.ignoreUndefined)) {
+        return;
+      }
+
+      preview = inspected;
+
+      // Limit the output to maximum 250 characters. Otherwise it becomes a)
+      // difficult to read and b) non terminal REPLs would visualize the whole
+      // output.
+      const maxColumns = MathMin(repl.columns, 250);
+
+      if (inspected.length > maxColumns) {
+        inspected = `${inspected.slice(0, maxColumns - 6)}...`;
+      }
+      const lineBreakPos = inspected.indexOf('\n');
+      if (lineBreakPos !== -1) {
+        inspected = `${inspected.slice(0, lineBreakPos)}`;
+      }
+      const result = repl.useColors ?
+        `\u001b[90m${inspected}\u001b[39m` :
+        `// ${inspected}`;
+
+      repl.output.write(`\n${result}`);
+      moveCursor(repl.output, 0, -1);
+      cursorTo(repl.output, repl.cursor + repl._prompt.length);
+    });
+  };
+
+  // Refresh prints the whole screen again and the preview will be removed
+  // during that procedure. Print the preview again. This also makes sure
+  // the preview is always correct after resizing the terminal window.
+  const tmpRefresh = repl._refreshLine.bind(repl);
+  repl._refreshLine = () => {
+    preview = null;
+    tmpRefresh();
+    showInputPreview();
+  };
+
+  return { showInputPreview, clearPreview };
+}
+
 module.exports = {
   isRecoverableError,
-  kStandaloneREPL: Symbol('kStandaloneREPL')
+  kStandaloneREPL: Symbol('kStandaloneREPL'),
+  setupPreview
 };
diff --git a/lib/repl.js b/lib/repl.js
index b6876bb8c6013c..98b0d2415d4f70 100644
--- a/lib/repl.js
+++ b/lib/repl.js
@@ -98,7 +98,8 @@ const experimentalREPLAwait = require('internal/options').getOptionValue(
 );
 const {
   isRecoverableError,
-  kStandaloneREPL
+  kStandaloneREPL,
+  setupPreview,
 } = require('internal/repl/utils');
 const {
   getOwnNonIndexProperties,
@@ -204,6 +205,9 @@ function REPLServer(prompt,
     }
   }
 
+  const preview = options.terminal &&
+    (options.preview !== undefined ? !!options.preview : true);
+
   this.inputStream = options.input;
   this.outputStream = options.output;
   this.useColors = !!options.useColors;
@@ -804,9 +808,20 @@ function REPLServer(prompt,
     }
   });
 
+  const {
+    clearPreview,
+    showInputPreview
+  } = setupPreview(
+    this,
+    kContextId,
+    kBufferedCommandSymbol,
+    preview
+  );
+
   // Wrap readline tty to enable editor mode and pausing.
   const ttyWrite = self._ttyWrite.bind(self);
   self._ttyWrite = (d, key) => {
+    clearPreview();
     key = key || {};
     if (paused && !(self.breakEvalOnSigint && key.ctrl && key.name === 'c')) {
       pausedBuffer.push(['key', [d, key]]);
@@ -819,6 +834,7 @@ function REPLServer(prompt,
         self.clearLine();
       }
       ttyWrite(d, key);
+      showInputPreview();
       return;
     }
 
diff --git a/test/parallel/test-repl-history-navigation.js b/test/parallel/test-repl-history-navigation.js
index b00f932aa9a253..3bd198880fc015 100644
--- a/test/parallel/test-repl-history-navigation.js
+++ b/test/parallel/test-repl-history-navigation.js
@@ -46,28 +46,50 @@ ActionStream.prototype.readable = true;
 const ENTER = { name: 'enter' };
 const UP = { name: 'up' };
 const DOWN = { name: 'down' };
+const LEFT = { name: 'left' };
+const DELETE = { name: 'delete' };
 
 const prompt = '> ';
 
+const prev = process.features.inspector;
+
 const tests = [
   { // Creates few history to navigate for
     env: { NODE_REPL_HISTORY: defaultHistoryPath },
     test: [ 'let ab = 45', ENTER,
             '555 + 909', ENTER,
-            '{key : {key2 :[] }}', ENTER],
+            '{key : {key2 :[] }}', ENTER,
+            'Array(100).fill(1).map((e, i) => i ** i)', LEFT, LEFT, DELETE,
+            '2', ENTER],
     expected: [],
     clean: false
   },
   {
     env: { NODE_REPL_HISTORY: defaultHistoryPath },
-    test: [UP, UP, UP, UP, DOWN, DOWN, DOWN],
+    test: [UP, UP, UP, UP, UP, DOWN, DOWN, DOWN, DOWN],
     expected: [prompt,
+               `${prompt}Array(100).fill(1).map((e, i) => i ** 2)`,
+               prev && '\n// [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, ' +
+                 '144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529,' +
+                 ' 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, ' +
+                 '1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936,' +
+                 ' 2025, 2116, 2209, ...',
                `${prompt}{key : {key2 :[] }}`,
+               prev && '\n// { key: { key2: [] } }',
                `${prompt}555 + 909`,
+               prev && '\n// 1464',
                `${prompt}let ab = 45`,
                `${prompt}555 + 909`,
+               prev && '\n// 1464',
                `${prompt}{key : {key2 :[] }}`,
-               prompt],
+               prev && '\n// { key: { key2: [] } }',
+               `${prompt}Array(100).fill(1).map((e, i) => i ** 2)`,
+               prev && '\n// [ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, ' +
+                 '144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529,' +
+                 ' 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, ' +
+                 '1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936,' +
+                 ' 2025, 2116, 2209, ...',
+               prompt].filter((e) => typeof e === 'string'),
     clean: true
   }
 ];
diff --git a/test/parallel/test-repl-multiline.js b/test/parallel/test-repl-multiline.js
index 454d5b10192fa5..6498923b62ecfc 100644
--- a/test/parallel/test-repl-multiline.js
+++ b/test/parallel/test-repl-multiline.js
@@ -3,34 +3,44 @@ const common = require('../common');
 const ArrayStream = require('../common/arraystream');
 const assert = require('assert');
 const repl = require('repl');
-const inputStream = new ArrayStream();
-const outputStream = new ArrayStream();
-const input = ['const foo = {', '};', 'foo;'];
-let output = '';
+const input = ['const foo = {', '};', 'foo'];
 
-outputStream.write = (data) => { output += data.replace('\r', ''); };
+function run({ useColors }) {
+  const inputStream = new ArrayStream();
+  const outputStream = new ArrayStream();
+  let output = '';
 
-const r = repl.start({
-  prompt: '',
-  input: inputStream,
-  output: outputStream,
-  terminal: true,
-  useColors: false
-});
+  outputStream.write = (data) => { output += data.replace('\r', ''); };
 
-r.on('exit', common.mustCall(() => {
-  const actual = output.split('\n');
+  const r = repl.start({
+    prompt: '',
+    input: inputStream,
+    output: outputStream,
+    terminal: true,
+    useColors
+  });
 
-  // Validate the output, which contains terminal escape codes.
-  assert.strictEqual(actual.length, 6);
-  assert.ok(actual[0].endsWith(input[0]));
-  assert.ok(actual[1].includes('... '));
-  assert.ok(actual[1].endsWith(input[1]));
-  assert.strictEqual(actual[2], 'undefined');
-  assert.ok(actual[3].endsWith(input[2]));
-  assert.strictEqual(actual[4], '{}');
-  // Ignore the last line, which is nothing but escape codes.
-}));
+  r.on('exit', common.mustCall(() => {
+    const actual = output.split('\n');
 
-inputStream.run(input);
-r.close();
+    // Validate the output, which contains terminal escape codes.
+    assert.strictEqual(actual.length, 6 + process.features.inspector);
+    assert.ok(actual[0].endsWith(input[0]));
+    assert.ok(actual[1].includes('... '));
+    assert.ok(actual[1].endsWith(input[1]));
+    assert.ok(actual[2].includes('undefined'));
+    assert.ok(actual[3].endsWith(input[2]));
+    if (process.features.inspector) {
+      assert.ok(actual[4].includes(actual[5]));
+      assert.strictEqual(actual[4].includes('//'), !useColors);
+    }
+    assert.strictEqual(actual[4 + process.features.inspector], '{}');
+    // Ignore the last line, which is nothing but escape codes.
+  }));
+
+  inputStream.run(input);
+  r.close();
+}
+
+run({ useColors: true });
+run({ useColors: false });
diff --git a/test/parallel/test-repl-preview.js b/test/parallel/test-repl-preview.js
new file mode 100644
index 00000000000000..92e73dd245056f
--- /dev/null
+++ b/test/parallel/test-repl-preview.js
@@ -0,0 +1,131 @@
+'use strict';
+
+const common = require('../common');
+const ArrayStream = require('../common/arraystream');
+const assert = require('assert');
+const Repl = require('repl');
+
+common.skipIfInspectorDisabled();
+
+const PROMPT = 'repl > ';
+
+class REPLStream extends ArrayStream {
+  constructor() {
+    super();
+    this.lines = [''];
+  }
+  write(chunk) {
+    const chunkLines = chunk.toString('utf8').split('\n');
+    this.lines[this.lines.length - 1] += chunkLines[0];
+    if (chunkLines.length > 1) {
+      this.lines.push(...chunkLines.slice(1));
+    }
+    this.emit('line');
+    return true;
+  }
+  wait() {
+    this.lines = [''];
+    return new Promise((resolve, reject) => {
+      const onError = (err) => {
+        this.removeListener('line', onLine);
+        reject(err);
+      };
+      const onLine = () => {
+        if (this.lines[this.lines.length - 1].includes(PROMPT)) {
+          this.removeListener('error', onError);
+          this.removeListener('line', onLine);
+          resolve(this.lines);
+        }
+      };
+      this.once('error', onError);
+      this.on('line', onLine);
+    });
+  }
+}
+
+function runAndWait(cmds, repl) {
+  const promise = repl.inputStream.wait();
+  for (const cmd of cmds) {
+    repl.inputStream.run([cmd]);
+  }
+  return promise;
+}
+
+async function tests(options) {
+  const repl = Repl.start({
+    prompt: PROMPT,
+    stream: new REPLStream(),
+    ignoreUndefined: true,
+    useColors: true,
+    ...options
+  });
+
+  repl.inputStream.run([
+    'function foo(x) { return x; }',
+    'function koo() { console.log("abc"); }',
+    'a = undefined;'
+  ]);
+  const testCases = [
+    ['foo', [2, 4], '[Function: foo]',
+     'foo',
+     '\x1B[90m[Function: foo]\x1B[39m\x1B[1A\x1B[11G\x1B[1B\x1B[2K\x1B[1A\r',
+     '\x1B[36m[Function: foo]\x1B[39m',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G'],
+    ['koo', [2, 4], '[Function: koo]',
+     'koo',
+     '\x1B[90m[Function: koo]\x1B[39m\x1B[1A\x1B[11G\x1B[1B\x1B[2K\x1B[1A\r',
+     '\x1B[36m[Function: koo]\x1B[39m',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G'],
+    ['a', [1, 2], undefined],
+    ['{ a: true }', [2, 3], '{ a: \x1B[33mtrue\x1B[39m }',
+     '{ a: true }\r',
+     '{ a: \x1B[33mtrue\x1B[39m }',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G'],
+    ['1n + 2n', [2, 5], '\x1B[33m3n\x1B[39m',
+     '1n + 2',
+     '\x1B[90mType[39m\x1B[1A\x1B[14G\x1B[1B\x1B[2K\x1B[1An',
+     '\x1B[90m3n\x1B[39m\x1B[1A\x1B[15G\x1B[1B\x1B[2K\x1B[1A\r',
+     '\x1B[33m3n\x1B[39m',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G'],
+    ['{ a: true };', [2, 4], '\x1B[33mtrue\x1B[39m',
+     '{ a: true };',
+     '\x1B[90mtrue\x1B[39m\x1B[1A\x1B[20G\x1B[1B\x1B[2K\x1B[1A\r',
+     '\x1B[33mtrue\x1B[39m',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G'],
+    [' \t { a: true};', [2, 5], '\x1B[33mtrue\x1B[39m',
+     ' \t { a: true}',
+     '\x1B[90m{ a: true }\x1B[39m\x1B[1A\x1B[21G\x1B[1B\x1B[2K\x1B[1A;',
+     '\x1B[90mtrue\x1B[39m\x1B[1A\x1B[22G\x1B[1B\x1B[2K\x1B[1A\r',
+     '\x1B[33mtrue\x1B[39m',
+     '\x1B[1G\x1B[0Jrepl > \x1B[8G']
+  ];
+
+  const hasPreview = repl.terminal &&
+    (options.preview !== undefined ? !!options.preview : true);
+
+  for (const [input, length, expected, ...preview] of testCases) {
+    console.log(`Testing ${input}`);
+
+    const toBeRun = input.split('\n');
+    let lines = await runAndWait(toBeRun, repl);
+
+    assert.strictEqual(lines.length, length[+hasPreview]);
+    if (expected === undefined) {
+      assert(!lines.some((e) => e.includes('undefined')));
+    } else if (hasPreview) {
+      // Remove error messages. That allows the code to run in different
+      // engines.
+      // eslint-disable-next-line no-control-regex
+      lines = lines.map((line) => line.replace(/Error: .+?\x1B/, ''));
+      assert.deepStrictEqual(lines, preview);
+    } else {
+      assert.ok(lines[0].includes(expected), lines);
+    }
+  }
+}
+
+tests({ terminal: false }); // No preview
+tests({ terminal: true }); // Preview
+tests({ terminal: false, preview: false }); // No preview
+tests({ terminal: false, preview: true }); // No preview
+tests({ terminal: true, preview: true }); // Preview
diff --git a/test/parallel/test-repl-top-level-await.js b/test/parallel/test-repl-top-level-await.js
index 5c8aa95d40ec05..cecbd3ab4563d0 100644
--- a/test/parallel/test-repl-top-level-await.js
+++ b/test/parallel/test-repl-top-level-await.js
@@ -1,11 +1,13 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const ArrayStream = require('../common/arraystream');
 const assert = require('assert');
 const { stripVTControlCharacters } = require('internal/readline/utils');
 const repl = require('repl');
 
+common.skipIfInspectorDisabled();
+
 // Flags: --expose-internals --experimental-repl-await
 
 const PROMPT = 'await repl > ';
@@ -84,61 +86,84 @@ async function ordinaryTests() {
   const testCases = [
     [ 'await Promise.resolve(0)', '0' ],
     [ '{ a: await Promise.resolve(1) }', '{ a: 1 }' ],
-    [ '_', '{ a: 1 }' ],
-    [ 'let { a, b } = await Promise.resolve({ a: 1, b: 2 }), f = 5;',
+    [ '_', '// { a: 1 }\r', { line: 0 } ],
+    [ 'let { aa, bb } = await Promise.resolve({ aa: 1, bb: 2 }), f = 5;',
       'undefined' ],
-    [ 'a', '1' ],
-    [ 'b', '2' ],
-    [ 'f', '5' ],
-    [ 'let c = await Promise.resolve(2)', 'undefined' ],
-    [ 'c', '2' ],
-    [ 'let d;', 'undefined' ],
-    [ 'd', 'undefined' ],
-    [ 'let [i, { abc: { k } }] = [0, { abc: { k: 1 } }];', 'undefined' ],
-    [ 'i', '0' ],
-    [ 'k', '1' ],
-    [ 'var l = await Promise.resolve(2);', 'undefined' ],
-    [ 'l', '2' ],
-    [ 'foo(await koo())', '4' ],
-    [ '_', '4' ],
-    [ 'const m = foo(await koo());', 'undefined' ],
-    [ 'm', '4' ],
-    [ 'const n = foo(await\nkoo());', 'undefined' ],
-    [ 'n', '4' ],
+    [ 'aa', ['// 1\r', '1'] ],
+    [ 'bb', ['// 2\r', '2'] ],
+    [ 'f', ['// 5\r', '5'] ],
+    [ 'let cc = await Promise.resolve(2)', 'undefined' ],
+    [ 'cc', ['// 2\r', '2'] ],
+    [ 'let dd;', 'undefined' ],
+    [ 'dd', 'undefined' ],
+    [ 'let [ii, { abc: { kk } }] = [0, { abc: { kk: 1 } }];', 'undefined' ],
+    [ 'ii', ['// 0\r', '0'] ],
+    [ 'kk', ['// 1\r', '1'] ],
+    [ 'var ll = await Promise.resolve(2);', 'undefined' ],
+    [ 'll', ['// 2\r', '2'] ],
+    [ 'foo(await koo())',
+      [ 'f', '// 5oo', '// [Function: foo](await koo())\r', '4' ] ],
+    [ '_', ['// 4\r', '4'] ],
+    [ 'const m = foo(await koo());',
+      [ 'const m = foo(await koo());\r', 'undefined' ] ],
+    [ 'm', ['// 4\r', '4' ] ],
+    [ 'const n = foo(await\nkoo());',
+      [ 'const n = foo(await\r', '... koo());\r', 'undefined' ] ],
+    [ 'n', ['// 4\r', '4' ] ],
     // eslint-disable-next-line no-template-curly-in-string
     [ '`status: ${(await Promise.resolve({ status: 200 })).status}`',
       "'status: 200'"],
-    [ 'for (let i = 0; i < 2; ++i) await i', 'undefined' ],
-    [ 'for (let i = 0; i < 2; ++i) { await i }', 'undefined' ],
-    [ 'await 0', '0' ],
-    [ 'await 0; function foo() {}', 'undefined' ],
-    [ 'foo', '[Function: foo]' ],
-    [ 'class Foo {}; await 1;', '1' ],
-    [ 'Foo', '[Function: Foo]' ],
-    [ 'if (await true) { function bar() {}; }', 'undefined' ],
-    [ 'bar', '[Function: bar]' ],
+    [ 'for (let i = 0; i < 2; ++i) await i',
+      ['f', '// 5or (let i = 0; i < 2; ++i) await i\r', 'undefined'] ],
+    [ 'for (let i = 0; i < 2; ++i) { await i }',
+      [ 'f', '// 5or (let i = 0; i < 2; ++i) { await i }\r', 'undefined' ] ],
+    [ 'await 0', ['await 0\r', '0'] ],
+    [ 'await 0; function foo() {}',
+      ['await 0; function foo() {}\r', 'undefined'] ],
+    [ 'foo',
+      ['f', '// 5oo', '// [Function: foo]\r', '[Function: foo]'] ],
+    [ 'class Foo {}; await 1;', ['class Foo {}; await 1;\r', '1'] ],
+    [ 'Foo', ['// [Function: Foo]\r', '[Function: Foo]'] ],
+    [ 'if (await true) { function bar() {}; }',
+      ['if (await true) { function bar() {}; }\r', 'undefined'] ],
+    [ 'bar', ['// [Function: bar]\r', '[Function: bar]'] ],
     [ 'if (await true) { class Bar {}; }', 'undefined' ],
     [ 'Bar', 'Uncaught ReferenceError: Bar is not defined' ],
     [ 'await 0; function* gen(){}', 'undefined' ],
-    [ 'for (var i = 0; i < 10; ++i) { await i; }', 'undefined' ],
-    [ 'i', '10' ],
-    [ 'for (let j = 0; j < 5; ++j) { await j; }', 'undefined' ],
-    [ 'j', 'Uncaught ReferenceError: j is not defined' ],
-    [ 'gen', '[GeneratorFunction: gen]' ],
+    [ 'for (var i = 0; i < 10; ++i) { await i; }',
+      ['f', '// 5or (var i = 0; i < 10; ++i) { await i; }\r', 'undefined'] ],
+    [ 'i', ['// 10\r', '10'] ],
+    [ 'for (let j = 0; j < 5; ++j) { await j; }',
+      ['f', '// 5or (let j = 0; j < 5; ++j) { await j; }\r', 'undefined'] ],
+    [ 'j', 'Uncaught ReferenceError: j is not defined', { line: 0 } ],
+    [ 'gen', ['// [GeneratorFunction: gen]\r', '[GeneratorFunction: gen]'] ],
     [ 'return 42; await 5;', 'Uncaught SyntaxError: Illegal return statement',
       { line: 3 } ],
     [ 'let o = await 1, p', 'undefined' ],
     [ 'p', 'undefined' ],
     [ 'let q = 1, s = await 2', 'undefined' ],
-    [ 's', '2' ],
-    [ 'for await (let i of [1,2,3]) console.log(i)', 'undefined', { line: 3 } ]
+    [ 's', ['// 2\r', '2'] ],
+    [ 'for await (let i of [1,2,3]) console.log(i)',
+      [
+        'f',
+        '// 5or await (let i of [1,2,3]) console.log(i)\r',
+        '1',
+        '2',
+        '3',
+        'undefined'
+      ]
+    ]
   ];
 
   for (const [input, expected, options = {}] of testCases) {
     console.log(`Testing ${input}`);
     const toBeRun = input.split('\n');
     const lines = await runAndWait(toBeRun);
-    if ('line' in options) {
+    if (Array.isArray(expected)) {
+      if (lines[0] === input)
+        lines.shift();
+      assert.deepStrictEqual(lines, [...expected, PROMPT]);
+    } else if ('line' in options) {
       assert.strictEqual(lines[toBeRun.length + options.line], expected);
     } else {
       const echoed = toBeRun.map((a, i) => `${i > 0 ? '... ' : ''}${a}\r`);