module: do not share the internal require function with public loaders

This patch removes `NativeModule.require` and
`NativeModule.requireWithFallbackInDeps`. The public loaders now
have to use a special method
`NativeModule.prototype.compileForPublicLoader()` to compile native
modules. In addition this patch moves the decisions of proxifying
exports and throwing unknown builtin errors entirely to public
loaders, and skip those during internal use - therefore `loaders.js`,
which is compiled during bootstrap, no longer needs to be aware of
the value of `--experimental-modules`.

PR-URL: #26549
Reviewed-By: James M Snell <jasnell@gmail.com>

lib/internal/bootstrap/loaders.js

@@ -19,7 +19,7 @@
 //   can be created using NODE_MODULE_CONTEXT_AWARE_CPP() with the flag
 //   NM_F_LINKED.
 // - internalBinding(): the private internal C++ binding loader, inaccessible
-//   from user land because they are only available from NativeModule.require().
+//   from user land unless through `require('internal/test/binding')`.
 //   These C++ bindings are created using NODE_MODULE_CONTEXT_AWARE_INTERNAL()
 //   and have their nm_flags set to NM_F_INTERNAL.
 //
@@ -42,7 +42,7 @@
 // This file is compiled as if it's wrapped in a function with arguments
 // passed by node::RunBootstrapping()
 /* global process, getLinkedBinding, getInternalBinding */
-/* global experimentalModules, exposeInternals, primordials */
+/* global exposeInternals, primordials */
 
 const {
   Reflect,
@@ -185,27 +185,9 @@ function nativeModuleRequire(id) {
   }
 
   const mod = NativeModule.map.get(id);
-  if (!mod) {
-    // Model the error off the internal/errors.js model, but
-    // do not use that module given that it could actually be
-    // the one causing the error if there's a bug in Node.js.
-    // eslint-disable-next-line no-restricted-syntax
-    const err = new Error(`No such built-in module: ${id}`);
-    err.code = 'ERR_UNKNOWN_BUILTIN_MODULE';
-    err.name = 'Error [ERR_UNKNOWN_BUILTIN_MODULE]';
-    throw err;
-  }
-
-  if (mod.loaded || mod.loading) {
-    return mod.exports;
-  }
-
-  moduleLoadList.push(`NativeModule ${id}`);
-  mod.compile();
-  return mod.exports;
+  return mod.compile();
 }
 
-NativeModule.require = nativeModuleRequire;
 NativeModule.exists = function(id) {
   return NativeModule.map.has(id);
 };
@@ -217,11 +199,25 @@ NativeModule.canBeRequiredByUsers = function(id) {
 
 // Allow internal modules from dependencies to require
 // other modules from dependencies by providing fallbacks.
-NativeModule.requireWithFallbackInDeps = function(request) {
+function requireWithFallbackInDeps(request) {
   if (!NativeModule.map.has(request)) {
     request = `internal/deps/${request}`;
   }
-  return NativeModule.require(request);
+  return nativeModuleRequire(request);
+}
+
+// This is exposed for public loaders
+NativeModule.prototype.compileForPublicLoader = function(needToProxify) {
+  if (!this.canBeRequiredByUsers) {
+    // No code because this is an assertion against bugs
+    // eslint-disable-next-line no-restricted-syntax
+    throw new Error(`Should not compile ${this.id} for public use`);
+  }
+  this.compile();
+  if (needToProxify && !this.exportKeys) {
+    this.proxifyExports();
+  }
+  return this.exports;
 };
 
 const getOwn = (target, property, receiver) => {
@@ -289,26 +285,27 @@ NativeModule.prototype.proxifyExports = function() {
 };
 
 NativeModule.prototype.compile = function() {
-  const id = this.id;
+  if (this.loaded || this.loading) {
+    return this.exports;
+  }
 
+  const id = this.id;
   this.loading = true;
 
   try {
     const requireFn = this.id.startsWith('internal/deps/') ?
-      NativeModule.requireWithFallbackInDeps :
-      NativeModule.require;
+      requireWithFallbackInDeps : nativeModuleRequire;
 
     const fn = compileFunction(id);
     fn(this.exports, requireFn, this, process, internalBinding, primordials);
 
-    if (experimentalModules && this.canBeRequiredByUsers) {
-      this.proxifyExports();
-    }
-
     this.loaded = true;
   } finally {
     this.loading = false;
   }
+
+  moduleLoadList.push(`NativeModule ${id}`);
+  return this.exports;
 };
 
 // This will be passed to internal/bootstrap/node.js.

lib/internal/bootstrap/node.js

@@ -33,13 +33,12 @@
 
 // This file is compiled as if it's wrapped in a function with arguments
 // passed by node::RunBootstrapping()
-/* global process, loaderExports, isMainThread, ownsProcessState */
+/* global process, require, internalBinding, isMainThread, ownsProcessState */
 /* global primordials */
 
-const { internalBinding, NativeModule } = loaderExports;
 const { Object, Symbol } = primordials;
 const config = internalBinding('config');
-const { deprecate } = NativeModule.require('internal/util');
+const { deprecate } = require('internal/util');
 
 setupProcessObject();
 
@@ -50,17 +49,17 @@ process.domain = null;
 process._exiting = false;
 
 // Bootstrappers for all threads, including worker threads and main thread
-const perThreadSetup = NativeModule.require('internal/process/per_thread');
+const perThreadSetup = require('internal/process/per_thread');
 // Bootstrappers for the main thread only
 let mainThreadSetup;
 // Bootstrappers for the worker threads only
 let workerThreadSetup;
 if (ownsProcessState) {
-  mainThreadSetup = NativeModule.require(
+  mainThreadSetup = require(
     'internal/process/main_thread_only'
   );
 } else {
-  workerThreadSetup = NativeModule.require(
+  workerThreadSetup = require(
     'internal/process/worker_thread_only'
   );
 }
@@ -116,14 +115,14 @@ if (isMainThread) {
 
 const {
   emitWarning
-} = NativeModule.require('internal/process/warning');
+} = require('internal/process/warning');
 
 process.emitWarning = emitWarning;
 
 const {
   nextTick,
   runNextTicks
-} = NativeModule.require('internal/process/next_tick').setup();
+} = require('internal/process/next_tick').setup();
 
 process.nextTick = nextTick;
 // Used to emulate a tick manually in the JS land.
@@ -161,7 +160,7 @@ if (credentials.implementsPosixCredentials) {
 
 if (isMainThread) {
   const { getStdout, getStdin, getStderr } =
-      NativeModule.require('internal/process/stdio').getMainThreadStdio();
+    require('internal/process/stdio').getMainThreadStdio();
   setupProcessStdio(getStdout, getStdin, getStderr);
 } else {
   const { getStdout, getStdin, getStderr } =
@@ -173,7 +172,7 @@ if (isMainThread) {
 // process. They use the same functions as the JS embedder API. These callbacks
 // are setup immediately to prevent async_wrap.setupHooks() from being hijacked
 // and the cost of doing so is negligible.
-const { nativeHooks } = NativeModule.require('internal/async_hooks');
+const { nativeHooks } = require('internal/async_hooks');
 internalBinding('async_wrap').setupHooks(nativeHooks);
 
 // XXX(joyeecheung): this has to be done after the initial load of
@@ -183,7 +182,7 @@ if (config.hasInspector) {
   const {
     enable,
     disable
-  } = NativeModule.require('internal/inspector_async_hook');
+  } = require('internal/inspector_async_hook');
   internalBinding('inspector').registerAsyncHook(enable, disable);
 }
 
@@ -193,22 +192,22 @@ if (!config.noBrowserGlobals) {
   // https://console.spec.whatwg.org/#console-namespace
   exposeNamespace(global, 'console', createGlobalConsole(global.console));
 
-  const { URL, URLSearchParams } = NativeModule.require('internal/url');
+  const { URL, URLSearchParams } = require('internal/url');
   // https://url.spec.whatwg.org/#url
   exposeInterface(global, 'URL', URL);
   // https://url.spec.whatwg.org/#urlsearchparams
   exposeInterface(global, 'URLSearchParams', URLSearchParams);
 
   const {
     TextEncoder, TextDecoder
-  } = NativeModule.require('internal/encoding');
+  } = require('internal/encoding');
   // https://encoding.spec.whatwg.org/#textencoder
   exposeInterface(global, 'TextEncoder', TextEncoder);
   // https://encoding.spec.whatwg.org/#textdecoder
   exposeInterface(global, 'TextDecoder', TextDecoder);
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#windoworworkerglobalscope
-  const timers = NativeModule.require('timers');
+  const timers = require('timers');
   defineOperation(global, 'clearInterval', timers.clearInterval);
   defineOperation(global, 'clearTimeout', timers.clearTimeout);
   defineOperation(global, 'setInterval', timers.setInterval);
@@ -302,7 +301,7 @@ Object.defineProperty(process, 'features', {
     fatalException,
     setUncaughtExceptionCaptureCallback,
     hasUncaughtExceptionCaptureCallback
-  } = NativeModule.require('internal/process/execution');
+  } = require('internal/process/execution');
 
   process._fatalException = fatalException;
   process.setUncaughtExceptionCaptureCallback =
@@ -312,7 +311,7 @@ Object.defineProperty(process, 'features', {
 }
 
 function setupProcessObject() {
-  const EventEmitter = NativeModule.require('events');
+  const EventEmitter = require('events');
   const origProcProto = Object.getPrototypeOf(process);
   Object.setPrototypeOf(origProcProto, EventEmitter.prototype);
   EventEmitter.call(process);
@@ -391,7 +390,7 @@ function setupGlobalProxy() {
 }
 
 function setupBuffer() {
-  const { Buffer } = NativeModule.require('buffer');
+  const { Buffer } = require('buffer');
   const bufferBinding = internalBinding('buffer');
 
   // Only after this point can C++ use Buffer::New()
@@ -404,9 +403,9 @@ function setupBuffer() {
 
 function createGlobalConsole(consoleFromVM) {
   const consoleFromNode =
-    NativeModule.require('internal/console/global');
+    require('internal/console/global');
   if (config.hasInspector) {
-    const inspector = NativeModule.require('internal/util/inspector');
+    const inspector = require('internal/util/inspector');
     // This will be exposed by `require('inspector').console` later.
     inspector.consoleFromVM = consoleFromVM;
     // TODO(joyeecheung): postpone this until the first time inspector
@@ -424,8 +423,7 @@ function setupQueueMicrotask() {
     get() {
       process.emitWarning('queueMicrotask() is experimental.',
                           'ExperimentalWarning');
-      const { queueMicrotask } =
-        NativeModule.require('internal/queue_microtask');
+      const { queueMicrotask } = require('internal/queue_microtask');
 
       Object.defineProperty(global, 'queueMicrotask', {
         value: queueMicrotask,

lib/internal/errors.js

@@ -1017,6 +1017,7 @@ E('ERR_UNHANDLED_ERROR',
     if (err === undefined) return msg;
     return `${msg} (${err})`;
   }, Error);
+E('ERR_UNKNOWN_BUILTIN_MODULE', 'No such built-in module: %s', Error);
 E('ERR_UNKNOWN_CREDENTIAL', '%s identifier does not exist: %s', Error);
 E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError);
 

lib/internal/modules/cjs/loader.js

@@ -567,8 +567,8 @@ Module._resolveLookupPaths = function(request, parent, newReturn) {
 
 // Check the cache for the requested file.
 // 1. If a module already exists in the cache: return its exports object.
-// 2. If the module is native: call `NativeModule.require()` with the
-//    filename and return the result.
+// 2. If the module is native: call
+//    `NativeModule.prototype.compileForPublicLoader()` and return the exports.
 // 3. Otherwise, create a new module for the file and save it to the cache.
 //    Then have it load  the file contents before returning its exports
 //    object.
@@ -585,9 +585,10 @@ Module._load = function(request, parent, isMain) {
     return cachedModule.exports;
   }
 
-  if (NativeModule.canBeRequiredByUsers(filename)) {
+  const mod = NativeModule.map.get(filename);
+  if (mod && mod.canBeRequiredByUsers) {
     debug('load native module %s', request);
-    return NativeModule.require(filename);
+    return mod.compileForPublicLoader(experimentalModules);
   }
 
   // Don't call updateChildren(), Module constructor already does.

lib/internal/modules/esm/translators.js

@@ -22,7 +22,9 @@ const { URL } = require('url');
 const { debuglog } = require('internal/util/debuglog');
 const { promisify } = require('internal/util');
 const esmLoader = require('internal/process/esm_loader');
-
+const {
+  ERR_UNKNOWN_BUILTIN_MODULE
+} = require('internal/errors').codes;
 const readFileAsync = promisify(fs.readFile);
 const readFileSync = fs.readFileSync;
 const StringReplace = FunctionPrototype.call.bind(StringPrototype.replace);
@@ -86,8 +88,11 @@ translators.set('builtin', async (url) => {
   debug(`Translating BuiltinModule ${url}`);
   // slice 'node:' scheme
   const id = url.slice(5);
-  NativeModule.require(id);
   const module = NativeModule.map.get(id);
+  if (!module) {
+    throw new ERR_UNKNOWN_BUILTIN_MODULE(id);
+  }
+  module.compileForPublicLoader(true);
   return createDynamicModule(
     [...module.exportKeys, 'default'], url, (reflect) => {
       debug(`Loading BuiltinModule ${url}`);

src/node.cc

@@ -298,8 +298,6 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
       env->process_string(),
       FIXED_ONE_BYTE_STRING(isolate, "getLinkedBinding"),
       FIXED_ONE_BYTE_STRING(isolate, "getInternalBinding"),
-      // --experimental-modules
-      FIXED_ONE_BYTE_STRING(isolate, "experimentalModules"),
       // --expose-internals
       FIXED_ONE_BYTE_STRING(isolate, "exposeInternals"),
       env->primordials_string()};
@@ -311,7 +309,6 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
       env->NewFunctionTemplate(binding::GetInternalBinding)
           ->GetFunction(context)
           .ToLocalChecked(),
-      Boolean::New(isolate, env->options()->experimental_modules),
       Boolean::New(isolate, env->options()->expose_internals),
       env->primordials()};
 
@@ -333,16 +330,19 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
       loader_exports_obj->Get(context, env->require_string()).ToLocalChecked();
   env->set_native_module_require(require.As<Function>());
 
-  // process, loaderExports, isMainThread, ownsProcessState, primordials
+  // process, require, internalBinding, isMainThread,
+  // ownsProcessState, primordials
   std::vector<Local<String>> node_params = {
       env->process_string(),
-      FIXED_ONE_BYTE_STRING(isolate, "loaderExports"),
+      env->require_string(),
+      env->internal_binding_string(),
       FIXED_ONE_BYTE_STRING(isolate, "isMainThread"),
       FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
       env->primordials_string()};
   std::vector<Local<Value>> node_args = {
       process,
-      loader_exports_obj,
+      require,
+      internal_binding_loader,
       Boolean::New(isolate, env->is_main_thread()),
       Boolean::New(isolate, env->owns_process_state()),
       env->primordials()};