Return our own Promise type in pure types

slowcheetah · slowcheetah · commit eb11b82b75d0 · 2026-01-06T03:36:59.000+07:00
diff --git a/packages/core-js-types/src/base/core-js-types/promise.d.ts b/packages/core-js-types/src/base/core-js-types/promise.d.ts
@@ -0,0 +1,58 @@
+declare namespace CoreJS {
+  export interface CoreJSPromise<T> extends Promise<T> {}
+
+  export interface CoreJSPromiseConstructor {
+    readonly prototype: CoreJSPromise<any>;
+
+    /**
+     * Creates a new Promise.
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used to resolve the promise with a value or the result of another promise,
+     * and a reject callback used to reject the promise with a provided reason or error.
+     */
+    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): CoreJSPromise<T>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    all<T extends readonly unknown[] | []>(values: T): CoreJSPromise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T extends readonly unknown[] | []>(values: T): CoreJSPromise<Awaited<T[number]>>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject<T = never>(reason?: any): CoreJSPromise<T>;
+
+    /**
+     * Creates a new resolved promise.
+     * @returns A resolved promise.
+     */
+    resolve(): CoreJSPromise<void>;
+    /**
+     * Creates a new resolved promise for the provided value.
+     * @param value A promise.
+     * @returns A promise whose internal state matches the provided promise.
+     */
+    resolve<T>(value: T): CoreJSPromise<Awaited<T>>;
+    /**
+     * Creates a new resolved promise for the provided value.
+     * @param value A promise.
+     * @returns A promise whose internal state matches the provided promise.
+     */
+    resolve<T>(value: T | PromiseLike<T>): CoreJSPromise<Awaited<T>>;
+  }
+
+  var CoreJSPromise: CoreJSPromiseConstructor;
+}
diff --git a/packages/core-js-types/src/base/proposals/array-from-async.d.ts b/packages/core-js-types/src/base/proposals/array-from-async.d.ts
@@ -9,7 +9,7 @@ interface ArrayConstructor {
    * Creates an array from an async iterator or iterable object.
    * @param iterableOrArrayLike An async iterator or array-like object to convert to an array.
    */
-  fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+  fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; // @type-options prefix-return-type
 
   /**
    * Creates an array from an async iterator or iterable object.
@@ -19,5 +19,5 @@ interface ArrayConstructor {
    *      Each return value is awaited before being added to result array.
    * @param thisArg Value of 'this' used when executing mapFn.
    */
-  fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+  fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>; // @type-options prefix-return-type
 }
diff --git a/packages/core-js-types/src/base/proposals/explicit-resource-management.d.ts b/packages/core-js-types/src/base/proposals/explicit-resource-management.d.ts
@@ -178,7 +178,7 @@ interface AsyncDisposableStack {
    */
   move(): AsyncDisposableStack;
 
-  [Symbol.asyncDispose](): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>; // @type-options prefix-return-type
 
   readonly [Symbol.toStringTag]: string;
 }
diff --git a/packages/core-js-types/src/base/proposals/promise-all-settled.d.ts b/packages/core-js-types/src/base/proposals/promise-all-settled.d.ts
@@ -13,13 +13,13 @@ interface PromiseConstructor {
    * @param values An array of Promises.
    * @returns A new Promise.
    */
-  allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: CoreJS.CoreJSPromiseSettledResult<Awaited<T[P]>>; }>;
+  allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: CoreJS.CoreJSPromiseSettledResult<Awaited<T[P]>>; }>; // @type-options prefix-return-type
 
   /**
    * Creates a Promise that is resolved with an array of results when all
    * of the provided Promises resolve or reject.
    * @param values An array of Promises.
    * @returns A new Promise.
    */
-  allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<CoreJS.CoreJSPromiseSettledResult<Awaited<T>>[]>;
+  allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<CoreJS.CoreJSPromiseSettledResult<Awaited<T>>[]>; // @type-options prefix-return-type
 }
diff --git a/packages/core-js-types/src/base/proposals/promise-any.d.ts b/packages/core-js-types/src/base/proposals/promise-any.d.ts
@@ -10,14 +10,14 @@ interface PromiseConstructor {
    * @param values An array or iterable of Promises.
    * @returns A new Promise.
    */
-  any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+  any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>; // @type-options prefix-return-type
 
   /**
    * The any function returns a promise that is fulfilled by the first given promise to be fulfilled, or rejected with an AggregateError containing an array of rejection reasons if all of the given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this algorithm.
    * @param values An array or iterable of Promises.
    * @returns A new Promise.
    */
-  any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+  any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>; // @type-options prefix-return-type
 }
 
 interface AggregateError extends Error { // @type-options no-redefine
diff --git a/packages/core-js-types/src/base/proposals/promise-finally.d.ts b/packages/core-js-types/src/base/proposals/promise-finally.d.ts
@@ -11,5 +11,5 @@ interface Promise<T> {
    * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
    * @returns A Promise for the completion of the callback.
    */
-  finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+  finally(onfinally?: (() => void) | undefined | null): Promise<T>; // @type-options prefix-return-type
 }
diff --git a/packages/core-js-types/src/base/proposals/promise-try.d.ts b/packages/core-js-types/src/base/proposals/promise-try.d.ts
@@ -18,6 +18,6 @@ interface PromiseConstructor {
    * - Already rejected, if the callback synchronously throws an error.
    * - Asynchronously fulfilled or rejected, if the callback returns a promise.
    */
-  try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>;
+  try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>; // @type-options prefix-return-type
 }
 
diff --git a/packages/core-js-types/src/base/proposals/promise-with-resolvers.d.ts b/packages/core-js-types/src/base/proposals/promise-with-resolvers.d.ts
@@ -5,7 +5,7 @@
 // License: https://github.com/microsoft/TypeScript/blob/v5.9.3/LICENSE.txt
 
 interface PromiseWithResolvers<T> { // @type-options no-extends, no-prefix
-  promise: Promise<T>;
+  promise: Promise<T>; // @type-options prefix-return-type
 
   resolve: (value: T | PromiseLike<T>) => void;
 
diff --git a/packages/core-js-types/src/base/pure/proposals/array-constructor.d.ts b/packages/core-js-types/src/base/pure/proposals/array-constructor.d.ts
@@ -1,4 +1,5 @@
 /// <reference types="./iterator.d.ts" />
+/// <reference types="../../core-js-types/promise.d.ts" />
 
 // Motivation: We must omit methods `fromAsync` and `isTemplateObject` because they cause a signature mismatch error.
 
@@ -20,7 +21,7 @@ declare namespace CoreJS {
      * Creates an array from an async iterator or iterable object.
      * @param iterableOrArrayLike An async iterator or array-like object to convert to an array.
      */
-    fromAsync<T>(iterableOrArrayLike: CoreJSAsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+    fromAsync<T>(iterableOrArrayLike: CoreJSAsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): CoreJSPromise<T[]>;
 
     /**
      * Creates an array from an async iterator or iterable object.
@@ -30,7 +31,7 @@ declare namespace CoreJS {
      *      Each return value is awaited before being added to result array.
      * @param thisArg Value of 'this' used when executing mapFn.
      */
-    fromAsync<T, U>(iterableOrArrayLike: CoreJSAsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+    fromAsync<T, U>(iterableOrArrayLike: CoreJSAsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): CoreJSPromise<Awaited<U>[]>;
 
     /**
      * Determines whether an `value` is a `TemplateStringsArray`
diff --git a/packages/core-js-types/src/base/pure/proposals/async-iterator-helpers.d.ts b/packages/core-js-types/src/base/pure/proposals/async-iterator-helpers.d.ts
@@ -1,5 +1,6 @@
 /// <reference types="../../core-js-types/async-iterable.d.ts" />
 /// <reference types="../../core-js-types/async-iterator-object.d.ts" />
+/// <reference types="../../core-js-types/promise.d.ts" />
 
 // Motivation: Has dependencies on internal types, e.g. AsyncIterable, AsyncIteratorObject
 
@@ -30,7 +31,7 @@ declare namespace CoreJS {
      * @param predicate A function that tests each element of the iterator
      * @returns A promise that resolves to `true` if all elements pass the test, otherwise `false`
      */
-    every(predicate: (value: T, index: number) => boolean): Promise<boolean>;
+    every(predicate: (value: T, index: number) => boolean): CoreJSPromise<boolean>;
 
     /**
      * Creates a new `AsyncIterator` that contains only the elements that pass the `predicate` function.
@@ -44,7 +45,7 @@ declare namespace CoreJS {
      * @param predicate A function that tests each element of the iterator
      * @returns A `Promise` that resolves to the found element, or `undefined` if no element satisfies the `predicate`
      */
-    find(predicate: (value: T, index: number) => boolean): Promise<T>;
+    find(predicate: (value: T, index: number) => boolean): CoreJSPromise<T>;
 
     /**
      * Creates a new `AsyncIterator` by applying the `mapper` function to each element of the original iterator and flattening the result.
@@ -58,7 +59,7 @@ declare namespace CoreJS {
      * @param callbackFn A function that is called for each element of the iterator
      * @returns A `Promise` that resolves when all elements have been processed
      */
-    forEach(callbackFn: (value: T, index: number) => void): Promise<void>;
+    forEach(callbackFn: (value: T, index: number) => void): CoreJSPromise<void>;
 
     /**
      * Creates a new `AsyncIterator` by applying the `mapper` function to each element of the original iterator.
@@ -73,14 +74,14 @@ declare namespace CoreJS {
      * @param initialValue An optional initial value to start the reduction
      * @returns A `Promise` that resolves to the reduced value
      */
-    reduce(reducer: (accumulator: any, value: T, index: number) => any, initialValue?: any): Promise<any>;
+    reduce(reducer: (accumulator: any, value: T, index: number) => any, initialValue?: any): CoreJSPromise<any>;
 
     /**
      * Checks if any value in the iterator matches a given `predicate`
      * @param predicate A function that tests each element of the iterator
      * @returns A `Promise` that resolves to `true` if any element passes the `predicate`, otherwise `false`
      */
-    some(predicate: (value: T, index: number) => boolean): Promise<boolean>;
+    some(predicate: (value: T, index: number) => boolean): CoreJSPromise<boolean>;
 
     /**
      * Creates a new `AsyncIterator` that yields only the first `limit` elements from the original iterator.
@@ -93,7 +94,7 @@ declare namespace CoreJS {
      * Collects all elements from the iterator into an array.
      * @returns A `Promise` that resolves to an array containing all elements from the iterator
      */
-    toArray(): Promise<T[]>;
+    toArray(): CoreJSPromise<T[]>;
   }
 
   var CoreJSAsyncIterator: CoreJSAsyncIteratorConstructor;
diff --git a/packages/core-js-types/src/base/pure/proposals/explicit-resource-management.d.ts b/packages/core-js-types/src/base/pure/proposals/explicit-resource-management.d.ts
@@ -125,7 +125,7 @@ declare namespace CoreJS {
     /**
      * Disposes each resource in the stack in the reverse order that they were added.
      */
-    disposeAsync(): Promise<void>;
+    disposeAsync(): CoreJSPromise<void>;
 
     /**
      * Adds a disposable resource to the stack, returning the resource.
diff --git a/packages/core-js-types/src/base/pure/proposals/iterator.d.ts b/packages/core-js-types/src/base/pure/proposals/iterator.d.ts
@@ -1,4 +1,5 @@
 /// <reference types="./explicit-resource-management.d.ts" />
+/// <reference types="../../core-js-types/promise.d.ts" />
 
 // Motivation: Has dependencies on internal types
 
@@ -48,9 +49,9 @@ declare namespace CoreJS {
   }
 
   interface CoreJSAsyncIterator<T, TReturn = any, TNext = any> {
-    next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
-    return?(value?: TReturn | CoreJSPromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
-    throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
+    next(...[value]: [] | [TNext]): CoreJSPromise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn | CoreJSPromiseLike<TReturn>): CoreJSPromise<IteratorResult<T, TReturn>>;
+    throw?(e?: any): CoreJSPromise<IteratorResult<T, TReturn>>;
   }
 
   export interface CoreJSAsyncIteratorObject<T, TReturn = unknown, TNext = unknown> extends CoreJSAsyncIterator<T, TReturn, TNext> {}
diff --git a/scripts/build-types/pure.mjs b/scripts/build-types/pure.mjs
@@ -34,6 +34,7 @@ function parseOptions(line) {
     exportBaseConstructor: hasOptions && optionsStr.includes('export-base-constructor'),
     noExport: hasOptions && optionsStr.includes('no-export'),
     noRedefine: hasOptions && optionsStr.includes('no-redefine'),
+    prefixReturnType: hasOptions && optionsStr.includes('prefix-return-type'),
   };
 }
 
@@ -100,6 +101,11 @@ function processLines(lines, prefix) {
           `$<indent>export function ${ !options.noPrefix ? prefix : '' }$<name>`);
       }
 
+      if (options.prefixReturnType) {
+        return line.replace(/^(?<smth>.*):\s(?<rootType>[a-z_]\w*)(?<subType><[^;]+);/i,
+          `$<smth>: ${ prefix }$<rootType>$<subType>;`);
+      }
+
       // Replace prefixed types in the entire file
       if (/(?::|\|)\s*\w/.test(line)) {
         const sortedPrefixed = prefixed.sort((a, b) => b.length - a.length);
diff --git a/tests/type-definitions/global/proposals/array-from-async.test.ts b/tests/type-definitions/global/proposals/array-from-async.test.ts
@@ -1,12 +1,12 @@
 import 'core-js/full';
 
-Array.fromAsync([1, 2, 3]);
-Array.fromAsync([Promise.resolve(1), 2, 3]);
-Array.fromAsync((async function* () { yield 1; })());
-Array.fromAsync([1, 2, 3], (value: number, index: number) => value.toString());
-Array.fromAsync([Promise.resolve(1), 2, 3], (value: number) => value + 1);
-Array.fromAsync((async function* () { yield 1; })(), function (value: number) { return value * 2; });
-Array.fromAsync([1, 2, 3], function (this: {foo: string}, value: number) { return value.toString(); }, {foo: 'str'});
+const p1: Promise<number[]> = Array.fromAsync([1, 2, 3]);
+const p2: Promise<number[]> = Array.fromAsync([Promise.resolve(1), 2, 3]);
+const p3: Promise<number[]> = Array.fromAsync((async function* () { yield 1; })());
+const p4: Promise<string[]> = Array.fromAsync([1, 2, 3], (value: number, index: number) => value.toString());
+const p5: Promise<number[]> = Array.fromAsync([Promise.resolve(1), 2, 3], (value: number) => value + 1);
+const p6: Promise<number[]> = Array.fromAsync((async function* () { yield 1; })(), function (value: number) { return value * 2; });
+const p7: Promise<string[]> = Array.fromAsync([1, 2, 3], function (this: { foo: string }, value: number) { return value.toString(); }, { foo: 'str' });
 
 async function t1() {
   const n: number[] = await Array.fromAsync([1, 2, 3]);
@@ -20,8 +20,8 @@ async function t2() {
 }
 
 declare const arrLike: { [index: number]: PromiseLike<number>; length: 2 };
-Array.fromAsync(arrLike);
-Array.fromAsync(arrLike, (value: number) => value);
+const p8: Promise<number[]> = Array.fromAsync(arrLike);
+const p9: Promise<number[]> = Array.fromAsync(arrLike, (value: number) => value);
 
 // @ts-expect-error
 Array.fromAsync([1, 2, 3], (value: string) => value);
diff --git a/tests/type-definitions/helpers.ts b/tests/type-definitions/helpers.ts
@@ -0,0 +1,5 @@
+export default interface CoreJSPromiseLike<T> {
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+
+  finally(onfinally?: (() => void) | undefined | null): PromiseLike<T>;
+}
diff --git a/tests/type-definitions/pure/proposals/array-from-async.test.ts b/tests/type-definitions/pure/proposals/array-from-async.test.ts
@@ -1,10 +1,12 @@
 import arrayFromAsync from '@core-js/pure/full/array/from-async';
+import promiseResolve from '@core-js/pure/full/promise/resolve';
+import CoreJSPromiseLike from '../../helpers';
 
-arrayFromAsync([1, 2, 3]);
-arrayFromAsync([Promise.resolve(1), 2, 3]);
-arrayFromAsync([1, 2, 3], (value: number, index: number) => value.toString());
-arrayFromAsync([Promise.resolve(1), 2, 3], (value: number) => value + 1);
-arrayFromAsync([1, 2, 3], function (this: { foo: string }, value: number) { return value.toString(); }, {foo: 'str'});
+const p1: CoreJSPromiseLike<number[]> = arrayFromAsync([1, 2, 3]);
+const p2: CoreJSPromiseLike<number[]> = arrayFromAsync([promiseResolve(1), 2, 3]);
+const p3: CoreJSPromiseLike<string[]> = arrayFromAsync([1, 2, 3], (value: number, index: number) => value.toString());
+const p4: CoreJSPromiseLike<number[]> = arrayFromAsync([promiseResolve(1), 2, 3], (value: number) => value + 1);
+const p5: CoreJSPromiseLike<string[]> = arrayFromAsync([1, 2, 3], function (this: { foo: string }, value: number) { return value.toString(); }, { foo: 'str' });
 
 async function t1() {
   const n: number[] = await arrayFromAsync([1, 2, 3]);
@@ -18,8 +20,8 @@ async function t2() {
 }
 
 declare const arrLike: { [index: number]: PromiseLike<number>; length: 2 };
-arrayFromAsync(arrLike);
-arrayFromAsync(arrLike, (value: number) => value);
+const p6: CoreJSPromiseLike<number[]> = arrayFromAsync(arrLike);
+const p7: CoreJSPromiseLike<number[]> = arrayFromAsync(arrLike, (value: number) => value);
 
 // @ts-expect-error
 arrayFromAsync([1, 2, 3], (value: string) => value);
diff --git a/tests/type-definitions/pure/proposals/async-iterator-helper.test.ts b/tests/type-definitions/pure/proposals/async-iterator-helper.test.ts
@@ -11,7 +11,8 @@ import some from '@core-js/pure/full/async-iterator/some';
 import take from '@core-js/pure/full/async-iterator/take';
 import toArray from '@core-js/pure/full/async-iterator/to-array';
 import toAsync from '@core-js/pure/full/iterator/to-async';
-import $AsyncIterator from '@core-js/pure/full/async-iterator';
+// import $AsyncIterator from '@core-js/pure/full/async-iterator'; // todo
+import CoreJSPromiseLike from '../../helpers';
 
 const aiton = from([1, 2, 3]);
 aiton.next();
@@ -40,16 +41,16 @@ toAsync(is);
 toAsync(itn);
 
 drop(aiton, 3);
-const r2: Promise<boolean> = every(aiton, (v: number, i: number) => v > 0);
+const r2: CoreJSPromiseLike<boolean> = every(aiton, (v: number, i: number) => v > 0);
 filter(aiton, (v: number, i: number) => v > 0);
-const r4: Promise<number> = find(aiton, (v: number, i: number) => v > 0);
+const r4: CoreJSPromiseLike<number> = find(aiton, (v: number, i: number) => v > 0);
 flatMap(aiton, (v: number, i: number) => `${v}`);
-const r6: Promise<void> = forEach(aiton, (v: number, i: number) => { });
+const r6: CoreJSPromiseLike<void> = forEach(aiton, (v: number, i: number) => { });
 map(aiton, (v: number, i: number) => v * 2);
-const r8: Promise<number> = reduce(aiton, (acc: number, v: number, i: number) => acc + v, 0);
-const r9: Promise<boolean> = some(aiton, (v: number, i: number) => v > 0);
+const r8: CoreJSPromiseLike<number> = reduce(aiton, (acc: number, v: number, i: number) => acc + v, 0);
+const r9: CoreJSPromiseLike<boolean> = some(aiton, (v: number, i: number) => v > 0);
 take(aiton, 10);
-const r11: Promise<number[]> = toArray(aiton);
+const r11: CoreJSPromiseLike<number[]> = toArray(aiton);
 
 // @ts-expect-error
 drop(ain);
@@ -74,8 +75,8 @@ take(ain);
 // @ts-expect-error
 toArray(ain, 1);
 
-const s0: Promise<number[]> = toArray(aiton);
-const f0: Promise<string> = find(aitos, (v: string, i: number) => v.length === 1);
+const s0: CoreJSPromiseLike<number[]> = toArray(aiton);
+const f0: CoreJSPromiseLike<string> = find(aitos, (v: string, i: number) => v.length === 1);
 
 // @ts-expect-error
 map(ais, (v: string, i: number) => v.length === 1, 'extra');
diff --git a/tests/type-definitions/pure/proposals/explicit-resource-management.test.ts b/tests/type-definitions/pure/proposals/explicit-resource-management.test.ts
diff --git a/tests/type-definitions/pure/proposals/promise-all-settled.test.ts b/tests/type-definitions/pure/proposals/promise-all-settled.test.ts
diff --git a/tests/type-definitions/pure/proposals/promise-any.test.ts b/tests/type-definitions/pure/proposals/promise-any.test.ts
diff --git a/tests/type-definitions/pure/proposals/promise-finally.test.ts b/tests/type-definitions/pure/proposals/promise-finally.test.ts
diff --git a/tests/type-definitions/pure/proposals/promise-try.test.ts b/tests/type-definitions/pure/proposals/promise-try.test.ts
diff --git a/tests/type-definitions/pure/proposals/promise-with-resolvers.test.ts b/tests/type-definitions/pure/proposals/promise-with-resolvers.test.ts

Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ interface AsyncDisposableStack {`
`178`	`178`	`*/`
`179`	`179`	`move(): AsyncDisposableStack;`
`180`	`180`
`181`		`- [Symbol.asyncDispose](): Promise<void>;`
	`181`	`+ [Symbol.asyncDispose](): Promise<void>; // @type-options prefix-return-type`
`182`	`182`
`183`	`183`	`readonly [Symbol.toStringTag]: string;`
`184`	`184`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,5 @@ interface Promise<T> {`
`11`	`11`	`* @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).`
`12`	`12`	`* @returns A Promise for the completion of the callback.`
`13`	`13`	`*/`
`14`		`- finally(onfinally?: (() => void) \| undefined \| null): Promise<T>;`
	`14`	`+ finally(onfinally?: (() => void) \| undefined \| null): Promise<T>; // @type-options prefix-return-type`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,6 @@ interface PromiseConstructor {`
`18`	`18`	`* - Already rejected, if the callback synchronously throws an error.`
`19`	`19`	`* - Asynchronously fulfilled or rejected, if the callback returns a promise.`
`20`	`20`	`*/`
`21`		`- try<T, U extends unknown[]>(callbackFn: (...args: U) => T \| PromiseLike<T>, ...args: U): Promise<Awaited<T>>;`
	`21`	`+ try<T, U extends unknown[]>(callbackFn: (...args: U) => T \| PromiseLike<T>, ...args: U): Promise<Awaited<T>>; // @type-options prefix-return-type`
`22`	`22`	`}`
`23`	`23`