[v20.x] Revert "module: print location of unsettled top-level await in entry points"

.github/CODEOWNERS

@@ -96,6 +96,7 @@
 /doc/api/packages.md @nodejs/loaders
 /lib/internal/bootstrap/realm.js @nodejs/loaders
 /lib/internal/modules/* @nodejs/loaders
+/lib/internal/process/esm_loader.js @nodejs/loaders
 /lib/internal/process/execution.js @nodejs/loaders
 /lib/module.js @nodejs/loaders
 /src/module_wrap* @nodejs/loaders @nodejs/vm

lib/internal/main/check_syntax.js

@@ -50,7 +50,8 @@ function loadESMIfNeeded(cb) {
   const hasModulePreImport = getOptionValue('--import').length > 0;
 
   if (hasModulePreImport) {
-    require('internal/modules/run_main').runEntryPointWithESMLoader(cb);
+    const { loadESM } = require('internal/process/esm_loader');
+    loadESM(cb);
     return;
   }
   cb();
@@ -75,5 +76,7 @@ async function checkSyntax(source, filename) {
     return;
   }
 
-  wrapSafe(filename, source);
+  const { loadESM } = require('internal/process/esm_loader');
+  const { handleMainPromise } = require('internal/modules/run_main');
+  handleMainPromise(loadESM((loader) => wrapSafe(filename, source)));
 }

lib/internal/main/eval_stdin.js

@@ -10,7 +10,7 @@ const {
 const { getOptionValue } = require('internal/options');
 
 const {
-  evalModuleEntryPoint,
+  evalModule,
   evalScript,
   readStdin,
 } = require('internal/process/execution');
@@ -24,15 +24,15 @@ readStdin((code) => {
   process._eval = code;
 
   const print = getOptionValue('--print');
-  const shouldLoadESM = getOptionValue('--import').length > 0;
+  const loadESM = getOptionValue('--import').length > 0;
   if (getOptionValue('--input-type') === 'module' ||
     (getOptionValue('--experimental-default-type') === 'module' && getOptionValue('--input-type') !== 'commonjs')) {
-    evalModuleEntryPoint(code, print);
+    evalModule(code, print);
   } else {
     evalScript('[stdin]',
                code,
                getOptionValue('--inspect-brk'),
                print,
-               shouldLoadESM);
+               loadESM);
   }
 });

lib/internal/main/eval_string.js

@@ -13,7 +13,7 @@ const {
   prepareMainThreadExecution,
   markBootstrapComplete,
 } = require('internal/process/pre_execution');
-const { evalModuleEntryPoint, evalScript } = require('internal/process/execution');
+const { evalModule, evalScript } = require('internal/process/execution');
 const { addBuiltinLibsToObject } = require('internal/modules/helpers');
 
 const { getOptionValue } = require('internal/options');
@@ -24,10 +24,10 @@ markBootstrapComplete();
 
 const source = getOptionValue('--eval');
 const print = getOptionValue('--print');
-const shouldLoadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0;
+const loadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0;
 if (getOptionValue('--input-type') === 'module' ||
   (getOptionValue('--experimental-default-type') === 'module' && getOptionValue('--input-type') !== 'commonjs')) {
-  evalModuleEntryPoint(source, print);
+  evalModule(source, print);
 } else {
   // For backward compatibility, we want the identifier crypto to be the
   // `node:crypto` module rather than WebCrypto.
@@ -54,5 +54,5 @@ if (getOptionValue('--input-type') === 'module' ||
              ) : source,
              getOptionValue('--inspect-brk'),
              print,
-             shouldLoadESM);
+             loadESM);
 }

lib/internal/main/repl.js

@@ -35,7 +35,8 @@ if (process.env.NODE_REPL_EXTERNAL_MODULE) {
     process.exit(kInvalidCommandLineArgument);
   }
 
-  require('internal/modules/run_main').runEntryPointWithESMLoader(() => {
+  const esmLoader = require('internal/process/esm_loader');
+  esmLoader.loadESM(() => {
     console.log(`Welcome to Node.js ${process.version}.\n` +
       'Type ".help" for more information.');
 
@@ -63,7 +64,5 @@ if (process.env.NODE_REPL_EXTERNAL_MODULE) {
                  getOptionValue('--inspect-brk'),
                  getOptionValue('--print'));
     }
-    // The TLAs in the REPL are still run as scripts, just transformed as async
-    // IIFEs for the REPL code itself to await on.
   });
 }

lib/internal/main/worker_thread.js

@@ -170,8 +170,8 @@ port.on('message', (message) => {
       }
 
       case 'module': {
-        const { evalModuleEntryPoint } = require('internal/process/execution');
-        PromisePrototypeThen(evalModuleEntryPoint(filename), undefined, (e) => {
+        const { evalModule } = require('internal/process/execution');
+        PromisePrototypeThen(evalModule(filename), undefined, (e) => {
           workerOnGlobalUncaughtException(e, true);
         });
         break;

lib/internal/modules/esm/handle_process_exit.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { exitCodes: { kUnfinishedTopLevelAwait } } = internalBinding('errors');
+
+/**
+ * Handle a Promise from running code that potentially does Top-Level Await.
+ * In that case, it makes sense to set the exit code to a specific non-zero value
+ * if the main code never finishes running.
+ */
+function handleProcessExit() {
+  process.exitCode ??= kUnfinishedTopLevelAwait;
+}
+
+module.exports = {
+  handleProcessExit,
+};

lib/internal/modules/esm/hooks.js

@@ -161,8 +161,8 @@ class Hooks {
    * loader (user-land) to the worker.
    */
   async register(urlOrSpecifier, parentURL, data) {
-    const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-    const keyedExports = await cascadedLoader.import(
+    const moduleLoader = require('internal/process/esm_loader').esmLoader;
+    const keyedExports = await moduleLoader.import(
       urlOrSpecifier,
       parentURL,
       kEmptyObject,

lib/internal/modules/esm/loader.js

@@ -20,7 +20,7 @@ const {
   ERR_UNKNOWN_MODULE_FORMAT,
 } = require('internal/errors').codes;
 const { getOptionValue } = require('internal/options');
-const { isURL } = require('internal/url');
+const { pathToFileURL, isURL } = require('internal/url');
 const { emitExperimentalWarning } = require('internal/util');
 const {
   getDefaultConditions,
@@ -85,6 +85,11 @@ class ModuleLoader {
    */
   #defaultConditions = getDefaultConditions();
 
+  /**
+   * The index for assigning unique URLs to anonymous module evaluation
+   */
+  evalIndex = 0;
+
   /**
    * Registry of resolved specifiers
    */
@@ -182,7 +187,10 @@ class ModuleLoader {
     }
   }
 
-  async eval(source, url) {
+  async eval(
+    source,
+    url = pathToFileURL(`${process.cwd()}/[eval${++this.evalIndex}]`).href,
+  ) {
     const evalInstance = (url) => {
       const { ModuleWrap } = internalBinding('module_wrap');
       const { registerModule } = require('internal/modules/esm/utils');
@@ -206,7 +214,6 @@ class ModuleLoader {
     return {
       __proto__: null,
       namespace: module.getNamespace(),
-      module,
     };
   }
 
@@ -561,23 +568,6 @@ function getHooksProxy() {
   return hooksProxy;
 }
 
-let cascadedLoader;
-
-/**
- * This is a singleton ESM loader that integrates the loader hooks, if any.
- * It it used by other internal built-ins when they need to load ESM code
- * while also respecting hooks.
- * When built-ins need access to this loader, they should do
- * require('internal/module/esm/loader').getOrInitializeCascadedLoader()
- * lazily only right before the loader is actually needed, and don't do it
- * in the top-level, to avoid circular dependencies.
- * @returns {ModuleLoader}
- */
-function getOrInitializeCascadedLoader() {
-  cascadedLoader ??= createModuleLoader();
-  return cascadedLoader;
-}
-
 /**
  * Register a single loader programmatically.
  * @param {string|import('url').URL} specifier
@@ -608,11 +598,12 @@ function getOrInitializeCascadedLoader() {
  * ```
  */
 function register(specifier, parentURL = undefined, options) {
+  const moduleLoader = require('internal/process/esm_loader').esmLoader;
   if (parentURL != null && typeof parentURL === 'object' && !isURL(parentURL)) {
     options = parentURL;
     parentURL = options.parentURL;
   }
-  getOrInitializeCascadedLoader().register(
+  moduleLoader.register(
     specifier,
     parentURL ?? 'data:',
     options?.data,
@@ -623,6 +614,5 @@ function register(specifier, parentURL = undefined, options) {
 module.exports = {
   createModuleLoader,
   getHooksProxy,
-  getOrInitializeCascadedLoader,
   register,
 };

lib/internal/modules/esm/translators.js

@@ -59,6 +59,7 @@ const {
 const { maybeCacheSourceMap } = require('internal/source_map/source_map_cache');
 const moduleWrap = internalBinding('module_wrap');
 const { ModuleWrap } = moduleWrap;
+const asyncESM = require('internal/process/esm_loader');
 const { emitWarningSync } = require('internal/process/warning');
 
 // Lazy-loading to avoid circular dependencies.
@@ -157,8 +158,7 @@ function errPath(url) {
  * @returns {Promise<import('internal/modules/esm/loader.js').ModuleExports>} The imported module.
  */
 async function importModuleDynamically(specifier, { url }, attributes) {
-  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-  return cascadedLoader.import(specifier, url, attributes);
+  return asyncESM.esmLoader.import(specifier, url, attributes);
 }
 
 // Strategy for loading a standard JavaScript module.
@@ -224,7 +224,6 @@ function loadCJSModule(module, source, url, filename) {
 
   const compiledWrapper = compileResult.function;
 
-  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
   const __dirname = dirname(filename);
   // eslint-disable-next-line func-name-matching,func-style
   const requireFn = function require(specifier) {
@@ -243,7 +242,7 @@ function loadCJSModule(module, source, url, filename) {
       }
       specifier = `${pathToFileURL(path)}`;
     }
-    const job = cascadedLoader.getModuleJobSync(specifier, url, importAttributes);
+    const job = asyncESM.esmLoader.getModuleJobSync(specifier, url, importAttributes);
     job.runSync();
     return cjsCache.get(job.url).exports;
   };
@@ -254,7 +253,7 @@ function loadCJSModule(module, source, url, filename) {
         specifier = `${pathToFileURL(path)}`;
       }
     }
-    const { url: resolvedURL } = cascadedLoader.resolveSync(specifier, url, kEmptyObject);
+    const { url: resolvedURL } = asyncESM.esmLoader.resolveSync(specifier, url, kEmptyObject);
     return StringPrototypeStartsWith(resolvedURL, 'file://') ? fileURLToPath(resolvedURL) : resolvedURL;
   });
   setOwnProperty(requireFn, 'main', process.mainModule);

lib/internal/modules/esm/utils.js

@@ -32,6 +32,7 @@ const {
 const {
   emitExperimentalWarning,
   getCWDURL,
+  getLazy,
 } = require('internal/util');
 const {
   setImportModuleDynamicallyCallback,
@@ -180,6 +181,9 @@ function initializeImportMetaObject(symbol, meta) {
     }
   }
 }
+const getCascadedLoader = getLazy(
+  () => require('internal/process/esm_loader').esmLoader,
+);
 
 /**
  * Proxy the dynamic import to the default loader.
@@ -190,8 +194,7 @@ function initializeImportMetaObject(symbol, meta) {
  */
 function defaultImportModuleDynamically(specifier, attributes, referrerName) {
   const parentURL = normalizeReferrerURL(referrerName);
-  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-  return cascadedLoader.import(specifier, parentURL, attributes);
+  return getCascadedLoader().import(specifier, parentURL, attributes);
 }
 
 /**
@@ -260,10 +263,10 @@ async function initializeHooks() {
   const customLoaderURLs = getOptionValue('--experimental-loader');
 
   const { Hooks } = require('internal/modules/esm/hooks');
-  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
+  const esmLoader = require('internal/process/esm_loader').esmLoader;
 
   const hooks = new Hooks();
-  cascadedLoader.setCustomizations(hooks);
+  esmLoader.setCustomizations(hooks);
 
   // We need the loader customizations to be set _before_ we start invoking
   // `--require`, otherwise loops can happen because a `--require` script