From b60fbc053d3dcc3fb7081c584bb20f4dc93e2fe5 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Thu, 8 Aug 2024 10:26:03 -0700
Subject: [PATCH] Update tests

---
 tests/cases/compiler/deferredCallbacks.ts  | 238 ---------------------
 tests/cases/compiler/immediateCallbacks.ts | 238 +++++++++++++++++++++
 2 files changed, 238 insertions(+), 238 deletions(-)
 delete mode 100644 tests/cases/compiler/deferredCallbacks.ts
 create mode 100644 tests/cases/compiler/immediateCallbacks.ts

diff --git a/tests/cases/compiler/deferredCallbacks.ts b/tests/cases/compiler/deferredCallbacks.ts
deleted file mode 100644
index 33f324704c2..00000000000
--- a/tests/cases/compiler/deferredCallbacks.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-// @strict: true
-// @declaration: true
-// @target: esnext
-
-declare function immediate(cb: () => void): void;
-declare function deferred1(deferred cb: () => void): void;
-declare function deferred2(/** @deferred */ cb: () => void): void;
-declare function deferred3(/** @deferred */ deferred cb: () => void): void;
-
-function f01() {
-    let x: string | number = "OK";
-    immediate(() => {
-        x = 42;
-    });
-    x;  // string | number
-}
-
-function f02() {
-    let x: string | number = "OK";
-    deferred1(() => {
-        x = 42;
-    });
-    x;  // string
-}
-
-function f03() {
-    let x: string | number = "OK";
-    deferred2(() => {
-        x = 42;
-    });
-    x;  // string
-}
-
-function f04() {
-    let x: string | number = "OK";
-    deferred3(() => {
-        x = 42;
-    });
-    x;  // string
-}
-
-// Parameter is considered deferred if one or more overloads defer that parameter
-
-declare function overloaded<T>(cb: (x: T) => T): void;
-declare function overloaded<T>(cb: (x: T, y: T) => T): void;
-declare function overloaded(deferred cb: (...args: any) => any): void;
-
-function f05() {
-    let x: string | number = "OK";
-    overloaded(() => {
-        x = 42;
-    });
-    x.length;
-}
-
-// deferred is permitted on a rest parameter
-
-declare function invokeImmediate(...args: ((...args: any) => any)[]): void;
-declare function invokeDeferred(deferred ...args: ((...args: any) => any)[]): void;
-
-function f06() {
-    let a = [];
-    a.push("abc");
-    a;  // string[]
-    invokeImmediate(
-        () => {
-            a;  // string[]
-            a.push(42);
-            a;  // (string | number)[]
-        },
-        () => {
-            a;  // string[]
-            a.push(true);
-            a;  // (string | boolean)[]
-        }
-    );
-    a;  // (string | number | boolean)[]
-}
-
-function f07() {
-    let a = [];
-    a.push("abc");
-    a;  // string[]
-    invokeDeferred(
-        () => {
-            a;  // string[]
-            a.push(42);
-            a;  // (string | number)[]
-        },
-        () => {
-            a;  // string[]
-            a.push(true);
-            a;  // (string | boolean)[]
-        }
-    );
-    a;  // string[]
-}
-
-// deferred modifier must precede public/private/protected/readonly
-
-class CC {
-    constructor(deferred public readonly x: () => void) {}
-}
-
-// deferred requires parameter to have type that permits functions
-
-declare function f10(deferred f: () => void): void;
-declare function f11(deferred f: Function): void;
-declare function f12(deferred f: any): void;
-declare function f13(deferred f: object): void;
-declare function f14(deferred f: {}): void;
-declare function f15(deferred f: unknown): void;
-declare function f16<T extends Function>(deferred f: T): void;
-declare function f17<T extends (...args: any) => any>(deferred f: T): void;
-declare function f18<T extends string | (() => void)>(deferred f: T): void;
-
-declare function f20(deferred ...funcs: Function[]): void;
-declare function f21<T extends ((...args: any) => any)[]>(deferred ...funcs: T): void;
-declare function f22<T extends (string | (() => void))[]>(deferred ...funcs: T): void;
-declare function f23<T extends string[] | (() => void)[]>(deferred ...funcs: T): void;
-declare function f24<T extends (() => void)[]>(deferred ...funcs: T | string[]): void;
-
-declare function f30(deferred f: { foo(): void }): void;
-declare function f31(deferred f: number): void;
-declare function f32(deferred ...funcs: number[]): void;
-
-type T10 = (deferred f: () => void) => void;
-type T11 = (deferred f: { (): void }) => void;
-type T12 = (deferred f: Function) => void;
-type T13 = (deferred f: any) => void;
-
-type T20 = (deferred f: { foo(): void }) => void;
-type T21 = (deferred f: number) => void;
-type T22 = (deferred ...funcs: number[]) => void;
-type T23 = { deferred x: () => void };
-
-// deferred modifier is not captured in argument list tuples
-
-declare function doStuff(deferred f: () => void): void;
-
-declare function recreate<A extends unknown[], R>(f: (...args: A) => R): (...args: A) => R;
-declare function recreateDeferred1<A extends unknown[], R>(f: (deferred ...args: A) => R): (...args: A) => R;
-declare function recreateDeferred2<A extends unknown[], R>(f: (...args: A) => R): (deferred ...args: A) => R;
-
-function ff1() {
-    let x: string | number;
-    x = 123;
-    doStuff(() => {
-        x = "hi";
-    });
-    x;  // number
-}
-
-function ff2() {
-    let y: string | number;
-    y = 123;
-    recreate(doStuff)(() => {
-        y = "hi";
-    });
-    y;  // string | number
-}
-
-function ff3() {
-    let z: string | number;
-    z = 123;
-    recreateDeferred1(doStuff)(() => {
-        z = "hi";
-    });
-    z;  // string | number
-}
-
-function ff4() {
-    let z: string | number;
-    z = 123;
-    recreateDeferred2(doStuff)(() => {
-        z = "hi";
-    });
-    z;  // number
-}
-
-// https://github.com/microsoft/TypeScript/issues/11498
-
-declare function mystery(cb: () => void): void;
-
-function fx1() {
-    let x: string | number = "OK";
-    x;  // string
-    mystery(() => {
-        x = 10;
-    });
-    x;  // string | number
-    if (x === 10) {}
-}
-
-// https://github.com/microsoft/TypeScript/issues/15380
-
-class Foo {
-  public bar: string = "";
-}
-
-function fx2() {
-  let foo: Foo | null = null;
-  [1].forEach((item) => {
-      foo = new Foo();
-  });
-  if (foo) {
-      foo.bar;
-  }
-}
-
-// https://github.com/microsoft/TypeScript/issues/57880
-
-const call = (f: () => void) => f();
-
-const fx3 = () => {
-    let a: undefined | number = undefined;
-    call(() => { a = 1; });
-    if (a !== undefined) {
-        a.toString();
-    }
-};
-
-// https://github.com/microsoft/TypeScript/issues/58291
-
-async function execute(onError: (_err: Error | undefined) => void) {
-    onError(new Error("a"));
-}
-
-async function run() {
-    let result: boolean = true;
-    await execute(() => {
-        result = false;
-    });
-    if (result === false) {
-        console.log("error");
-    }
-    return result;
-}
diff --git a/tests/cases/compiler/immediateCallbacks.ts b/tests/cases/compiler/immediateCallbacks.ts
new file mode 100644
index 00000000000..f8a1129e6fc
--- /dev/null
+++ b/tests/cases/compiler/immediateCallbacks.ts
@@ -0,0 +1,238 @@
+// @strict: true
+// @noemit: true
+// @target: esnext
+
+declare function deferred(cb: () => void): void;
+declare function immediate1(immediate cb: () => void): void;
+declare function immediate2(/** @immediate */ cb: () => void): void;
+declare function immediate3(/** @immediate */ immediate cb: () => void): void;
+
+function f01() {
+    let x: string | number = "OK";
+    deferred(() => {
+        x = 42;
+    });
+    x;  // string
+}
+
+function f02() {
+    let x: string | number = "OK";
+    immediate1(() => {
+        x = 42;
+    });
+    x;  // string | number
+}
+
+function f03() {
+    let x: string | number = "OK";
+    immediate2(() => {
+        x = 42;
+    });
+    x;  // string | number
+}
+
+function f04() {
+    let x: string | number = "OK";
+    immediate3(() => {
+        x = 42;
+    });
+    x;  // string | number
+}
+
+// Parameter is considered immediate if one or more overloads include the modifier in that parameter position
+
+declare function overloaded<T>(cb: (x: T) => T): void;
+declare function overloaded<T>(cb: (x: T, y: T) => T): void;
+declare function overloaded(immediate cb: (...args: any) => any): void;
+
+function f05() {
+    let x: string | number = "OK";
+    overloaded(() => {
+        x = 42;
+    });
+    x;  // string | number
+}
+
+// immediate is permitted on a rest parameter
+
+declare function invokeDeferred(...args: ((...args: any) => any)[]): void;
+declare function invokeImmediate(immediate ...args: ((...args: any) => any)[]): void;
+
+function f06() {
+    let a = [];
+    a.push("abc");
+    a;  // string[]
+    invokeImmediate(
+        () => {
+            a;  // string[]
+            a.push(42);
+            a;  // (string | number)[]
+        },
+        () => {
+            a;  // string[]
+            a.push(true);
+            a;  // (string | boolean)[]
+        }
+    );
+    a;  // (string | number | boolean)[]
+}
+
+function f07() {
+    let a = [];
+    a.push("abc");
+    a;  // string[]
+    invokeDeferred(
+        () => {
+            a;  // string[]
+            a.push(42);
+            a;  // (string | number)[]
+        },
+        () => {
+            a;  // string[]
+            a.push(true);
+            a;  // (string | boolean)[]
+        }
+    );
+    a;  // string[]
+}
+
+// immediate modifier must precede public/private/protected/readonly
+
+class CC {
+    constructor(immediate public readonly x: () => void) {}
+}
+
+// immediate requires parameter to have type that permits functions
+
+declare function f10(immediate f: () => void): void;
+declare function f11(immediate f: Function): void;
+declare function f12(immediate f: any): void;
+declare function f13(immediate f: object): void;
+declare function f14(immediate f: {}): void;
+declare function f15(immediate f: unknown): void;
+declare function f16<T extends Function>(immediate f: T): void;
+declare function f17<T extends (...args: any) => any>(immediate f: T): void;
+declare function f18<T extends string | (() => void)>(immediate f: T): void;
+
+declare function f20(immediate ...funcs: Function[]): void;
+declare function f21<T extends ((...args: any) => any)[]>(immediate ...funcs: T): void;
+declare function f22<T extends (string | (() => void))[]>(immediate ...funcs: T): void;
+declare function f23<T extends string[] | (() => void)[]>(immediate ...funcs: T): void;
+declare function f24<T extends (() => void)[]>(immediate ...funcs: T | string[]): void;
+
+declare function f30(immediate f: { foo(): void }): void;
+declare function f31(immediate f: number): void;
+declare function f32(immediate ...funcs: number[]): void;
+
+type T10 = (immediate f: () => void) => void;
+type T11 = (immediate f: { (): void }) => void;
+type T12 = (immediate f: Function) => void;
+type T13 = (immediate f: any) => void;
+
+type T20 = (immediate f: { foo(): void }) => void;
+type T21 = (immediate f: number) => void;
+type T22 = (immediate ...funcs: number[]) => void;
+type T23 = { immediate x: () => void };
+
+// immediate modifier is not captured in argument list tuples
+
+declare function doStuff(immediate f: () => void): void;
+
+declare function recreate<A extends unknown[], R>(f: (...args: A) => R): (...args: A) => R;
+declare function recreateImmediate1<A extends unknown[], R>(f: (immediate ...args: A) => R): (...args: A) => R;
+declare function recreateImmediate2<A extends unknown[], R>(f: (...args: A) => R): (immediate ...args: A) => R;
+
+function ff1() {
+    let x: string | number;
+    x = 123;
+    doStuff(() => {
+        x = "hi";
+    });
+    x;  // string | number
+}
+
+function ff2() {
+    let y: string | number;
+    y = 123;
+    recreate(doStuff)(() => {
+        y = "hi";
+    });
+    y;  // number
+}
+
+function ff3() {
+    let z: string | number;
+    z = 123;
+    recreateImmediate1(doStuff)(() => {
+        z = "hi";
+    });
+    z;  // number
+}
+
+function ff4() {
+    let z: string | number;
+    z = 123;
+    recreateImmediate2(doStuff)(() => {
+        z = "hi";
+    });
+    z;  // string | number
+}
+
+// https://github.com/microsoft/TypeScript/issues/11498
+
+declare function mystery(immediate cb: () => void): void;
+
+function fx1() {
+    let x: string | number = "OK";
+    x;  // string
+    mystery(() => {
+        x = 10;
+    });
+    x;  // string | number
+    if (x === 10) {}
+}
+
+// https://github.com/microsoft/TypeScript/issues/15380
+
+class Foo {
+  public bar: string = "";
+}
+
+function fx2() {
+  let foo: Foo | null = null;
+  [1].forEach((item) => {
+      foo = new Foo();
+  });
+  if (foo) {
+      foo.bar;
+  }
+}
+
+// https://github.com/microsoft/TypeScript/issues/57880
+
+const call = (immediate f: () => void) => f();
+
+const fx3 = () => {
+    let a: undefined | number = undefined;
+    call(() => { a = 1; });
+    if (a !== undefined) {
+        a.toString();
+    }
+};
+
+// https://github.com/microsoft/TypeScript/issues/58291
+
+async function execute(immediate onError: (_err: Error | undefined) => void) {
+    onError(new Error("a"));
+}
+
+async function run() {
+    let result: boolean = true;
+    await execute(() => {
+        result = false;
+    });
+    if (result === false) {
+        console.log("error");
+    }
+    return result;
+}