module: support eval with ts syntax detection

PR-URL: #56285
Refs: nodejs/typescript#17
Reviewed-By: Pietro Marchini <pietro.marchini94@gmail.com>
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>

Author: marco-ippolito

doc/api/cli.md

@@ -1381,8 +1381,23 @@ added: v12.0.0
 -->
 
 This configures Node.js to interpret `--eval` or `STDIN` input as CommonJS or
-as an ES module. Valid values are `"commonjs"` or `"module"`. The default is
-`"commonjs"`.
+as an ES module. Valid values are `"commonjs"`, `"module"`, `"module-typescript"` and `"commonjs-typescript"`.
+The `"-typescript"` values are available only in combination with the flag `--experimental-strip-types`.
+The default is `"commonjs"`.
+
+If `--experimental-strip-types` is enabled and `--input-type` is not provided,
+Node.js will try to detect the syntax with the following steps:
+
+1. Run the input as CommonJS.
+2. If step 1 fails, run the input as an ES module.
+3. If step 2 fails with a SyntaxError, strip the types.
+4. If step 3 fails with an error code [`ERR_INVALID_TYPESCRIPT_SYNTAX`][],
+   throw the error from step 2, including the TypeScript error in the message,
+   else run as CommonJS.
+5. If step 4 fails, run the input as an ES module.
+
+To avoid the delay of multiple syntax detection passes, the `--input-type=type` flag can be used to specify
+how the `--eval` input should be interpreted.
 
 The REPL does not support this option. Usage of `--input-type=module` with
 [`--print`][] will throw an error, as `--print` does not support ES module
@@ -3645,6 +3660,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [`AsyncLocalStorage`]: async_context.md#class-asynclocalstorage
 [`Buffer`]: buffer.md#class-buffer
 [`CRYPTO_secure_malloc_init`]: https://www.openssl.org/docs/man3.0/man3/CRYPTO_secure_malloc_init.html
+[`ERR_INVALID_TYPESCRIPT_SYNTAX`]: errors.md#err_invalid_typescript_syntax
 [`NODE_OPTIONS`]: #node_optionsoptions
 [`NO_COLOR`]: https://no-color.org
 [`SlowBuffer`]: buffer.md#class-slowbuffer

lib/internal/main/eval_string.js

@@ -13,28 +13,34 @@ const {
   prepareMainThreadExecution,
   markBootstrapComplete,
 } = require('internal/process/pre_execution');
-const { evalModuleEntryPoint, evalScript } = require('internal/process/execution');
+const {
+  evalModuleEntryPoint,
+  evalTypeScript,
+  parseAndEvalCommonjsTypeScript,
+  parseAndEvalModuleTypeScript,
+  evalScript,
+} = require('internal/process/execution');
 const { addBuiltinLibsToObject } = require('internal/modules/helpers');
-const { stripTypeScriptModuleTypes } = require('internal/modules/typescript');
 const { getOptionValue } = require('internal/options');
 
 prepareMainThreadExecution();
 addBuiltinLibsToObject(globalThis, '<eval>');
 markBootstrapComplete();
 
 const code = getOptionValue('--eval');
-const source = getOptionValue('--experimental-strip-types') ?
-  stripTypeScriptModuleTypes(code) :
-  code;
 
 const print = getOptionValue('--print');
 const shouldLoadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0;
-if (getOptionValue('--input-type') === 'module') {
-  evalModuleEntryPoint(source, print);
+const inputType = getOptionValue('--input-type');
+const tsEnabled = getOptionValue('--experimental-strip-types');
+if (inputType === 'module') {
+  evalModuleEntryPoint(code, print);
+} else if (inputType === 'module-typescript' && tsEnabled) {
+  parseAndEvalModuleTypeScript(code, print);
 } else {
   // For backward compatibility, we want the identifier crypto to be the
   // `node:crypto` module rather than WebCrypto.
-  const isUsingCryptoIdentifier = RegExpPrototypeExec(/\bcrypto\b/, source) !== null;
+  const isUsingCryptoIdentifier = RegExpPrototypeExec(/\bcrypto\b/, code) !== null;
   const shouldDefineCrypto = isUsingCryptoIdentifier && internalBinding('config').hasOpenSSL;
 
   if (isUsingCryptoIdentifier && !shouldDefineCrypto) {
@@ -49,11 +55,24 @@ if (getOptionValue('--input-type') === 'module') {
     };
     ObjectDefineProperty(object, name, { __proto__: null, set: setReal });
   }
-  evalScript('[eval]',
-             shouldDefineCrypto ? (
-               print ? `let crypto=require("node:crypto");{${source}}` : `(crypto=>{{${source}}})(require('node:crypto'))`
-             ) : source,
-             getOptionValue('--inspect-brk'),
-             print,
-             shouldLoadESM);
+
+  let evalFunction;
+  if (inputType === 'commonjs') {
+    evalFunction = evalScript;
+  } else if (inputType === 'commonjs-typescript' && tsEnabled) {
+    evalFunction = parseAndEvalCommonjsTypeScript;
+  } else if (tsEnabled) {
+    evalFunction = evalTypeScript;
+  } else {
+    // Default to commonjs.
+    evalFunction = evalScript;
+  }
+
+  evalFunction('[eval]',
+               shouldDefineCrypto ? (
+                 print ? `let crypto=require("node:crypto");{${code}}` : `(crypto=>{{${code}}})(require('node:crypto'))`
+               ) : code,
+               getOptionValue('--inspect-brk'),
+               print,
+               shouldLoadESM);
 }

lib/internal/modules/cjs/loader.js

@@ -449,7 +449,6 @@ function initializeCJS() {
 
   const tsEnabled = getOptionValue('--experimental-strip-types');
   if (tsEnabled) {
-    emitExperimentalWarning('Type Stripping');
     Module._extensions['.cts'] = loadCTS;
     Module._extensions['.ts'] = loadTS;
   }

lib/internal/modules/esm/loader.js

@@ -213,9 +213,25 @@ class ModuleLoader {
     }
   }
 
-  async eval(source, url, isEntryPoint = false) {
+  /**
+   *
+   * @param {string} source Source code of the module.
+   * @param {string} url URL of the module.
+   * @returns {object} The module wrap object.
+   */
+  createModuleWrap(source, url) {
+    return compileSourceTextModule(url, source, this);
+  }
+
+  /**
+   *
+   * @param {string} url URL of the module.
+   * @param {object} wrap Module wrap object.
+   * @param {boolean} isEntryPoint Whether the module is the entry point.
+   * @returns {Promise<object>} The module object.
+   */
+  async executeModuleJob(url, wrap, isEntryPoint = false) {
     const { ModuleJob } = require('internal/modules/esm/module_job');
-    const wrap = compileSourceTextModule(url, source, this);
     const module = await onImport.tracePromise(async () => {
       const job = new ModuleJob(
         this, url, undefined, wrap, false, false);
@@ -235,6 +251,18 @@ class ModuleLoader {
     };
   }
 
+  /**
+   *
+   * @param {string} source Source code of the module.
+   * @param {string} url URL of the module.
+   * @param {boolean} isEntryPoint Whether the module is the entry point.
+   * @returns {Promise<object>} The module object.
+   */
+  eval(source, url, isEntryPoint = false) {
+    const wrap = this.createModuleWrap(source, url);
+    return this.executeModuleJob(url, wrap, isEntryPoint);
+  }
+
   /**
    * Get a (possibly not yet fully linked) module job from the cache, or create one and return its Promise.
    * @param {string} specifier The module request of the module to be resolved. Typically, what's

lib/internal/modules/esm/translators.js

@@ -291,7 +291,6 @@ translators.set('require-commonjs', (url, source, isMain) => {
 // Handle CommonJS modules referenced by `require` calls.
 // This translator function must be sync, as `require` is sync.
 translators.set('require-commonjs-typescript', (url, source, isMain) => {
-  emitExperimentalWarning('Type Stripping');
   assert(cjsParse);
   const code = stripTypeScriptModuleTypes(stringify(source), url);
   return createCJSModuleWrap(url, code, isMain, 'commonjs-typescript');
@@ -536,7 +535,6 @@ translators.set('addon', function translateAddon(url, source, isMain) {
 
 // Strategy for loading a commonjs TypeScript module
 translators.set('commonjs-typescript', function(url, source) {
-  emitExperimentalWarning('Type Stripping');
   assertBufferSource(source, true, 'load');
   const code = stripTypeScriptModuleTypes(stringify(source), url);
   debug(`Translating TypeScript ${url}`);
@@ -545,7 +543,6 @@ translators.set('commonjs-typescript', function(url, source) {
 
 // Strategy for loading an esm TypeScript module
 translators.set('module-typescript', function(url, source) {
-  emitExperimentalWarning('Type Stripping');
   assertBufferSource(source, true, 'load');
   const code = stripTypeScriptModuleTypes(stringify(source), url);
   debug(`Translating TypeScript ${url}`);

lib/internal/modules/typescript.js

@@ -113,9 +113,13 @@ function processTypeScriptCode(code, options) {
  * It is used by internal loaders.
  * @param {string} source TypeScript code to parse.
  * @param {string} filename The filename of the source code.
+ * @param {boolean} emitWarning Whether to emit a warning.
  * @returns {TransformOutput} The stripped TypeScript code.
  */
-function stripTypeScriptModuleTypes(source, filename) {
+function stripTypeScriptModuleTypes(source, filename, emitWarning = true) {
+  if (emitWarning) {
+    emitExperimentalWarning('Type Stripping');
+  }
   assert(typeof source === 'string');
   if (isUnderNodeModules(filename)) {
     throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);