Make loadChunkAsync load chunks synchronously

We still return a promise to satisfy our call signatures but resolution is now synchronously performed by `require`

Author: lukesandberg

turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.ts

@@ -95,7 +95,8 @@ function loadChunk(chunkData: ChunkData, source?: SourceInfo): void {
 const loadedChunks = new Set<ChunkPath>()
 const unsupportedLoadChunk = Promise.resolve(undefined)
 const loadedChunk = Promise.resolve(undefined)
-const chunkCache = new Map<ChunkPath, Promise<any> | null>()
+// Holds either a rejected promise or `loadedChunk` for success
+const chunkCache = new Map<ChunkPath, Promise<void>>()
 
 function clearChunkCache() {
   chunkCache.clear()
@@ -143,47 +144,30 @@ function loadChunkPath(chunkPath: ChunkPath, source?: SourceInfo): void {
   }
 }
 
-async function loadChunkAsyncUncached(
-  source: SourceInfo,
-  chunkPath: ChunkPath
-): Promise<void> {
+function loadChunkUncached(chunkPath: ChunkPath) {
+  // resolve to an absolute path to simplify `require` handling
   const resolved = path.resolve(RUNTIME_ROOT, chunkPath)
 
-  try {
-    // use await to ensure that evaluation happens in another microtask
-    // Because we are using a resolved absolute path require shouldn't waste time probing node_modules.
-    const exports = await require(resolved)
-    const chunkModules: CompressedModuleFactories = exports
-    for (const [moduleId, moduleFactory] of Object.entries(chunkModules)) {
-      if (!moduleFactories[moduleId]) {
-        if (Array.isArray(moduleFactory)) {
-          const [moduleFactoryFn, otherIds] = moduleFactory
-          moduleFactories[moduleId] = moduleFactoryFn
-          for (const otherModuleId of otherIds) {
-            moduleFactories[otherModuleId] = moduleFactoryFn
-          }
-        } else {
-          moduleFactories[moduleId] = moduleFactory
+  const chunkModules: CompressedModuleFactories = require(resolved)
+  for (const [moduleId, moduleFactory] of Object.entries(chunkModules)) {
+    if (!moduleFactories[moduleId]) {
+      if (Array.isArray(moduleFactory)) {
+        const [moduleFactoryFn, otherIds] = moduleFactory
+        moduleFactories[moduleId] = moduleFactoryFn
+        for (const otherModuleId of otherIds) {
+          moduleFactories[otherModuleId] = moduleFactoryFn
         }
+      } else {
+        moduleFactories[moduleId] = moduleFactory
       }
     }
-  } catch (e) {
-    let errorMessage = `Failed to load chunk ${chunkPath}`
-
-    if (source) {
-      errorMessage += ` from ${stringifySourceInfo(source)}`
-    }
-
-    throw new Error(errorMessage, {
-      cause: e,
-    })
   }
 }
 
 function loadChunkAsync(
   source: SourceInfo,
   chunkData: ChunkData
-): Promise<any> {
+): Promise<void> {
   const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path
   if (!isJs(chunkPath)) {
     // We only support loading JS chunks in Node.js.
@@ -193,14 +177,27 @@ function loadChunkAsync(
 
   let entry = chunkCache.get(chunkPath)
   if (entry === undefined) {
-    const resolve = chunkCache.set.bind(chunkCache, chunkPath, null)
-    // A new Promise ensures callers that don't handle rejection will still trigger one unhandled rejection.
-    // Handling the rejection will not trigger unhandled rejections.
-    entry = loadChunkAsyncUncached(source, chunkPath).then(resolve)
+    try {
+      // Load the chunk synchronously
+      loadChunkUncached(chunkPath)
+      entry = loadedChunk
+    } catch (e) {
+      let errorMessage = `Failed to load chunk ${chunkPath}`
+      if (source) {
+        errorMessage += ` from ${stringifySourceInfo(source)}`
+      }
+
+      // Cache the failure promise, future requests will also get this same rejection
+      entry = Promise.reject(
+        new Error(errorMessage, {
+          cause: e,
+        })
+      )
+    }
     chunkCache.set(chunkPath, entry)
   }
   // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.
-  return entry === null ? loadedChunk : entry
+  return entry
 }
 
 function loadChunkAsyncByUrl(source: SourceInfo, chunkUrl: string) {