module: unflag detect-module

Author: GeoffreyBooth

lib/internal/modules/cjs/loader.js

@@ -1379,7 +1379,7 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache, format) {
   }
 
   const isMain = !!(cjsModuleInstance && cjsModuleInstance[kIsMainSymbol]);
-  const shouldDetectModule = (format !== 'commonjs' && getOptionValue('--experimental-detect-module'));
+  const shouldDetectModule = (format !== 'commonjs');
   const result = compileFunctionForCJSLoader(content, filename, isMain, shouldDetectModule);
 
   // cachedDataRejected is only set for cache coming from SEA.

lib/internal/modules/esm/get_format.js

@@ -33,6 +33,16 @@ const protocolHandlers = {
   'node:'() { return 'builtin'; },
 };
 
+/**
+ * Determine whether the given source contains CommonJS or ES module syntax.
+ * @param {string | Buffer | undefined} source
+ * @param {URL} url
+ */
+function detectModuleFormat(source, url) {
+  if (!source) { return; }
+  return containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs';
+}
+
 /**
  * @param {URL} parsed
  * @returns {string | null}
@@ -112,26 +122,23 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
       default: { // The user did not pass `--experimental-default-type`.
         // `source` is undefined when this is called from `defaultResolve`;
         // but this gets called again from `defaultLoad`/`defaultLoadSync`.
-        if (getOptionValue('--experimental-detect-module')) {
-          const format = source ?
-            (containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs') :
-            null;
-          if (format === 'module') {
-            // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
-            // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
-            typelessPackageJsonFilesWarnedAbout ??= new SafeSet();
-            if (!typelessPackageJsonFilesWarnedAbout.has(pjsonPath)) {
-              const warning = `${url} parsed as an ES module because module syntax was detected;` +
-              ` to avoid the performance penalty of syntax detection, add "type": "module" to ${pjsonPath}`;
-              process.emitWarning(warning, {
-                code: 'MODULE_TYPELESS_PACKAGE_JSON',
-              });
-              typelessPackageJsonFilesWarnedAbout.add(pjsonPath);
-            }
+        // For ambiguous files (no type field, .js extension) we return
+        // undefined from `resolve` and re-run the check in `load`.
+        const format = detectModuleFormat(source, url);
+        if (format === 'module') {
+          // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
+          // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
+          typelessPackageJsonFilesWarnedAbout ??= new SafeSet();
+          if (!typelessPackageJsonFilesWarnedAbout.has(pjsonPath)) {
+            const warning = `${url} parsed as an ES module because module syntax was detected;` +
+            ` to avoid the performance penalty of syntax detection, add "type": "module" to ${pjsonPath}`;
+            process.emitWarning(warning, {
+              code: 'MODULE_TYPELESS_PACKAGE_JSON',
+            });
+            typelessPackageJsonFilesWarnedAbout.add(pjsonPath);
           }
-          return format;
         }
-        return 'commonjs';
+        return format;
       }
     }
   }
@@ -154,15 +161,14 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
         return 'commonjs';
       }
       default: { // The user did not pass `--experimental-default-type`.
-        if (getOptionValue('--experimental-detect-module')) {
-          if (!source) { return null; }
-          const format = getFormatOfExtensionlessFile(url);
-          if (format === 'module') {
-            return containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs';
-          }
+        if (!source) {
+          return;
+        }
+        const format = getFormatOfExtensionlessFile(url);
+        if (format === 'wasm') {
           return format;
         }
-        return 'commonjs';
+        return detectModuleFormat(source, url);
       }
     }
   }

lib/internal/modules/run_main.js

@@ -142,7 +142,7 @@ function runEntryPointWithESMLoader(callback) {
  * by `require('module')`) even when the entry point is ESM.
  * This monkey-patchable code is bypassed under `--experimental-default-type=module`.
  * Because of backwards compatibility, this function is exposed publicly via `import { runMain } from 'node:module'`.
- * When `--experimental-detect-module` is passed, this function will attempt to run ambiguous (no explicit extension, no
+ * Because of module detection, this function will attempt to run ambiguous (no explicit extension, no
  * `package.json` type field) entry points as CommonJS first; under certain conditions, it will retry running as ESM.
  * @param {string} main - First positional CLI argument, such as `'entry.js'` from `node entry.js`
  */

lib/internal/process/execution.js

@@ -81,8 +81,7 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
 
   const baseUrl = pathToFileURL(module.filename).href;
 
-  if (getOptionValue('--experimental-detect-module') &&
-    getOptionValue('--input-type') === '' && getOptionValue('--experimental-default-type') === '' &&
+  if (getOptionValue('--input-type') === '' && getOptionValue('--experimental-default-type') === '' &&
     containsModuleSyntax(body, name, null, 'no CJS variables')) {
     return evalModuleEntryPoint(body, print);
   }

src/node_options.cc

@@ -352,11 +352,7 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::conditions,
             kAllowedInEnvvar);
   AddAlias("-C", "--conditions");
-  AddOption("--experimental-detect-module",
-            "when ambiguous modules fail to evaluate because they contain "
-            "ES module syntax, try again to evaluate them as ES modules",
-            &EnvironmentOptions::detect_module,
-            kAllowedInEnvvar);
+  AddOption("--experimental-detect-module", "", NoOp{}, kAllowedInEnvvar);
   AddOption("--experimental-print-required-tla",
             "Print pending top-level await. If --experimental-require-module "
             "is true, evaluate asynchronous graphs loaded by `require()` but "

src/node_options.h

@@ -110,7 +110,7 @@ class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   std::vector<std::string> conditions;
-  bool detect_module = false;
+  bool detect_module = true;
   bool print_required_tla = false;
   bool require_module = false;
   std::string dns_result_order;