vm: flip Module#link's signature

The specifier parameter is deemed to be more essential than referencingModule. Flipping the parameter order allows developers to write simple linker functions that only take in a specifier. PR-URL: #18471 Reviewed-By: Tiancheng "Timothy" Gu <[email protected]> Reviewed-By: Colin Ihrig <[email protected]> Reviewed-By: Michaël Zasso <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Ruben Bridgewater <[email protected]>

Author: devsnek

doc/api/vm.md

@@ -117,7 +117,7 @@ const contextifiedSandbox = vm.createContext({secret: 42 });
 // "foo" module every time it is called. In a full-fledged module system, a
 // cache would probably be used to avoid duplicated modules.
 
-asyncfunctionlinker(referencingModule, specifier){
+asyncfunctionlinker(specifier, referencingModule){
 if (specifier ==='foo'){
 returnnewvm.Module(`
  // The "secret" variable refers to the global variable we added to
@@ -319,14 +319,13 @@ can only be called once per module.
 
 Two parameters will be passed to the `linker` function:
 
--`referencingModule` The `Module` object `link()` is called on.
 -`specifier` The specifier of the requested module:
-
 <!-- eslint-skip -->
 ```js
 importfoofrom'foo';
 // ^^^^^ the module specifier
 ```
+-`referencingModule` The `Module` object `link()` is called on.
 
 The function is expected to return a `Module` object or a `Promise` that
 eventually resolves to a `Module` object. The returned `Module` must satisfy the

lib/internal/vm/Module.js

@@ -135,7 +135,7 @@ class Module{
 constpromises=[];
 wrap.link((specifier)=>{
 constp=(async()=>{
-constm=awaitlinker(this,specifier);
+constm=awaitlinker(specifier,this);
 if(!m||!wrapMap.has(m))
 thrownewerrors.Error('ERR_VM_MODULE_NOT_MODULE');
 if(m.context!==this.context)

test/parallel/test-vm-module-errors.js

@@ -109,7 +109,7 @@ async function checkModuleState(){
 
 {
 constm=newModule('import "foo"');
-awaitm.link(common.mustCall(async(module,specifier)=>{
+awaitm.link(common.mustCall(async(specifier,module)=>{
 assert.strictEqual(module,m);
 assert.strictEqual(specifier,'foo');
 assert.strictEqual(m.linkingStatus,'linking');

test/parallel/test-vm-module-link.js

@@ -18,7 +18,7 @@ async function simple(){
 
 assert.deepStrictEqual(bar.dependencySpecifiers,['foo']);
 
-awaitbar.link(common.mustCall((module,specifier)=>{
+awaitbar.link(common.mustCall((specifier,module)=>{
 assert.strictEqual(module,bar);
 assert.strictEqual(specifier,'foo');
 returnfoo;
@@ -38,7 +38,7 @@ async function depth(){
  import ${parentName} from '${parentName}'
  export default ${parentName};
  `);
-awaitmod.link(common.mustCall((module,specifier)=>{
+awaitmod.link(common.mustCall((specifier,module)=>{
 assert.strictEqual(module,mod);
 assert.strictEqual(specifier,parentName);
 returnparentModule;
@@ -68,10 +68,10 @@ async function circular(){
  return foo;
  }
  `);
-awaitfoo.link(common.mustCall(async(fooModule,fooSpecifier)=>{
+awaitfoo.link(common.mustCall(async(fooSpecifier,fooModule)=>{
 assert.strictEqual(fooModule,foo);
 assert.strictEqual(fooSpecifier,'bar');
-awaitbar.link(common.mustCall((barModule,barSpecifier)=>{
+awaitbar.link(common.mustCall((barSpecifier,barModule)=>{
 assert.strictEqual(barModule,bar);
 assert.strictEqual(barSpecifier,'foo');
 assert.strictEqual(foo.linkingStatus,'linking');
@@ -111,7 +111,7 @@ async function circular2(){
 };
 constmoduleMap=newMap();
 constrootModule=newModule(sourceMap.root,{url: 'vm:root'});
-asyncfunctionlink(referencingModule,specifier){
+asyncfunctionlink(specifier,referencingModule){
 if(moduleMap.has(specifier)){
 returnmoduleMap.get(specifier);
 }