Implement deterministic collapse of 'await' in 'await using' (#58929)

src/compiler/factory/emitHelpers.ts

@@ -1417,6 +1417,10 @@ export const addDisposableResourceHelper: UnscopedEmitHelper = {
 };
 
 /**
+ * The `s` variable represents two boolean flags from the `DisposeResources` algorithm:
+ * - `needsAwait` (`1`) — Indicates that an `await using` for a `null` or `undefined` resource was encountered.
+ * - `hasAwaited` (`2`) — Indicates that the algorithm has performed an Await.
+ *
  * @internal
  */
 export const disposeResourcesHelper: UnscopedEmitHelper = {
@@ -1430,17 +1434,22 @@ export const disposeResourcesHelper: UnscopedEmitHelper = {
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

src/testRunner/unittests/evaluation/usingDeclarations.ts

@@ -1810,4 +1810,50 @@ describe("unittests:: evaluation:: usingDeclarations", () => {
  "exit",
  ]);
  });
+
+ it("deterministic collapse of Await", async () => {
+ const { main, output } = evaluator.evaluateTypeScript(
+ `
+ export const output: any[] = [];
+
+ let asyncId = 0;
+ function increment() { asyncId++; }
+
+ export async function main() {
+ // increment asyncId at the top of each turn of the microtask queue
+ let pending = Promise.resolve();
+ for (let i = 0; i < 10; i++) {
+ pending = pending.then(increment);
+ }
+
+ {
+ using sync1 = { [Symbol.dispose]() { output.push(asyncId); } }; // asyncId: 2
+ await using async1 = null, async2 = null;
+ using sync2 = { [Symbol.dispose]() { output.push(asyncId); } }; // asyncId: 1
+ await using async3 = null, async4 = null;
+ output.push(asyncId); // asyncId: 0
+ }
+
+ output.push(asyncId); // asyncId: Ideally, 2, but ends up being 4 due to delays imposed by 'await'
+
+ await pending; // wait for the remaining 'increment' frames to complete.
+ }
+
+ `,
+ { target: ts.ScriptTarget.ES2018 },
+ );
+
+ await main();
+
+ assert.deepEqual(output, [
+ 0,
+ 1,
+ 2,
+
+ // This really should be 2, but our transpile introduces an extra `await` by necessity to observe the
+ // result of __disposeResources. The process of adopting the result ends up taking two turns of the
+ // microtask queue.
+ 4,
+ ]);
+ });
 });

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

@@ -137,17 +137,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -128,17 +128,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -128,17 +128,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -164,17 +164,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -46,17 +46,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -37,17 +37,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -37,17 +37,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -73,17 +73,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -48,17 +48,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -39,17 +39,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();

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

@@ -39,17 +39,22 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
  env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
  env.hasError = true;
  }
+ var r, s = 0;
  function next() {
- while (env.stack.length) {
- var rec = env.stack.pop();
+ while (r = 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(); });
+ if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+ if (r.dispose) {
+ var result = r.dispose.call(r.value);
+ if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+ }
+ else s |= 1;
  }
  catch (e) {
  fail(e);
  }
  }
+ if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
  if (env.hasError) throw env.error;
  }
  return next();