repl: support mult-line string-keyed objects

isRecoverableError is completely reimplemented using acorn and an acorn plugin that examines the state of the parser at the time of the error to determine if the code could be completed on a subsequent line.
nodejs · rubys · Jul 13, 2018 · Jul 14, 2018 · Jul 15, 2018 · Jul 15, 2018
commit 9affc6f44839d49cf438cfbcf1279648df58f1ce
diff --git a/lib/repl.js b/lib/repl.js
@@ -47,10 +47,11 @@ const {
   makeRequireFunction,
   addBuiltinLibsToObject
 } = require('internal/modules/cjs/helpers');
+const acorn = require('internal/deps/acorn/dist/acorn');
 const {
   isIdentifierStart,
   isIdentifierChar
-} = require('internal/deps/acorn/dist/acorn');
+} = acorn;
 const internalUtil = require('internal/util');
 const { isTypedArray } = require('internal/util/types');
 const util = require('util');
@@ -1507,72 +1508,60 @@ function regexpEscape(s) {
 
 // If the error is that we've unexpectedly ended the input,
 // then let the user try to recover by adding more input.
+// Note: `e` (the original exception is not used by the current implemention,
+// but may be needed in the future.)
 function isRecoverableError(e, code) {
-  if (e && e.name === 'SyntaxError') {
-    var message = e.message;
-    if (message === 'Unterminated template literal' ||
-        message === 'Unexpected end of input') {
-      return true;
-    }
+  let recoverable = false;
+
+  // Determine if the point of the any error raised is at the end of the input.
+  // There are two cases to consider:
+  //   1.  Any error raised after we have encountered the 'eof' token.
+  //       This prevents us from declaring partial tokens (like '2e') as
+  //       recoverable.
+  //   2.  Three cases where tokens can legally span lines.  This is
+  //       template, comment, and strings with a backslash at the end of
+  //       the line, indicating a continuation.
+  acorn.plugins.repl = (parser) => {
+    parser.extend('nextToken', (nextToken) => {
+      return function(pos, message) {
+        nextToken.call(this, pos, message);
+
+        if (parser.type === acorn.tokTypes.eof) recoverable = true;
+      };
+    });
 
-    if (message === 'missing ) after argument list') {
-      const frames = e.stack.split(/\r?\n/);
-      const pos = frames.findIndex((f) => f.match(/^\s*\^+$/));
-      return pos > 0 && frames[pos - 1].length === frames[pos].length;
-    }
+    parser.extend('raise', (raise) => {
+      return function(pos, message) {
+        switch (message) {
+          case 'Unterminated template':
+          case 'Unterminated comment':
+            recoverable = true;
+            break;
+
+          case 'Unterminated string constant':
+            const token = parser.input.slice(parser.lastTokStart, parser.pos);
+            recoverable = token.endsWith('\\\n');
+        }
 
-    if (message === 'Invalid or unexpected token')
-      return isCodeRecoverable(code);
-  }
-  return false;
-}
+        raise.call(this, pos, message);
+      };
+    });
+  };
 
-// Check whether a code snippet should be forced to fail in the REPL.
-function isCodeRecoverable(code) {
-  var current, previous, stringLiteral;
-  var isBlockComment = false;
-  var isSingleComment = false;
-  var isRegExpLiteral = false;
-  var lastChar = code.charAt(code.length - 2);
-  var prevTokenChar = null;
-
-  for (var i = 0; i < code.length; i++) {
-    previous = current;
-    current = code[i];
-
-    if (previous === '\\' && (stringLiteral || isRegExpLiteral)) {
-      current = null;
-    } else if (stringLiteral) {
-      if (stringLiteral === current) {
-        stringLiteral = null;
-      }
-    } else if (isRegExpLiteral && current === '/') {
-      isRegExpLiteral = false;
-    } else if (isBlockComment && previous === '*' && current === '/') {
-      isBlockComment = false;
-    } else if (isSingleComment && current === '\n') {
-      isSingleComment = false;
-    } else if (!isBlockComment && !isRegExpLiteral && !isSingleComment) {
-      if (current === '/' && previous === '/') {
-        isSingleComment = true;
-      } else if (previous === '/') {
-        if (current === '*') {
-          isBlockComment = true;
-          // Distinguish between a division operator and the start of a regex
-          // by examining the non-whitespace character that precedes the /
-        } else if ([null, '(', '[', '{', '}', ';'].includes(prevTokenChar)) {
-          isRegExpLiteral = true;
-        }
-      } else {
-        if (current.trim()) prevTokenChar = current;
-        if (current === '\'' || current === '"') {
-          stringLiteral = current;
-        }
-      }
-    }
+  // For similar reasons as `defaultEval`, wrap expressions starting with a
+  // curly brace with parenthesis.  Note: only the open parenthesis is added
+  // here as the point is to test for potentially valid but incomplete
+  // expressions.
+  if (/^\s*\{/.test(code) && isRecoverableError(e, `(${code}`)) return true;
+
+  // Try to parse the code with acorn.  If the parse fails, ignore the acorn
+  // error and return the recoverable status.
+  try {
+    acorn.parse(code, { plugins: { repl: true } });
+    return true;
+  } catch (e) {
+    return recoverable;
   }
-
-  return stringLiteral ? lastChar === '\\' : isBlockComment;
 }
 
 function Recoverable(err) {

diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
@@ -162,13 +162,11 @@ const errorTests = [
   // Template expressions
   {
     send: '`io.js ${"1.0"',
-    expect: [
-      kSource,
-      kArrow,
-      '',
-      /^SyntaxError: /,
-      ''
-    ]
+    expect: '... '
+  },
+  {
+    send: '+ ".2"}`',
+    expect: '\'io.js 1.0.2\''
   },
   {
     send: '`io.js ${',
@@ -315,6 +313,15 @@ const errorTests = [
     send: '1 }',
     expect: '{ a: 1 }'
   },
+  // Multiline string-keyed object (e.g. JSON)
+  {
+    send: '{ "a": ',
+    expect: '... '
+  },
+  {
+    send: '1 }',
+    expect: '{ a: 1 }'
+  },
   // Multiline anonymous function with comment
   {
     send: '(function() {',