add vm.Module linker hook to hookContext

doc/api/esm.md

@@ -157,6 +157,9 @@ A hook context consists of the following properties:
   useful if resolve is not hooked.
   - `specifier` {string} The specifier of the module to import.
   - `parentURL` {string} The URL of the module that requested the specifier.
+- `vmModuleLinkHook` {object} This value can be passed to [`module.link`][] to
+  allow linking the import requests of a [`vm.Module`][] instance to the
+  loader.
 
 ### Resolve hook
 
@@ -269,6 +272,8 @@ With the list of module exports provided upfront, the `execute` function will
 then be called at the exact point of module evaluation order for that module
 in the import tree.
 
+[`module.link`]: vm.html#vm_module_link_linker
+[`vm.Module`]: vm.html#vm_class_vm_module
 [Node.js EP for ES Modules]: https://github.com/nodejs/node-eps/blob/master/002-es-modules.md
 [addons]: addons.html
 [dynamic instantiate hook]: #esm_dynamic_instantiate_hook

doc/api/vm.md

@@ -395,6 +395,8 @@ that point all modules would have been fully linked already, the
 [HostResolveImportedModule][] implementation is fully synchronous per
 specification.
 
+The linker may also be passed from [`hookContext.vmModuleLinkhook`][].
+
 ## Class: vm.Script
 <!-- YAML
 added: v0.3.1
@@ -893,6 +895,7 @@ associating it with the `sandbox` object is what this document refers to as
 [`Error`]: errors.html#errors_class_error
 [`URL`]: url.html#url_class_url
 [`eval()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
+[`hookContext.vmModuleLinkHook`]: esm.html#esm_hook_context
 [`script.runInContext()`]: #vm_script_runincontext_contextifiedsandbox_options
 [`script.runInThisContext()`]: #vm_script_runinthiscontext_options
 [`url.origin`]: url.html#url_url_origin

lib/internal/modules/esm/loader.js

@@ -12,6 +12,7 @@ const defaultResolve = require('internal/modules/esm/default_resolve');
 const createDynamicModule = require(
   'internal/modules/esm/create_dynamic_module');
 const translators = require('internal/modules/esm/translators');
+const { vmModuleLinkHookMap } = require('internal/vm/module');
 
 const FunctionBind = Function.call.bind(Function.prototype.bind);
 
@@ -47,9 +48,13 @@ class Loader {
     this._dynamicInstantiate = undefined;
 
     // Set up context passed to hooks
+    const k = Object.freeze(Object.create(null));
+    vmModuleLinkHookMap.set(k, this);
+
     this.hookContext = Object.assign(Object.create(null), {
       defaultResolve,
       resolve: (specifier, parentURL) => this.resolve(specifier, parentURL),
+      vmModuleLinkHook: k,
     });
   }
 

lib/internal/vm/module.js

@@ -20,6 +20,8 @@ const {
 const { SafePromise } = require('internal/safe_globals');
 const { validateInt32, validateUint32 } = require('internal/validators');
 
+const vmModuleLinkHookMap = new WeakMap();
+
 const {
   ModuleWrap,
   kUninstantiated,
@@ -151,6 +153,15 @@ class Module {
   }
 
   async link(linker) {
+    const linkingFromLoader = vmModuleLinkHookMap.has(linker);
+    if (linkingFromLoader) {
+      const loader = vmModuleLinkHookMap.get(linker);
+      linker = (specifier, parent) =>
+        loader.getModuleJob(specifier, parent.url)
+        .then((j) => j.modulePromise)
+        .then((r) => r.module);
+    }
+
     if (typeof linker !== 'function')
       throw new ERR_INVALID_ARG_TYPE('linker', 'function', linker);
     if (linkingStatusMap.get(this) !== 'unlinked')
@@ -163,6 +174,9 @@ class Module {
 
     const promises = wrap.link(async (specifier) => {
       const m = await linker(specifier, this);
+      if (linkingFromLoader) {
+        return m;
+      }
       if (!m || !wrapMap.has(m))
         throw new ERR_VM_MODULE_NOT_MODULE();
       if (m.context !== this.context)
@@ -246,4 +260,5 @@ module.exports = {
   Module,
   initImportMetaMap,
   wrapToModuleMap,
+  vmModuleLinkHookMap,
 };