Add fallback in helpers when SuppressedError does not exist

src/compiler/factory/emitHelpers.ts

@@ -1425,26 +1425,31 @@ export const disposeResourcesHelper: UnscopedEmitHelper = {
     importName: "__disposeResources",
     scoped: false,
     text: `
-        var __disposeResources = (this && this.__disposeResources) || function (env) {
-            function fail(e) {
-                env.error = env.hasError ? new SuppressedError(e, env.error) : e;
-                env.hasError = true;
-            }
-            function next() {
-                while (env.stack.length) {
-                    var rec = env.stack.pop();
-                    try {
-                        var result = rec.dispose && rec.dispose.call(rec.value);
-                        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    catch (e) {
-                        fail(e);
+        var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+            return function (env) {
+                function fail(e) {
+                    env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+                    env.hasError = true;
+                }
+                function next() {
+                    while (env.stack.length) {
+                        var rec = env.stack.pop();
+                        try {
+                            var result = rec.dispose && rec.dispose.call(rec.value);
+                            if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                        }
+                        catch (e) {
+                            fail(e);
+                        }
                     }
+                    if (env.hasError) throw env.error;
                 }
-                if (env.hasError) throw env.error;
-            }
-            return next();
-        };`
+                return next();
+            };
+        })(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+            var e = new Error(message);
+            return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+        });`
 };
 
 let allUnscopedEmitHelpers: ReadonlyMap<string, UnscopedEmitHelper> | undefined;

src/testRunner/unittests/evaluation/awaitUsingDeclarations.ts

@@ -175,6 +175,53 @@ describe("unittests:: evaluation:: awaitUsingDeclarations", () => {
         ]);
     });
 
+    it("'await using' in Block, 'throw' in body and dispose, no global SuppressedError (es2018)", async () => {
+        const { main, output } = evaluator.evaluateTypeScript(`
+        export const output: any[] = [];
+
+        const disposable = {
+            async [Symbol.asyncDispose]() {
+                output.push("disposed");
+                throw "dispose error";
+            }
+        };
+
+        function body() {
+            output.push("body");
+            throw "body error";
+        }
+
+        export async function main() {
+            output.push("before try");
+            try {
+                output.push("enter try");
+                await using _ = disposable;
+                body();
+                output.push("exit try");
+            }
+            catch (e) {
+                output.push(e);
+            }
+            output.push("after try");
+        }
+        `, { target: ts.ScriptTarget.ES2018 });
+
+        await main();
+
+        assert.deepEqual(output.slice(0, 4), [
+            "before try",
+            "enter try",
+            "body",
+            "disposed"]);
+        assert.instanceOf(output[4], Error);
+        assert.strictEqual(output[4].name, "SuppressedError");
+        assert.strictEqual(output[4].error, "dispose error");
+        assert.strictEqual(output[4].suppressed, "body error");
+        assert.deepEqual(output.slice(5), [
+            "after try"
+        ]);
+    });
+
     it("'await using' in Block, 'return' in body (es2018)", async () => {
         const { main, output } = evaluator.evaluateTypeScript(`
         export const output: any[] = [];

src/testRunner/unittests/evaluation/usingDeclarations.ts

@@ -286,6 +286,53 @@ describe("unittests:: evaluation:: usingDeclarations", () => {
         ]);
     });
 
+    it("'using' in Block, 'throw' in body and dispose, no global SuppressedError (es2018)", () => {
+        const { main, output } = evaluator.evaluateTypeScript(`
+        export const output: any[] = [];
+
+        const disposable = {
+            [Symbol.dispose]() {
+                output.push("disposed");
+                throw "dispose error";
+            }
+        };
+
+        function body() {
+            output.push("body");
+            throw "body error";
+        }
+
+        export function main() {
+            output.push("before try");
+            try {
+                output.push("enter try");
+                using _ = disposable;
+                body();
+                output.push("exit try");
+            }
+            catch (e) {
+                output.push(e);
+            }
+            output.push("after try");
+        }
+        `, { target: ts.ScriptTarget.ES2018 });
+
+        main();
+
+        assert.deepEqual(output.slice(0, 4), [
+            "before try",
+            "enter try",
+            "body",
+            "disposed"]);
+        assert.instanceOf(output[4], Error);
+        assert.strictEqual(output[4].name, "SuppressedError");
+        assert.strictEqual(output[4].error, "dispose error");
+        assert.strictEqual(output[4].suppressed, "body error");
+        assert.deepEqual(output.slice(5), [
+            "after try"
+        ]);
+    });
+
     it("'using' in Block, 'return' in body (es2018)", () => {
         const { main, output } = evaluator.evaluateTypeScript(`
         export const output: any[] = [];

tests/baselines/reference/awaitUsingDeclarations.1(target=es2015).js

@@ -129,26 +129,31 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
     }
     return value;
 };
-var __disposeResources = (this && this.__disposeResources) || function (env) {
-    function fail(e) {
-        env.error = env.hasError ? new SuppressedError(e, env.error) : e;
-        env.hasError = true;
-    }
-    function next() {
-        while (env.stack.length) {
-            var rec = env.stack.pop();
-            try {
-                var result = rec.dispose && rec.dispose.call(rec.value);
-                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-            }
-            catch (e) {
-                fail(e);
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
             }
+            if (env.hasError) throw env.error;
         }
-        if (env.hasError) throw env.error;
-    }
-    return next();
-};
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");

tests/baselines/reference/awaitUsingDeclarations.1(target=es2017).js

@@ -120,26 +120,31 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
     }
     return value;
 };
-var __disposeResources = (this && this.__disposeResources) || function (env) {
-    function fail(e) {
-        env.error = env.hasError ? new SuppressedError(e, env.error) : e;
-        env.hasError = true;
-    }
-    function next() {
-        while (env.stack.length) {
-            var rec = env.stack.pop();
-            try {
-                var result = rec.dispose && rec.dispose.call(rec.value);
-                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-            }
-            catch (e) {
-                fail(e);
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
             }
+            if (env.hasError) throw env.error;
         }
-        if (env.hasError) throw env.error;
-    }
-    return next();
-};
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");

tests/baselines/reference/awaitUsingDeclarations.1(target=es2022).js

@@ -120,26 +120,31 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
     }
     return value;
 };
-var __disposeResources = (this && this.__disposeResources) || function (env) {
-    function fail(e) {
-        env.error = env.hasError ? new SuppressedError(e, env.error) : e;
-        env.hasError = true;
-    }
-    function next() {
-        while (env.stack.length) {
-            var rec = env.stack.pop();
-            try {
-                var result = rec.dispose && rec.dispose.call(rec.value);
-                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-            }
-            catch (e) {
-                fail(e);
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
             }
+            if (env.hasError) throw env.error;
         }
-        if (env.hasError) throw env.error;
-    }
-    return next();
-};
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 async function af() {
     const env_15 = { stack: [], error: void 0, hasError: false };
     try {

tests/baselines/reference/awaitUsingDeclarations.1(target=es5).js

@@ -156,26 +156,31 @@ var __addDisposableResource = (this && this.__addDisposableResource) || function
     }
     return value;
 };
-var __disposeResources = (this && this.__disposeResources) || function (env) {
-    function fail(e) {
-        env.error = env.hasError ? new SuppressedError(e, env.error) : e;
-        env.hasError = true;
-    }
-    function next() {
-        while (env.stack.length) {
-            var rec = env.stack.pop();
-            try {
-                var result = rec.dispose && rec.dispose.call(rec.value);
-                if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-            }
-            catch (e) {
-                fail(e);
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
             }
-        }
-        if (env.hasError) throw env.error;
-    }
-    return next();
-};
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");