repl: add experimental TypeScript support

Signed-off-by: avivkeller <me@aviv.sh>

Author: avivkeller

doc/api/cli.md

@@ -1362,6 +1362,16 @@ added:
 
 Enable experimental support for the QUIC protocol.
 
+### `--experimental-repl-typescript`
+
+<!--
+added: REPLACEME
+-->
+
+> Stability: 1.2 - Release candidate
+
+Enable experimental support for TypeScript stripping in the REPL.
+
 ### `--experimental-sea-config`
 
 <!-- YAML

lib/internal/main/check_syntax.js

@@ -58,7 +58,7 @@ function loadESMIfNeeded(cb) {
 
 async function checkSyntax(source, filename) {
   let format;
-  if (filename === '[stdin]' || filename === '[eval]') {
+  if (filename === '[stdin]' || filename === '[eval]' || filename === '[repl]') {
     format = (getOptionValue('--input-type') === 'module') ? 'module' : 'commonjs';
   } else {
     const { defaultResolve } = require('internal/modules/esm/resolve');
@@ -75,3 +75,7 @@ async function checkSyntax(source, filename) {
 
   wrapSafe(filename, source, undefined, format);
 }
+
+module.exports = {
+  checkSyntax,
+};

lib/internal/modules/typescript.js

@@ -185,4 +185,5 @@ module.exports = {
   stripTypeScriptModuleTypes,
   stripTypeScriptTypes,
   stripTypeScriptTypesForCoverage,
+  processTypeScriptCode,
 };

lib/repl.js

@@ -97,6 +97,7 @@ const {
   decorateErrorStack,
   isError,
   deprecate,
+  getLazy,
   SideEffectFreeRegExpPrototypeSymbolReplace,
   SideEffectFreeRegExpPrototypeSymbolSplit,
 } = require('internal/util');
@@ -141,6 +142,9 @@ const {
 const experimentalREPLAwait = getOptionValue(
   '--experimental-repl-await',
 );
+const experimentalREPLTypeScript = getOptionValue(
+  '--experimental-repl-typescript'
+)
 const pendingDeprecation = getOptionValue('--pending-deprecation');
 const {
   REPL_MODE_SLOPPY,
@@ -177,8 +181,12 @@ const {
 
 // Lazy-loaded.
 let processTopLevelAwait;
+const processTypeScriptCode = getLazy(() => require('internal/modules/typescript').processTypeScriptCode);
+const checkSyntax = getLazy(() => require('internal/main/check_syntax').checkSyntax);
 
 const parentModule = module;
+const kREPLTag = '[repl]';
+const kTypeScriptOptions = { __proto__: null, mode: 'strip-only', filename: kREPLTag };
 
 // AsyncLocalStorage to track which REPL instance owns the current async context
 // This replaces the domain-based tracking for error handling
@@ -477,6 +485,41 @@ class REPLServer extends Interface {
                                      phase === 'evaluation' ? cascadedLoader.kEvaluationPhase :
                                        cascadedLoader.kSourcePhase);
       }
+      function runScript(scriptCode) {
+        if (experimentalREPLTypeScript) {
+          try {
+            // Try parsing as pure JS
+            checkSyntax()(scriptCode, kREPLTag);
+          } catch (originalError) {
+            try {
+              // That failed, so try stripping TypeScript types
+              scriptCode = processTypeScriptCode()(scriptCode, kTypeScriptOptions);
+            } catch (tsError) {
+              // If it's invalid or unsupported TypeScript syntax, rethrow the original error
+              // with the TypeScript error message added to the stack.
+              if (tsError.code === 'ERR_INVALID_TYPESCRIPT_SYNTAX' ||
+                tsError.code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX') {
+                originalError.stack = `${tsError.message}\n\n${originalError.stack}`;
+                throw originalError;
+              }
+
+              throw tsError;
+            }
+          }
+        }
+
+        return makeContextifyScript(
+          scriptCode,              // code
+          file,                    // filename,
+          0,                       // lineOffset
+          0,                       // columnOffset,
+          undefined,               // cachedData
+          false,                   // produceCachedData
+          undefined,               // parsingContext
+          hostDefinedOptionId,     // hostDefinedOptionId
+          importModuleDynamically, // importModuleDynamically
+        );
+      }
       // `experimentalREPLAwait` is set to true by default.
       // Shall be false in case `--no-experimental-repl-await` flag is used.
       if (experimentalREPLAwait && StringPrototypeIncludes(code, 'await')) {
@@ -498,17 +541,7 @@ class REPLServer extends Interface {
             // in order to detect if error is truly non recoverable
             const fallbackCode = SideEffectFreeRegExpPrototypeSymbolReplace(/\bawait\b/g, code, '');
             try {
-              makeContextifyScript(
-                fallbackCode,            // code
-                file,                    // filename,
-                0,                       // lineOffset
-                0,                       // columnOffset,
-                undefined,               // cachedData
-                false,                   // produceCachedData
-                undefined,               // parsingContext
-                hostDefinedOptionId,     // hostDefinedOptionId
-                importModuleDynamically, // importModuleDynamically
-              );
+              runScript(fallbackCode);
             } catch (fallbackError) {
               if (isRecoverableError(fallbackError, fallbackCode)) {
                 recoverableError = true;
@@ -536,17 +569,7 @@ class REPLServer extends Interface {
               // value for statements and declarations that don't return a value.
               code = `'use strict'; void 0;\n${code}`;
             }
-            script = makeContextifyScript(
-              code,                    // code
-              file,                    // filename,
-              0,                       // lineOffset
-              0,                       // columnOffset,
-              undefined,               // cachedData
-              false,                   // produceCachedData
-              undefined,               // parsingContext
-              hostDefinedOptionId,     // hostDefinedOptionId
-              importModuleDynamically, // importModuleDynamically
-            );
+            script = runScript(code);
           } catch (e) {
             debug('parse error %j', code, e);
             if (wrappedCmd) {

src/node_options.cc

@@ -726,6 +726,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::experimental_repl_await,
             kAllowedInEnvvar,
             true);
+  AddOption("--experimental-repl-typescript",
+            "experimental TypeScript support in REPL",
+            &EnvironmentOptions::experimental_repl_typescript,
+            kAllowedInEnvvar);
   AddOption("--experimental-vm-modules",
             "experimental ES Module support in vm module",
             &EnvironmentOptions::experimental_vm_modules,

src/node_options.h

@@ -154,6 +154,7 @@ class EnvironmentOptions : public Options {
   bool allow_ffi = false;
   bool allow_worker_threads = false;
   bool experimental_repl_await = true;
+  bool experimental_repl_typescript = false;
   bool experimental_vm_modules = EXPERIMENTALS_DEFAULT_VALUE;
   bool async_context_frame = true;
   bool expose_internals = false;

test/parallel/test-repl-typescript.js

@@ -0,0 +1,15 @@
+// Flags: --experimental-repl-typescript
+'use strict';
+require('../common');
+const assert = require('assert');
+
+const { startNewREPLServer } = require('../common/repl');
+
+const { input, output } = startNewREPLServer({ terminal: false, prompt: '> ' });
+
+input.emit('data', 'let x: number = 3\n');
+assert.match(output.accumulator, /undefined\n> /);
+output.accumulator = '';
+
+input.emit('data', 'x\n');
+assert.match(output.accumulator, /3\n> /);