fix #4461, fix #4467: esm evaluation fixes

Author: evanw

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+* Fix ES module evaluation when an error is thrown ([#4461](https://github.com/evanw/esbuild/issues/4461), [#4467](https://github.com/evanw/esbuild/pull/4467))
+
+    If an error is thrown during ES module evaluation, esbuild previously didn't preserve the state of the module for subsequent module references. This was observable if `import()` is used to import the module multiple times. The thrown error is supposed to be thrown by every call to `import()`, not just the first. With this release, esbuild will now throw the same error every time you call `import()` on a module that throws during its evaluation.
+
 * Fix some edge cases around the `new` operator ([#4477](https://github.com/evanw/esbuild/issues/4477))
 
     Previously esbuild incorrectly printed certain edge cases involving complex expressions inside the target of a `new` expression (specifically an optional chain and/or a tagged template literal). The generated code for the `new` target was not correctly wrapped with parentheses, and either contained a syntax error or had different semantics. These edge cases have been fixed so that they now correctly wrap the `new` target in parentheses. Here is an example of some affected code:

internal/runtime/runtime.go

@@ -170,10 +170,22 @@ func Source(unsupportedJSFeatures compat.JSFeature) logger.Source {
 		// This is for lazily-initialized ESM code. This has two implementations, a
 		// compact one for minified code and a verbose one that generates friendly
 		// names in V8's profiler and in stack traces.
-		export var __esm = (fn, res) => function __init() {
-			return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res
+		export var __esm = (fn, res, err) => function __init() {
+			if (err) throw err[0]
+			try {
+				return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res
+			} catch (e) {
+				throw (err = [e]), e
+			}
+		}
+		export var __esmMin = (fn, res, err) => () => {
+			if (err) throw err[0]
+			try {
+				return fn && (res = fn(fn = 0)), res
+			} catch (e) {
+				throw (err = [e]), e
+			}
 		}
-		export var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res)
 
 		// Wraps a CommonJS closure and returns a require() function. This has two
 		// implementations, a compact one for minified code and a verbose one that

scripts/end-to-end-tests.js

@@ -2104,6 +2104,43 @@ for (const minify of [[], ['--minify']]) {
         export let async = async () => { if (42 !== await B()) throw 'fail' }
       `,
     }, { async: true }),
+
+    // https://github.com/evanw/esbuild/issues/4461
+    test(['--bundle', 'in.js', '--outfile=node.js', '--format=esm'].concat(minify), {
+      'in.js': `export let async = async () => {
+        let error
+        for (let i = 0; i < 3; i++) {
+          try {
+            await import('./foo')
+            throw new Error('Expected an error')
+          } catch (e) {
+            if (!e || e.message !== 'stop') throw 'fail ' + i + ': ' + e
+            if (i > 0 && e !== error) throw 'fail ' + i + ': wrong object'
+            error = e
+          }
+        }
+      }`,
+      'foo.js': `
+        export let foo
+        throw new Error('stop')
+      `,
+    }, { async: true }),
+    test(['--bundle', 'in.js', '--outfile=node.js', '--format=esm'].concat(minify), {
+      'in.js': `export let async = async () => {
+        for (let i = 0; i < 3; i++) {
+          try {
+            await import('./foo')
+            throw new Error('Expected an error')
+          } catch (e) {
+            if (e !== null) throw 'fail ' + i + ': ' + e
+          }
+        }
+      }`,
+      'foo.js': `
+        export let foo
+        throw null
+      `,
+    }, { async: true }),
   )
 }