Skip to content

Commit

Permalink
repl: support mult-line string-keyed objects
Browse files Browse the repository at this point in the history
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.

PR-URL: #21805
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: John-David Dalton <john.david.dalton@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
  • Loading branch information
rubys authored and targos committed Aug 4, 2018
1 parent 28870a4 commit e4f3468
Show file tree
Hide file tree
Showing 4 changed files with 97 additions and 78 deletions.
79 changes: 79 additions & 0 deletions lib/internal/repl/recoverable.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
'use strict';

const acorn = require('internal/deps/acorn/dist/acorn');
const { tokTypes: tt } = acorn;

// 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) {
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. Note that we need to look
// for the specific errors of 'unterminated' kind (not, for example,
// a syntax error in a ${} expression in a template), and the only
// way to do that currently is to look at the message. Should Acorn
// change these messages in the future, this will lead to a test
// failure, indicating that this code needs to be updated.
//
acorn.plugins.replRecoverable = (parser) => {
parser.extend('nextToken', (nextToken) => {
return function() {
Reflect.apply(nextToken, this, []);

if (this.type === tt.eof) recoverable = true;
};
});

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 = this.input.slice(this.lastTokStart, this.pos);
// see https://www.ecma-international.org/ecma-262/#sec-line-terminators
recoverable = /\\(?:\r\n?|\n|\u2028|\u2029)$/.test(token);
}

Reflect.apply(raise, this, [pos, message]);
};
});
};

// 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: { replRecoverable: true } });

// Odd case: the underlying JS engine (V8, Chakra) rejected this input
// but Acorn detected no issue. Presume that additional text won't
// address this issue.
return false;
} catch {
return recoverable;
}
}

module.exports = {
isRecoverableError
};
74 changes: 3 additions & 71 deletions lib/repl.js
Original file line number Diff line number Diff line change
Expand Up @@ -73,6 +73,7 @@ const {
} = require('internal/errors').codes;
const { sendInspectorCommand } = require('internal/util/inspector');
const { experimentalREPLAwait } = process.binding('config');
const { isRecoverableError } = require('internal/repl/recoverable');

// Lazy-loaded.
let processTopLevelAwait;
Expand Down Expand Up @@ -227,7 +228,8 @@ function REPLServer(prompt,
// It's confusing for `{ a : 1 }` to be interpreted as a block
// statement rather than an object literal. So, we first try
// to wrap it in parentheses, so that it will be interpreted as
// an expression.
// an expression. Note that if the above condition changes,
// lib/internal/repl/recoverable.js needs to be changed to match.
code = `(${code.trim()})\n`;
wrappedCmd = true;
}
Expand Down Expand Up @@ -1505,76 +1507,6 @@ function regexpEscape(s) {
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
}

// If the error is that we've unexpectedly ended the input,
// then let the user try to recover by adding more input.
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;
}

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;
}

if (message === 'Invalid or unexpected token')
return isCodeRecoverable(code);
}
return false;
}

// 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;
}
}
}
}

return stringLiteral ? lastChar === '\\' : isBlockComment;
}

function Recoverable(err) {
this.err = err;
}
Expand Down
1 change: 1 addition & 0 deletions node.gyp
Original file line number Diff line number Diff line change
Expand Up @@ -146,6 +146,7 @@
'lib/internal/readline.js',
'lib/internal/repl.js',
'lib/internal/repl/await.js',
'lib/internal/repl/recoverable.js',
'lib/internal/socket_list.js',
'lib/internal/test/binding.js',
'lib/internal/test/heap.js',
Expand Down
21 changes: 14 additions & 7 deletions test/parallel/test-repl.js
Original file line number Diff line number Diff line change
Expand Up @@ -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 ${',
Expand Down Expand Up @@ -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() {',
Expand Down

0 comments on commit e4f3468

Please sign in to comment.