module: eliminate performance cost of detection for cjs entry

PR-URL: #52093 Backport-PR-URL: #56927 Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Yagiz Nizipli <[email protected]> Reviewed-By: Joyee Cheung <[email protected]> Reviewed-By: Jacob Smith <[email protected]> Reviewed-By: Richard Lau <[email protected]> Refs: #52697

Author: GeoffreyBooth

benchmark/misc/startup-core.js

@@ -9,6 +9,7 @@ const bench = common.createBenchmark(main,{
 script: [
 'benchmark/fixtures/require-builtins',
 'test/fixtures/semicolon',
+'test/fixtures/snapshot/typescript',
 ],
 mode: ['process','worker'],
 n: [30],

lib/internal/modules/cjs/loader.js

@@ -106,6 +106,7 @@ module.exports ={
  kModuleExportNames,
  kModuleCircularVisited,
  initializeCJS,
+entryPointSource: undefined,// Set below.
  Module,
  wrapSafe,
  kIsMainSymbol,
@@ -1392,8 +1393,15 @@ function wrapSafe(filename, content, cjsModuleInstance, codeCache){
 returnresult;
 }catch(err){
 if(process.mainModule===cjsModuleInstance){
-const{ enrichCJSError }=require('internal/modules/esm/translators');
-enrichCJSError(err,content,filename);
+if(getOptionValue('--experimental-detect-module')){
+// For the main entry point, cache the source to potentially retry as ESM.
+module.exports.entryPointSource=content;
+}else{
+// We only enrich the error (print a warning) if we're sure we're going to for-sure throw it; so if we're
+// retrying as ESM, wait until we know whether we're going to retry before calling `enrichCJSError`.
+const{ enrichCJSError }=require('internal/modules/esm/translators');
+enrichCJSError(err,content,filename);
+}
 }
 throwerr;
 }

lib/internal/modules/helpers.js

@@ -19,6 +19,15 @@ const{
 }=require('internal/errors').codes;
 const{ BuiltinModule }=require('internal/bootstrap/realm');
 
+const{
+shouldRetryAsESM: contextifyShouldRetryAsESM,
+constants: {
+syntaxDetectionErrors: {
+ esmSyntaxErrorMessages,
+ throwsOnlyInCommonJSErrorMessages,
+},
+},
+}=internalBinding('contextify');
 const{ validateString }=require('internal/validators');
 constfs=require('fs');// Import all of `fs` so that it can be monkey-patched.
 constinternalFS=require('internal/fs/utils');
@@ -329,6 +338,31 @@ function urlToFilename(url){
 returnurl;
 }
 
+letesmSyntaxErrorMessagesSet;// Declared lazily in shouldRetryAsESM
+letthrowsOnlyInCommonJSErrorMessagesSet;// Declared lazily in shouldRetryAsESM
+/**
+ * After an attempt to parse a module as CommonJS throws an error, should we try again as ESM?
+ * We only want to try again as ESM if the error is due to syntax that is only valid in ESM; and if the CommonJS parse
+ * throws on an error that would not have been a syntax error in ESM (like via top-level `await` or a lexical
+ * redeclaration of one of the CommonJS variables) then we need to parse again to see if it would have thrown in ESM.
+ * @param{string} errorMessage The string message thrown by V8 when attempting to parse as CommonJS
+ * @param{string} source Module contents
+ */
+functionshouldRetryAsESM(errorMessage,source){
+esmSyntaxErrorMessagesSet??=newSafeSet(esmSyntaxErrorMessages);
+if(esmSyntaxErrorMessagesSet.has(errorMessage)){
+returntrue;
+}
+
+throwsOnlyInCommonJSErrorMessagesSet??=newSafeSet(throwsOnlyInCommonJSErrorMessages);
+if(throwsOnlyInCommonJSErrorMessagesSet.has(errorMessage)){
+return/** @type{boolean} */(contextifyShouldRetryAsESM(source));
+}
+
+returnfalse;
+}
+
+
 // Whether we have started executing any user-provided CJS code.
 // This is set right before we call the wrapped CJS code (not after,
 // in case we are half-way in the execution when internals check this).
@@ -362,6 +396,7 @@ module.exports ={
  loadBuiltinModule,
  makeRequireFunction,
  normalizeReferrerURL,
+ shouldRetryAsESM,
  stripBOM,
  toRealPath,
 hasStartedUserCJSExecution(){

lib/internal/modules/run_main.js

@@ -4,7 +4,6 @@ const{
  StringPrototypeEndsWith,
 }=primordials;
 
-const{ containsModuleSyntax }=internalBinding('contextify');
 const{ getOptionValue }=require('internal/options');
 constpath=require('path');
 const{ pathToFileURL }=require('internal/url');
@@ -85,10 +84,6 @@ function shouldUseESMLoader(mainPath){
 case'commonjs':
 returnfalse;
 default: {// No package.json or no `type` field.
-if(getOptionValue('--experimental-detect-module')){
-// If the first argument of `containsModuleSyntax` is undefined, it will read `mainPath` from the file system.
-returncontainsModuleSyntax(undefined,mainPath);
-}
 returnfalse;
 }
 }
@@ -153,12 +148,43 @@ function runEntryPointWithESMLoader(callback){
  * by `require('module')`) even when the entry point is ESM.
  * This monkey-patchable code is bypassed under `--experimental-default-type=module`.
  * Because of backwards compatibility, this function is exposed publicly via `import{runMain } from 'node:module'`.
+ * When `--experimental-detect-module` is passed, this function will attempt to run ambiguous (no explicit extension, no
+ * `package.json` type field) entry points as CommonJS first; under certain conditions, it will retry running as ESM.
  * @param{string} main - First positional CLI argument, such as `'entry.js'` from `node entry.js`
  */
 functionexecuteUserEntryPoint(main=process.argv[1]){
 constresolvedMain=resolveMainPath(main);
 constuseESMLoader=shouldUseESMLoader(resolvedMain);
-if(useESMLoader){
+
+// Unless we know we should use the ESM loader to handle the entry point per the checks in `shouldUseESMLoader`, first
+// try to run the entry point via the CommonJS loader; and if that fails under certain conditions, retry as ESM.
+letretryAsESM=false;
+if(!useESMLoader){
+constcjsLoader=require('internal/modules/cjs/loader');
+const{ Module }=cjsLoader;
+if(getOptionValue('--experimental-detect-module')){
+try{
+// Module._load is the monkey-patchable CJS module loader.
+Module._load(main,null,true);
+}catch(error){
+constsource=cjsLoader.entryPointSource;
+const{ shouldRetryAsESM }=require('internal/modules/helpers');
+retryAsESM=shouldRetryAsESM(error.message,source);
+// In case the entry point is a large file, such as a bundle,
+// ensure no further references can prevent it being garbage-collected.
+cjsLoader.entryPointSource=undefined;
+if(!retryAsESM){
+const{ enrichCJSError }=require('internal/modules/esm/translators');
+enrichCJSError(error,source,resolvedMain);
+throwerror;
+}
+}
+}else{// `--experimental-detect-module` is not passed
+Module._load(main,null,true);
+}
+}
+
+if(useESMLoader||retryAsESM){
 constmainPath=resolvedMain||main;
 constmainURL=pathToFileURL(mainPath).href;
 
@@ -167,10 +193,6 @@ function executeUserEntryPoint(main = process.argv[1]){
 // even after the event loop stops running.
 returncascadedLoader.import(mainURL,undefined,{__proto__: null},true);
 });
-}else{
-// Module._load is the monkey-patchable CJS module loader.
-const{ Module }=require('internal/modules/cjs/loader');
-Module._load(main,null,true);
 }
 }