vm: use internal versions of compileFunction and Script

Instead of using the public versions of the vm APIs internally, use the internal versions so that we can skip unnecessary argument validation. The public versions would need special care to the generation of host-defined options to hit the isolate compilation cache when imporModuleDynamically isn't used, while internally it's almost always used, so this allows us to handle the host-defined options separately. PR-URL: #50137 Refs: #35375 Reviewed-By: Geoffrey Booth <[email protected]> Reviewed-By: Yagiz Nizipli <[email protected]> Reviewed-By: Chengzhong Wu <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]>

Author: joyeecheung

lib/internal/modules/cjs/loader.js

@@ -52,6 +52,7 @@ const{
  SafeMap,
  SafeWeakMap,
  String,
+ Symbol,
  StringPrototypeCharAt,
  StringPrototypeCharCodeAt,
  StringPrototypeEndsWith,
@@ -84,7 +85,12 @@ const{
  setOwnProperty,
  getLazy,
 }=require('internal/util');
-const{ internalCompileFunction }=require('internal/vm');
+const{
+ internalCompileFunction,
+ makeContextifyScript,
+ runScriptInThisContext,
+}=require('internal/vm');
+
 constassert=require('internal/assert');
 constfs=require('fs');
 constpath=require('path');
@@ -1240,7 +1246,6 @@ Module.prototype.require = function(id){
 letresolvedArgv;
 lethasPausedEntry=false;
 /** @type{import('vm').Script} */
-letScript;
 
 /**
  * Wraps the given content in a script and runs it in a new context.
@@ -1250,47 +1255,49 @@ let Script;
  * @param{object} codeCache The SEA code cache
  */
 functionwrapSafe(filename,content,cjsModuleInstance,codeCache){
+consthostDefinedOptionId=Symbol(`cjs:${filename}`);
+asyncfunctionimportModuleDynamically(specifier,_,importAttributes){
+constcascadedLoader=getCascadedLoader();
+returncascadedLoader.import(specifier,normalizeReferrerURL(filename),
+importAttributes);
+}
 if(patched){
-constwrapper=Module.wrap(content);
-if(Script===undefined){
-({ Script }=require('vm'));
-}
-constscript=newScript(wrapper,{
- filename,
-lineOffset: 0,
-importModuleDynamically: async(specifier,_,importAttributes)=>{
-constcascadedLoader=getCascadedLoader();
-returncascadedLoader.import(specifier,normalizeReferrerURL(filename),
-importAttributes);
-},
-});
+constwrapped=Module.wrap(content);
+constscript=makeContextifyScript(
+wrapped,// code
+filename,// filename
+0,// lineOffset
+0,// columnOffset
+undefined,// cachedData
+false,// produceCachedData
+undefined,// parsingContext
+hostDefinedOptionId,// hostDefinedOptionId
+importModuleDynamically,// importModuleDynamically
+);
 
 // Cache the source map for the module if present.
 if(script.sourceMapURL){
 maybeCacheSourceMap(filename,content,this,false,undefined,script.sourceMapURL);
 }
 
-returnscript.runInThisContext({
-displayErrors: true,
-});
+returnrunScriptInThisContext(script,true,false);
 }
 
+constparams=['exports','require','module','__filename','__dirname'];
 try{
-constresult=internalCompileFunction(content,[
-'exports',
-'require',
-'module',
-'__filename',
-'__dirname',
-],{
- filename,
-cachedData: codeCache,
-importModuleDynamically(specifier,_,importAttributes){
-constcascadedLoader=getCascadedLoader();
-returncascadedLoader.import(specifier,normalizeReferrerURL(filename),
-importAttributes);
-},
-});
+constresult=internalCompileFunction(
+content,// code,
+filename,// filename
+0,// lineOffset
+0,// columnOffset,
+codeCache,// cachedData
+false,// produceCachedData
+undefined,// parsingContext
+undefined,// contextExtensions
+params,// params
+hostDefinedOptionId,// hostDefinedOptionId
+importModuleDynamically,// importModuleDynamically
+);
 
 // The code cache is used for SEAs only.
 if(codeCache&&

lib/internal/modules/esm/translators.js

@@ -15,6 +15,7 @@ const{
  StringPrototypeReplaceAll,
  StringPrototypeSlice,
  StringPrototypeStartsWith,
+ Symbol,
  SyntaxErrorPrototype,
 globalThis: { WebAssembly },
 }=primordials;
@@ -192,19 +193,29 @@ function enrichCJSError(err, content, filename){
  */
 functionloadCJSModule(module,source,url,filename){
 letcompiledWrapper;
+asyncfunctionimportModuleDynamically(specifier,_,importAttributes){
+returnasyncESM.esmLoader.import(specifier,url,importAttributes);
+}
 try{
-compiledWrapper=internalCompileFunction(source,[
-'exports',
-'require',
-'module',
-'__filename',
-'__dirname',
-],{
- filename,
-importModuleDynamically(specifier,_,importAttributes){
-returnasyncESM.esmLoader.import(specifier,url,importAttributes);
-},
-}).function;
+compiledWrapper=internalCompileFunction(
+source,// code,
+filename,// filename
+0,// lineOffset
+0,// columnOffset,
+undefined,// cachedData
+false,// produceCachedData
+undefined,// parsingContext
+undefined,// contextExtensions
+[// params
+'exports',
+'require',
+'module',
+'__filename',
+'__dirname',
+],
+Symbol(`cjs:${filename}`),// hostDefinedOptionsId
+importModuleDynamically,// importModuleDynamically
+).function;
 }catch(err){
 enrichCJSError(err,source,url);
 throwerr;

lib/internal/process/execution.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const{
+ Symbol,
  RegExpPrototypeExec,
  globalThis,
 }=primordials;
@@ -25,7 +26,9 @@ const{
  emitAfter,
  popAsyncContext,
 }=require('internal/async_hooks');
-
+const{
+ makeContextifyScript, runScriptInThisContext,
+}=require('internal/vm');
 // shouldAbortOnUncaughtToggle is a typed array for faster
 // communication with JS.
 const{ shouldAbortOnUncaughtToggle }=internalBinding('util');
@@ -53,7 +56,6 @@ function evalModule(source, print){
 
 functionevalScript(name,body,breakFirstLine,print,shouldLoadESM=false){
 constCJSModule=require('internal/modules/cjs/loader').Module;
-const{ kVmBreakFirstLineSymbol }=require('internal/util');
 const{ pathToFileURL }=require('internal/url');
 
 constcwd=tryGetCwd();
@@ -79,16 +81,25 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false){
  `;
 globalThis.__filename=name;
 RegExpPrototypeExec(/^/,'');// Necessary to reset RegExp statics before user code runs.
-constresult=module._compile(script,`${name}-wrapper`)(()=>
-require('vm').runInThisContext(body,{
-filename: name,
-displayErrors: true,
-[kVmBreakFirstLineSymbol]: !!breakFirstLine,
-importModuleDynamically(specifier,_,importAttributes){
-constloader=asyncESM.esmLoader;
-returnloader.import(specifier,baseUrl,importAttributes);
-},
-}));
+constresult=module._compile(script,`${name}-wrapper`)(()=>{
+consthostDefinedOptionId=Symbol(name);
+asyncfunctionimportModuleDynamically(specifier,_,importAttributes){
+constloader=asyncESM.esmLoader;
+returnloader.import(specifier,baseUrl,importAttributes);
+}
+constscript=makeContextifyScript(
+body,// code
+name,// filename,
+0,// lineOffset
+0,// columnOffset,
+undefined,// cachedData
+false,// produceCachedData
+undefined,// parsingContext
+hostDefinedOptionId,// hostDefinedOptionId
+importModuleDynamically,// importModuleDynamically
+);
+returnrunScriptInThisContext(script,true,!!breakFirstLine);
+});
 if(print){
 const{ log }=require('internal/console/global');
 log(result);

lib/internal/vm.js

@@ -1,32 +1,26 @@
 'use strict';
 
 const{
-ArrayPrototypeForEach,
+ReflectApply,
  Symbol,
 }=primordials;
 
 const{
+ ContextifyScript,
  compileFunction,
 isContext: _isContext,
 }=internalBinding('contextify');
+const{
+ runInContext,
+}=ContextifyScript.prototype;
 const{
  default_host_defined_options,
 }=internalBinding('symbols');
 const{
- validateArray,
- validateBoolean,
- validateBuffer,
  validateFunction,
  validateObject,
- validateString,
- validateStringArray,
  kValidateObjectAllowArray,
- kValidateObjectAllowNullable,
- validateInt32,
 }=require('internal/validators');
-const{
-ERR_INVALID_ARG_TYPE,
-}=require('internal/errors').codes;
 
 functionisContext(object){
 validateObject(object,'object',kValidateObjectAllowArray);
@@ -50,49 +44,20 @@ function getHostDefinedOptionId(importModuleDynamically, filename){
 returnSymbol(filename);
 }
 
-functioninternalCompileFunction(code,params,options){
-validateString(code,'code');
-if(params!==undefined){
-validateStringArray(params,'params');
-}
-const{
- filename ='',
- columnOffset =0,
- lineOffset =0,
- cachedData =undefined,
- produceCachedData =false,
- parsingContext =undefined,
- contextExtensions =[],
- importModuleDynamically,
-}=options;
-
-validateString(filename,'options.filename');
-validateInt32(columnOffset,'options.columnOffset');
-validateInt32(lineOffset,'options.lineOffset');
-if(cachedData!==undefined)
-validateBuffer(cachedData,'options.cachedData');
-validateBoolean(produceCachedData,'options.produceCachedData');
-if(parsingContext!==undefined){
-if(
-typeofparsingContext!=='object'||
-parsingContext===null||
-!isContext(parsingContext)
-){
-thrownewERR_INVALID_ARG_TYPE(
-'options.parsingContext',
-'Context',
-parsingContext,
-);
-}
-}
-validateArray(contextExtensions,'options.contextExtensions');
-ArrayPrototypeForEach(contextExtensions,(extension,i)=>{
-constname=`options.contextExtensions[${i}]`;
-validateObject(extension,name,kValidateObjectAllowNullable);
+functionregisterImportModuleDynamically(referrer,importModuleDynamically){
+const{ importModuleDynamicallyWrap }=require('internal/vm/module');
+const{ registerModule }=require('internal/modules/esm/utils');
+registerModule(referrer,{
+__proto__: null,
+importModuleDynamically:
+importModuleDynamicallyWrap(importModuleDynamically),
 });
+}
 
-consthostDefinedOptionId=
-getHostDefinedOptionId(importModuleDynamically,filename);
+functioninternalCompileFunction(
+code,filename,lineOffset,columnOffset,
+cachedData,produceCachedData,parsingContext,contextExtensions,
+params,hostDefinedOptionId,importModuleDynamically){
 constresult=compileFunction(
 code,
 filename,
@@ -119,23 +84,65 @@ function internalCompileFunction(code, params, options){
 }
 
 if(importModuleDynamically!==undefined){
-validateFunction(importModuleDynamically,
-'options.importModuleDynamically');
-const{ importModuleDynamicallyWrap }=require('internal/vm/module');
-constwrapped=importModuleDynamicallyWrap(importModuleDynamically);
-constfunc=result.function;
-const{ registerModule }=require('internal/modules/esm/utils');
-registerModule(func,{
-__proto__: null,
-importModuleDynamically: wrapped,
-});
+registerImportModuleDynamically(result.function,importModuleDynamically);
 }
 
 returnresult;
 }
 
+functionmakeContextifyScript(code,
+filename,
+lineOffset,
+columnOffset,
+cachedData,
+produceCachedData,
+parsingContext,
+hostDefinedOptionId,
+importModuleDynamically){
+letscript;
+// Calling `ReThrow()` on a native TryCatch does not generate a new
+// abort-on-uncaught-exception check. A dummy try/catch in JS land
+// protects against that.
+try{// eslint-disable-line no-useless-catch
+script=newContextifyScript(code,
+filename,
+lineOffset,
+columnOffset,
+cachedData,
+produceCachedData,
+parsingContext,
+hostDefinedOptionId);
+}catch(e){
+throwe;/* node-do-not-add-exception-line */
+}
+
+if(importModuleDynamically!==undefined){
+registerImportModuleDynamically(script,importModuleDynamically);
+}
+returnscript;
+}
+
+// Internal version of vm.Script.prototype.runInThisContext() which skips
+// argument validation.
+functionrunScriptInThisContext(script,displayErrors,breakOnFirstLine){
+returnReflectApply(
+runInContext,
+script,
+[
+null,// sandbox - use current context
+-1,// timeout
+displayErrors,// displayErrors
+false,// breakOnSigint
+breakOnFirstLine,// breakOnFirstLine
+],
+);
+}
+
 module.exports={
  getHostDefinedOptionId,
  internalCompileFunction,
  isContext,
+ makeContextifyScript,
+ registerImportModuleDynamically,
+ runScriptInThisContext,
 };