lib,src: iterate module requests of a module wrap in JS

Avoid repetitively calling into JS callback from C++ in `ModuleWrap::Link`. This removes the convoluted callback style of the internal `ModuleWrap` link step. PR-URL: #52058 Backport-PR-URL: #56927 Reviewed-By: Joyee Cheung <[email protected]> Refs: #52697

Author: legendecas

lib/internal/modules/esm/loader.js

@@ -318,7 +318,7 @@ class ModuleLoader{
  * @param{object} importAttributes import attributes from the import statement.
  * @returns{ModuleJobBase}
  */
-getModuleWrapForRequire(specifier,parentURL,importAttributes){
+getModuleJobForRequire(specifier,parentURL,importAttributes){
 assert(getOptionValue('--experimental-require-module'));
 
 if(canParse(specifier)){

lib/internal/modules/esm/module_job.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const{
+ Array,
  ArrayPrototypeJoin,
- ArrayPrototypePush,
  ArrayPrototypeSome,
  FunctionPrototype,
  ObjectSetPrototypeOf,
@@ -82,31 +82,8 @@ class ModuleJob extends ModuleJobBase{
 this.modulePromise=PromiseResolve(this.modulePromise);
 }
 
-// Wait for the ModuleWrap instance being linked with all dependencies.
-constlink=async()=>{
-this.module=awaitthis.modulePromise;
-assert(this.moduleinstanceofModuleWrap);
-
-// Explicitly keeping track of dependency jobs is needed in order
-// to flatten out the dependency graph below in `_instantiate()`,
-// so that circular dependencies can't cause a deadlock by two of
-// these `link` callbacks depending on each other.
-constdependencyJobs=[];
-constpromises=this.module.link(async(specifier,attributes)=>{
-constjob=awaitthis.#loader.getModuleJob(specifier,url,attributes);
-debug(`async link() ${this.url} -> ${specifier}`,job);
-ArrayPrototypePush(dependencyJobs,job);
-returnjob.modulePromise;
-});
-
-if(promises!==undefined){
-awaitSafePromiseAllReturnVoid(promises);
-}
-
-returnSafePromiseAllReturnArrayLike(dependencyJobs);
-};
 // Promise for the list of all dependencyJobs.
-this.linked=link();
+this.linked=this._link();
 // This promise is awaited later anyway, so silence
 // 'unhandled rejection' warnings.
 PromisePrototypeThen(this.linked,undefined,noop);
@@ -116,6 +93,49 @@ class ModuleJob extends ModuleJobBase{
 this.instantiated=undefined;
 }
 
+/**
+ * Iterates the module requests and links with the loader.
+ * @returns{Promise<ModuleJob[]>} Dependency module jobs.
+ */
+async_link(){
+this.module=awaitthis.modulePromise;
+assert(this.moduleinstanceofModuleWrap);
+
+constmoduleRequests=this.module.getModuleRequests();
+// Explicitly keeping track of dependency jobs is needed in order
+// to flatten out the dependency graph below in `_instantiate()`,
+// so that circular dependencies can't cause a deadlock by two of
+// these `link` callbacks depending on each other.
+// Create an ArrayLike to avoid calling into userspace with `.then`
+// when returned from the async function.
+constdependencyJobs=Array(moduleRequests.length);
+ObjectSetPrototypeOf(dependencyJobs,null);
+
+// Specifiers should be aligned with the moduleRequests array in order.
+constspecifiers=Array(moduleRequests.length);
+constmodulePromises=Array(moduleRequests.length);
+// Iterate with index to avoid calling into userspace with `Symbol.iterator`.
+for(letidx=0;idx<moduleRequests.length;idx++){
+const{ specifier, attributes }=moduleRequests[idx];
+
+constdependencyJobPromise=this.#loader.getModuleJob(
+specifier,this.url,attributes,
+);
+constmodulePromise=PromisePrototypeThen(dependencyJobPromise,(job)=>{
+debug(`async link() ${this.url} -> ${specifier}`,job);
+dependencyJobs[idx]=job;
+returnjob.modulePromise;
+});
+modulePromises[idx]=modulePromise;
+specifiers[idx]=specifier;
+}
+
+constmodules=awaitSafePromiseAllReturnArrayLike(modulePromises);
+this.module.link(specifiers,modules);
+
+returndependencyJobs;
+}
+
 instantiate(){
 if(this.instantiated===undefined){
 this.instantiated=this._instantiate();
@@ -269,18 +289,20 @@ class ModuleJobSync extends ModuleJobBase{
 super(url,importAttributes,moduleWrap,isMain,inspectBrk,true);
 assert(this.moduleinstanceofModuleWrap);
 this.#loader =loader;
-constmoduleRequests=this.module.getModuleRequestsSync();
-constlinked=[];
+constmoduleRequests=this.module.getModuleRequests();
+// Specifiers should be aligned with the moduleRequests array in order.
+constspecifiers=Array(moduleRequests.length);
+constmodules=Array(moduleRequests.length);
+constjobs=Array(moduleRequests.length);
 for(leti=0;i<moduleRequests.length;++i){
-const{0: specifier,1: attributes}=moduleRequests[i];
-constjob=this.#loader.getModuleWrapForRequire(specifier,url,attributes);
-constisLast=(i===moduleRequests.length-1);
-// TODO(joyeecheung): make the resolution callback deal with both promisified
-// an raw module wraps, then we don't need to wrap it with a promise here.
-this.module.cacheResolvedWrapsSync(specifier,PromiseResolve(job.module),isLast);
-ArrayPrototypePush(linked,job);
+const{ specifier, attributes }=moduleRequests[i];
+constjob=this.#loader.getModuleJobForRequire(specifier,url,attributes);
+specifiers[i]=specifier;
+modules[i]=job.module;
+jobs[i]=job;
 }
-this.linked=linked;
+this.module.link(specifiers,modules);
+this.linked=jobs;
 }
 
 getmodulePromise(){

lib/internal/vm/module.js

@@ -2,16 +2,20 @@
 
 constassert=require('internal/assert');
 const{
+ Array,
  ArrayIsArray,
  ArrayPrototypeForEach,
  ArrayPrototypeIndexOf,
+ ArrayPrototypeMap,
  ArrayPrototypeSome,
  ObjectDefineProperty,
  ObjectGetPrototypeOf,
  ObjectPrototypeHasOwnProperty,
  ObjectSetPrototypeOf,
+ PromiseResolve,
+ PromisePrototypeThen,
  ReflectApply,
-SafePromiseAllReturnVoid,
+SafePromiseAllReturnArrayLike,
  Symbol,
  SymbolToStringTag,
  TypeError,
@@ -293,44 +297,61 @@ class SourceTextModule extends Module{
  importModuleDynamically,
 });
 
-this[kLink]=async(linker)=>{
-this.#statusOverride ='linking';
+this[kDependencySpecifiers]=undefined;
+}
 
-constpromises=this[kWrap].link(async(identifier,attributes)=>{
-constmodule=awaitlinker(identifier,this,{ attributes,assert: attributes});
-if(!isModule(module)){
-thrownewERR_VM_MODULE_NOT_MODULE();
-}
-if(module.context!==this.context){
-thrownewERR_VM_MODULE_DIFFERENT_CONTEXT();
-}
-if(module.status==='errored'){
-thrownewERR_VM_MODULE_LINK_FAILURE(`request for '${identifier}' resolved to an errored module`,module.error);
-}
-if(module.status==='unlinked'){
-awaitmodule[kLink](linker);
-}
-returnmodule[kWrap];
+async[kLink](linker){
+this.#statusOverride ='linking';
+
+constmoduleRequests=this[kWrap].getModuleRequests();
+// Iterates the module requests and links with the linker.
+// Specifiers should be aligned with the moduleRequests array in order.
+constspecifiers=Array(moduleRequests.length);
+constmodulePromises=Array(moduleRequests.length);
+// Iterates with index to avoid calling into userspace with `Symbol.iterator`.
+for(letidx=0;idx<moduleRequests.length;idx++){
+const{ specifier, attributes }=moduleRequests[idx];
+
+constlinkerResult=linker(specifier,this,{
+attributes,
+assert: attributes,
 });
+constmodulePromise=PromisePrototypeThen(
+PromiseResolve(linkerResult),async(module)=>{
+if(!isModule(module)){
+thrownewERR_VM_MODULE_NOT_MODULE();
+}
+if(module.context!==this.context){
+thrownewERR_VM_MODULE_DIFFERENT_CONTEXT();
+}
+if(module.status==='errored'){
+thrownewERR_VM_MODULE_LINK_FAILURE(`request for '${specifier}' resolved to an errored module`,module.error);
+}
+if(module.status==='unlinked'){
+awaitmodule[kLink](linker);
+}
+returnmodule[kWrap];
+});
+modulePromises[idx]=modulePromise;
+specifiers[idx]=specifier;
+}
 
-try{
-if(promises!==undefined){
-awaitSafePromiseAllReturnVoid(promises);
-}
-}catch(e){
-this.#error =e;
-throwe;
-}finally{
-this.#statusOverride =undefined;
-}
-};
-
-this[kDependencySpecifiers]=undefined;
+try{
+constmodules=awaitSafePromiseAllReturnArrayLike(modulePromises);
+this[kWrap].link(specifiers,modules);
+}catch(e){
+this.#error =e;
+throwe;
+}finally{
+this.#statusOverride =undefined;
+}
 }
 
 getdependencySpecifiers(){
 validateInternalField(this,kDependencySpecifiers,'SourceTextModule');
-this[kDependencySpecifiers]??=this[kWrap].getStaticDependencySpecifiers();
+// TODO(legendecas): add a new getter to expose the import attributes as the value type
+// of [[RequestedModules]] is changed in https://tc39.es/proposal-import-attributes/#table-cyclic-module-fields.
+this[kDependencySpecifiers]??=ArrayPrototypeMap(this[kWrap].getModuleRequests(),(request)=>request.specifier);
 returnthis[kDependencySpecifiers];
 }
 
@@ -392,10 +413,10 @@ class SyntheticModule extends Module{
  context,
  identifier,
 });
+}
 
-this[kLink]=()=>this[kWrap].link(()=>{
-assert.fail('link callback should not be called');
-});
+[kLink](){
+/** nothing to do for synthetic modules */
 }
 
 setExport(name,value){

src/env_properties.h

@@ -71,6 +71,7 @@
  V(args_string, "args") \
  V(asn1curve_string, "asn1Curve") \
  V(async_ids_stack_string, "async_ids_stack") \
+ V(attributes_string, "attributes") \
  V(base_string, "base") \
  V(bits_string, "bits") \
  V(block_list_string, "blockList") \
@@ -303,6 +304,7 @@
  V(sni_context_string, "sni_context") \
  V(source_string, "source") \
  V(source_map_url_string, "sourceMapURL") \
+ V(specifier_string, "specifier") \
  V(stack_string, "stack") \
  V(standard_name_string, "standardName") \
  V(start_time_string, "startTime") \
@@ -377,6 +379,7 @@
  V(intervalhistogram_constructor_template, v8::FunctionTemplate) \
  V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate) \
  V(message_port_constructor_template, v8::FunctionTemplate) \
+ V(module_wrap_constructor_template, v8::FunctionTemplate) \
  V(microtask_queue_ctor_template, v8::FunctionTemplate) \
  V(pipe_constructor_template, v8::FunctionTemplate) \
  V(promise_wrap_template, v8::ObjectTemplate) \