clean up lint and unused code

Author: devsnek

src/io.js

@@ -9,11 +9,11 @@ class IO {
     this.stdin = stdin;
     this.stdout = stdout;
 
-    this.buffer = ''; // used for capturing the current statement
+    this.buffer = '';
+    this.multilineBuffer = '';
     this.cursor = 0;
     this.prefix = '';
     this.suffix = '';
-    this.multilineBuffer = ''; // for buffering the multiline statements
 
     this._paused = false;
     this.transformBuffer = transformBuffer;
@@ -135,18 +135,14 @@ class IO {
                   this.buffer = '';
                   this.cursor = 0;
                   this.history.unshift(b);
-                  this.multilineBuffer += b;
-                  // always buffer the line so that when we encounter multi-line
-                  // statements we can execute them as needed.
-                  const code = this.multilineBuffer;
-                  const result = await onLine(code);
-                  // online returns a Symbol when it sees a multi-line statement
-                  if (IO.kNeedsAnotherLine !== result) {
-                    this.stdout.write(`${result}\n`);
+                  const result = await onLine(this.multilineBuffer + b);
+                  if (result === IO.kNeedsAnotherLine) {
+                    this.multilineBuffer += b;
+                    this.setPrefix('... ');
+                  } else {
                     this.multilineBuffer = '';
+                    this.stdout.write(`${result}\n`);
                     this.setPrefix('> ');
-                  } else {
-                    this.setPrefix('... ');
                   }
                   this.unpause();
                 } else {

src/recoverable.js

@@ -1,13 +1,12 @@
 'use strict';
 
 const acorn = require('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) {
+function isRecoverableError(code) {
   let recoverable = false;
 
   // Determine if the point of the any error raised is at the end of the input.
@@ -27,39 +26,46 @@ function isRecoverableError(e, code) {
   //       failure, indicating that this code needs to be updated.
   //
   acorn.plugins.replRecoverable = (parser) => {
-    parser.extend('nextToken', (nextToken) => {
-      return function() {
-        Reflect.apply(nextToken, this, []);
+    parser.extend('nextToken', (nextToken) =>
+      function handleNextToken() {
+        if (this.type === tt.eof) {
+          recoverable = true;
+        }
 
-        if (this.type === tt.eof) recoverable = true;
-      };
-    });
+        return Reflect.apply(nextToken, this, []);
+      });
 
-    parser.extend('raise', (raise) => {
-      return function(pos, message) {
+    parser.extend('raise', (raise) =>
+      function handleRaise(pos, message) {
         switch (message) {
           case 'Unterminated template':
           case 'Unterminated comment':
           case 'Unexpected end of input':
             recoverable = true;
             break;
 
-          case 'Unterminated string constant':
+          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);
+            break;
+          }
+
+          default:
+            break;
         }
 
-        Reflect.apply(raise, this, [pos, message]);
-      };
-    });
+        return 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;
+  if (/^\s*\{/.test(code) && isRecoverableError(`(${code}`)) {
+    return true;
+  }
 
   // Try to parse the code with acorn.  If the parse fails, ignore the acorn
   // error and return the recoverable status.
@@ -70,10 +76,9 @@ function isRecoverableError(e, code) {
     // but Acorn detected no issue.  Presume that additional text won't
     // address this issue.
     return false;
-  } catch (e) {
+  } catch {
     return recoverable;
   }
 }
 
-module.exports = isRecoverableError
-
+module.exports = isRecoverableError;

src/repl.js

@@ -13,8 +13,13 @@ Error.prepareStackTrace = (err, frames) => {
   const cut = frames.findIndex((f) =>
     !f.getFileName() && !f.getFunctionName()) + 1;
 
-  return `${err}
-    at ${frames.slice(0, cut).join('\n    at ')}`;
+  frames = frames.slice(0, cut);
+
+  if (frames.length === 0) {
+    return `${err}`;
+  }
+
+  return `${err}\n    at ${frames.join('\n    at ')}`;
 };
 
 const inspect = (v) => util.inspect(v, { colors: true, showProxy: 2 });
@@ -103,32 +108,31 @@ Prototype REPL - https://github.com/nodejs/repl`,
         awaited = true;
       }
     }
+
     const evaluateResult = await this.eval(line, awaited);
 
     if (evaluateResult.exceptionDetails) {
-      // lets try for recovering
-      const result = isRecoverableError(evaluateResult.exceptionDetails.exception, line);
-      if (result) {
+      if (isRecoverableError(line)) {
         return IO.kNeedsAnotherLine;
-      } else {
-        // we tried our best - throw error
-        await this.callFunctionOn(
-          (err) => {
-            global.REPL.lastError = err;
-          },
-          evaluateResult.exceptionDetails.exception,
-        );
-        return inspect(global.REPL.lastError);
       }
-    } else {
+
       await this.callFunctionOn(
-        (result) => {
-          global.REPL.last = result;
+        (err) => {
+          global.REPL.lastError = err;
         },
-        evaluateResult.result,
+        evaluateResult.exceptionDetails.exception,
       );
-      return inspect(global.REPL.last);
+
+      return inspect(global.REPL.lastError);
     }
+
+    await this.callFunctionOn(
+      (result) => {
+        global.REPL.last = result;
+      },
+      evaluateResult.result,
+    );
+    return inspect(global.REPL.last);
   }
 
   async onAutocomplete(buffer) {