dependentDestructuredVariablesFromNestedPatterns.types

//// [tests/cases/conformance/controlFlow/dependentDestructuredVariablesFromNestedPatterns.ts] ////

=== dependentDestructuredVariablesFromNestedPatterns.ts ===
function test1(arg: [[undefined, Error] | [number, undefined]]) {
>test1 : (arg: [[undefined, Error] | [number, undefined]]) => void
>arg : [[undefined, Error] | [number, undefined]]

  const [[p1, p1Error]] = arg;
>p1 : number | undefined
>p1Error : Error | undefined
>arg : [[undefined, Error] | [number, undefined]]

  if (p1Error) {
>p1Error : Error | undefined

    return;
  }

  p1;
>p1 : number
}

function test2([[p1, p1Error]]: [[undefined, Error] | [number, undefined]]) {
>test2 : ([[p1, p1Error]]: [[undefined, Error] | [number, undefined]]) => void
>p1 : number | undefined
>p1Error : Error | undefined

  if (p1Error) {
>p1Error : Error | undefined

    return;
  }

  p1;
>p1 : number
}

async function myAllSettled<T extends readonly unknown[]>(fn: () => T) {
>myAllSettled : <T extends readonly unknown[]>(fn: () => T) => Promise<{ [K in keyof T]: [undefined, Error] | [Awaited<T[K]>, undefined]; }>
>fn : () => T

  const promises = await Promise.allSettled(fn());
>promises : { -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }
>await Promise.allSettled(fn()) : { -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }
>Promise.allSettled(fn()) : Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>
>Promise.allSettled : { <T_1 extends readonly unknown[] | []>(values: T_1): Promise<{ -readonly [P in keyof T_1]: PromiseSettledResult<Awaited<T_1[P]>>; }>; <T_2>(values: Iterable<T_2 | PromiseLike<T_2>>): Promise<PromiseSettledResult<Awaited<T_2>>[]>; }
>Promise : PromiseConstructor
>allSettled : { <T_1 extends readonly unknown[] | []>(values: T_1): Promise<{ -readonly [P in keyof T_1]: PromiseSettledResult<Awaited<T_1[P]>>; }>; <T_2>(values: Iterable<T_2 | PromiseLike<T_2>>): Promise<PromiseSettledResult<Awaited<T_2>>[]>; }
>fn() : T
>fn : () => T

  return promises.map((result) =>
>promises.map((result) =>    result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))],  ) as { [K in keyof T]: [Awaited<T[K]>, undefined] | [undefined, Error] } : { [K in keyof T]: [undefined, Error] | [Awaited<T[K]>, undefined]; }
>promises.map((result) =>    result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))],  ) : ([undefined, Error] | [unknown, undefined])[]
>promises.map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
>promises : { -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }
>map : <U>(callbackfn: (value: PromiseSettledResult<unknown>, index: number, array: PromiseSettledResult<unknown>[]) => U, thisArg?: any) => U[]
>(result) =>    result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))] : (result: PromiseSettledResult<unknown>) => [undefined, Error] | [unknown, undefined]
>result : PromiseSettledResult<unknown>

    result.status === "fulfilled"
>result.status === "fulfilled"      ? [result.value, undefined]      : [undefined, new Error(String(result.reason))] : [unknown, undefined] | [undefined, Error]
>result.status === "fulfilled" : boolean
>result.status : "rejected" | "fulfilled"
>result : PromiseSettledResult<unknown>
>status : "rejected" | "fulfilled"
>"fulfilled" : "fulfilled"

      ? [result.value, undefined]
>[result.value, undefined] : [unknown, undefined]
>result.value : unknown
>result : PromiseFulfilledResult<unknown>
>value : unknown
>undefined : undefined

      : [undefined, new Error(String(result.reason))],
>[undefined, new Error(String(result.reason))] : [undefined, Error]
>undefined : undefined
>new Error(String(result.reason)) : Error
>Error : ErrorConstructor
>String(result.reason) : string
>String : StringConstructor
>result.reason : any
>result : PromiseRejectedResult
>reason : any

  ) as { [K in keyof T]: [Awaited<T[K]>, undefined] | [undefined, Error] };
}

async function test3() {
>test3 : () => Promise<void>

  const [[p1, p1Error], _] = await myAllSettled(
>p1 : number | undefined
>p1Error : Error | undefined
>_ : [undefined, Error] | [never, undefined]
>await myAllSettled(    () => [Promise.resolve(0), Promise.reject(1)] as const,  ) : [[undefined, Error] | [number, undefined], [undefined, Error] | [never, undefined]]
>myAllSettled(    () => [Promise.resolve(0), Promise.reject(1)] as const,  ) : Promise<[[undefined, Error] | [number, undefined], [undefined, Error] | [never, undefined]]>
>myAllSettled : <T extends readonly unknown[]>(fn: () => T) => Promise<{ [K in keyof T]: [undefined, Error] | [Awaited<T[K]>, undefined]; }>

    () => [Promise.resolve(0), Promise.reject(1)] as const,
>() => [Promise.resolve(0), Promise.reject(1)] as const : () => [Promise<number>, Promise<never>]
>[Promise.resolve(0), Promise.reject(1)] as const : [Promise<number>, Promise<never>]
>[Promise.resolve(0), Promise.reject(1)] : [Promise<number>, Promise<never>]
>Promise.resolve(0) : Promise<number>
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
>Promise : PromiseConstructor
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
>0 : 0
>Promise.reject(1) : Promise<never>
>Promise.reject : <T = never>(reason?: any) => Promise<T>
>Promise : PromiseConstructor
>reject : <T = never>(reason?: any) => Promise<T>
>1 : 1

  );

  if (p1Error) return;
>p1Error : Error | undefined

  p1;
>p1 : number
}

function test4([[p1, p1Error]]: [[undefined, Error] | [number, undefined]]) {
>test4 : ([[p1, p1Error]]: [[undefined, Error] | [number, undefined]]) => void
>p1 : number | undefined
>p1Error : Error | undefined

  if (Math.random()) {
>Math.random() : number
>Math.random : () => number
>Math : Math
>random : () => number

    p1 = undefined;
>p1 = undefined : undefined
>p1 : number | undefined
>undefined : undefined
  }
  if (p1Error) {
>p1Error : Error | undefined

    return;
  }

  p1;
>p1 : number | undefined
}