mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-11-18 17:21:48 +00:00
Accept new baselines
This commit is contained in:
Anders Hejlsberg
@@ -0,0 +1,83 @@
|
||||
tests/cases/conformance/types/conditional/inferTypes1.ts(34,23): error TS2344: Type 'string' does not satisfy the constraint 'Function'.
|
||||
tests/cases/conformance/types/conditional/inferTypes1.ts(43,25): error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'.
|
||||
tests/cases/conformance/types/conditional/inferTypes1.ts(44,25): error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'.
|
||||
Type 'Function' provides no match for the signature '(x: any): any'.
|
||||
|
||||
|
||||
==== tests/cases/conformance/types/conditional/inferTypes1.ts (3 errors) ====
|
||||
type Unpacked<T> =
|
||||
T extends (infer U)[] ? U :
|
||||
T extends (...args: any[]) => infer U ? U :
|
||||
T extends Promise<infer U> ? U :
|
||||
T;
|
||||
|
||||
type T00 = Unpacked<string>; // string
|
||||
type T01 = Unpacked<string[]>; // string
|
||||
type T02 = Unpacked<() => string>; // string
|
||||
type T03 = Unpacked<Promise<string>>; // string
|
||||
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
|
||||
type T05 = Unpacked<any>; // any
|
||||
type T06 = Unpacked<never>; // never
|
||||
|
||||
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
|
||||
|
||||
function f1(s: string) {
|
||||
return { a: 1, b: s };
|
||||
}
|
||||
|
||||
class C {
|
||||
x = 0;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
type T10 = ReturnType<() => string>; // string
|
||||
type T11 = ReturnType<(s: string) => void>; // void
|
||||
type T12 = ReturnType<(<T>() => T)>; // {}
|
||||
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
|
||||
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
|
||||
type T15 = ReturnType<typeof C>; // C
|
||||
type T16 = ReturnType<any>; // any
|
||||
type T17 = ReturnType<never>; // any
|
||||
type T18 = ReturnType<string>; // Error
|
||||
~~~~~~
|
||||
!!! error TS2344: Type 'string' does not satisfy the constraint 'Function'.
|
||||
type T19 = ReturnType<Function>; // any
|
||||
|
||||
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
|
||||
|
||||
type T20 = ArgumentType<() => void>; // never
|
||||
type T21 = ArgumentType<(x: string) => number>; // string
|
||||
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
|
||||
type T23 = ArgumentType<(...args: string[]) => number>; // string
|
||||
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
!!! error TS2344: Type '(x: string, y: string) => number' does not satisfy the constraint '(x: any) => any'.
|
||||
type T25 = ArgumentType<Function>; // Error
|
||||
~~~~~~~~
|
||||
!!! error TS2344: Type 'Function' does not satisfy the constraint '(x: any) => any'.
|
||||
!!! error TS2344: Type 'Function' provides no match for the signature '(x: any): any'.
|
||||
type T26 = ArgumentType<any>; // any
|
||||
type T27 = ArgumentType<never>; // any
|
||||
|
||||
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
|
||||
|
||||
type T30 = X1<{ x: any, y: any }>; // [any, any]
|
||||
type T31 = X1<{ x: number, y: string }>; // [number, string]
|
||||
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
|
||||
|
||||
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
|
||||
|
||||
type T40 = X2<{}>; // never
|
||||
type T41 = X2<{ a: string }>; // never
|
||||
type T42 = X2<{ a: string, b: string }>; // string
|
||||
type T43 = X2<{ a: number, b: string }>; // string | number
|
||||
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
|
||||
|
||||
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
|
||||
|
||||
type T50 = X3<{}>; // never
|
||||
type T51 = X3<{ a: (x: string) => void }>; // never
|
||||
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
|
||||
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
|
||||
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
|
||||
|
||||
@@ -0,0 +1,183 @@
|
||||
//// [inferTypes1.ts]
|
||||
type Unpacked<T> =
|
||||
T extends (infer U)[] ? U :
|
||||
T extends (...args: any[]) => infer U ? U :
|
||||
T extends Promise<infer U> ? U :
|
||||
T;
|
||||
|
||||
type T00 = Unpacked<string>; // string
|
||||
type T01 = Unpacked<string[]>; // string
|
||||
type T02 = Unpacked<() => string>; // string
|
||||
type T03 = Unpacked<Promise<string>>; // string
|
||||
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
|
||||
type T05 = Unpacked<any>; // any
|
||||
type T06 = Unpacked<never>; // never
|
||||
|
||||
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
|
||||
|
||||
function f1(s: string) {
|
||||
return { a: 1, b: s };
|
||||
}
|
||||
|
||||
class C {
|
||||
x = 0;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
type T10 = ReturnType<() => string>; // string
|
||||
type T11 = ReturnType<(s: string) => void>; // void
|
||||
type T12 = ReturnType<(<T>() => T)>; // {}
|
||||
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
|
||||
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
|
||||
type T15 = ReturnType<typeof C>; // C
|
||||
type T16 = ReturnType<any>; // any
|
||||
type T17 = ReturnType<never>; // any
|
||||
type T18 = ReturnType<string>; // Error
|
||||
type T19 = ReturnType<Function>; // any
|
||||
|
||||
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
|
||||
|
||||
type T20 = ArgumentType<() => void>; // never
|
||||
type T21 = ArgumentType<(x: string) => number>; // string
|
||||
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
|
||||
type T23 = ArgumentType<(...args: string[]) => number>; // string
|
||||
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
|
||||
type T25 = ArgumentType<Function>; // Error
|
||||
type T26 = ArgumentType<any>; // any
|
||||
type T27 = ArgumentType<never>; // any
|
||||
|
||||
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
|
||||
|
||||
type T30 = X1<{ x: any, y: any }>; // [any, any]
|
||||
type T31 = X1<{ x: number, y: string }>; // [number, string]
|
||||
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
|
||||
|
||||
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
|
||||
|
||||
type T40 = X2<{}>; // never
|
||||
type T41 = X2<{ a: string }>; // never
|
||||
type T42 = X2<{ a: string, b: string }>; // string
|
||||
type T43 = X2<{ a: number, b: string }>; // string | number
|
||||
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
|
||||
|
||||
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
|
||||
|
||||
type T50 = X3<{}>; // never
|
||||
type T51 = X3<{ a: (x: string) => void }>; // never
|
||||
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
|
||||
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
|
||||
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
|
||||
|
||||
|
||||
//// [inferTypes1.js]
|
||||
"use strict";
|
||||
function f1(s) {
|
||||
return { a: 1, b: s };
|
||||
}
|
||||
var C = /** @class */ (function () {
|
||||
function C() {
|
||||
this.x = 0;
|
||||
this.y = 0;
|
||||
}
|
||||
return C;
|
||||
}());
|
||||
|
||||
|
||||
//// [inferTypes1.d.ts]
|
||||
declare type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
|
||||
declare type T00 = Unpacked<string>;
|
||||
declare type T01 = Unpacked<string[]>;
|
||||
declare type T02 = Unpacked<() => string>;
|
||||
declare type T03 = Unpacked<Promise<string>>;
|
||||
declare type T04 = Unpacked<Unpacked<Promise<string>[]>>;
|
||||
declare type T05 = Unpacked<any>;
|
||||
declare type T06 = Unpacked<never>;
|
||||
declare type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
|
||||
declare function f1(s: string): {
|
||||
a: number;
|
||||
b: string;
|
||||
};
|
||||
declare class C {
|
||||
x: number;
|
||||
y: number;
|
||||
}
|
||||
declare type T10 = ReturnType<() => string>;
|
||||
declare type T11 = ReturnType<(s: string) => void>;
|
||||
declare type T12 = ReturnType<(<T>() => T)>;
|
||||
declare type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;
|
||||
declare type T14 = ReturnType<typeof f1>;
|
||||
declare type T15 = ReturnType<typeof C>;
|
||||
declare type T16 = ReturnType<any>;
|
||||
declare type T17 = ReturnType<never>;
|
||||
declare type T18 = ReturnType<string>;
|
||||
declare type T19 = ReturnType<Function>;
|
||||
declare type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
|
||||
declare type T20 = ArgumentType<() => void>;
|
||||
declare type T21 = ArgumentType<(x: string) => number>;
|
||||
declare type T22 = ArgumentType<(x?: string) => number>;
|
||||
declare type T23 = ArgumentType<(...args: string[]) => number>;
|
||||
declare type T24 = ArgumentType<(x: string, y: string) => number>;
|
||||
declare type T25 = ArgumentType<Function>;
|
||||
declare type T26 = ArgumentType<any>;
|
||||
declare type T27 = ArgumentType<never>;
|
||||
declare type X1<T extends {
|
||||
x: any;
|
||||
y: any;
|
||||
}> = T extends {
|
||||
x: infer X;
|
||||
y: infer Y;
|
||||
} ? [X, Y] : any;
|
||||
declare type T30 = X1<{
|
||||
x: any;
|
||||
y: any;
|
||||
}>;
|
||||
declare type T31 = X1<{
|
||||
x: number;
|
||||
y: string;
|
||||
}>;
|
||||
declare type T32 = X1<{
|
||||
x: number;
|
||||
y: string;
|
||||
z: boolean;
|
||||
}>;
|
||||
declare type X2<T> = T extends {
|
||||
a: infer U;
|
||||
b: infer U;
|
||||
} ? U : never;
|
||||
declare type T40 = X2<{}>;
|
||||
declare type T41 = X2<{
|
||||
a: string;
|
||||
}>;
|
||||
declare type T42 = X2<{
|
||||
a: string;
|
||||
b: string;
|
||||
}>;
|
||||
declare type T43 = X2<{
|
||||
a: number;
|
||||
b: string;
|
||||
}>;
|
||||
declare type T44 = X2<{
|
||||
a: number;
|
||||
b: string;
|
||||
c: boolean;
|
||||
}>;
|
||||
declare type X3<T> = T extends {
|
||||
a: (x: infer U) => void;
|
||||
b: (x: infer U) => void;
|
||||
} ? U : never;
|
||||
declare type T50 = X3<{}>;
|
||||
declare type T51 = X3<{
|
||||
a: (x: string) => void;
|
||||
}>;
|
||||
declare type T52 = X3<{
|
||||
a: (x: string) => void;
|
||||
b: (x: string) => void;
|
||||
}>;
|
||||
declare type T53 = X3<{
|
||||
a: (x: number) => void;
|
||||
b: (x: string) => void;
|
||||
}>;
|
||||
declare type T54 = X3<{
|
||||
a: (x: number) => void;
|
||||
b: () => void;
|
||||
}>;
|
||||
@@ -0,0 +1,299 @@
|
||||
=== tests/cases/conformance/types/conditional/inferTypes1.ts ===
|
||||
type Unpacked<T> =
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 0, 14))
|
||||
|
||||
T extends (infer U)[] ? U :
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 0, 14))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 1, 20))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 1, 20))
|
||||
|
||||
T extends (...args: any[]) => infer U ? U :
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 0, 14))
|
||||
>args : Symbol(args, Decl(inferTypes1.ts, 2, 15))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 2, 39))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 2, 39))
|
||||
|
||||
T extends Promise<infer U> ? U :
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 0, 14))
|
||||
>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 3, 27))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 3, 27))
|
||||
|
||||
T;
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 0, 14))
|
||||
|
||||
type T00 = Unpacked<string>; // string
|
||||
>T00 : Symbol(T00, Decl(inferTypes1.ts, 4, 6))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
|
||||
type T01 = Unpacked<string[]>; // string
|
||||
>T01 : Symbol(T01, Decl(inferTypes1.ts, 6, 28))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
|
||||
type T02 = Unpacked<() => string>; // string
|
||||
>T02 : Symbol(T02, Decl(inferTypes1.ts, 7, 30))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
|
||||
type T03 = Unpacked<Promise<string>>; // string
|
||||
>T03 : Symbol(T03, Decl(inferTypes1.ts, 8, 34))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
|
||||
|
||||
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
|
||||
>T04 : Symbol(T04, Decl(inferTypes1.ts, 9, 37))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
>Promise : Symbol(Promise, Decl(lib.d.ts, --, --))
|
||||
|
||||
type T05 = Unpacked<any>; // any
|
||||
>T05 : Symbol(T05, Decl(inferTypes1.ts, 10, 49))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
|
||||
type T06 = Unpacked<never>; // never
|
||||
>T06 : Symbol(T06, Decl(inferTypes1.ts, 11, 25))
|
||||
>Unpacked : Symbol(Unpacked, Decl(inferTypes1.ts, 0, 0))
|
||||
|
||||
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 14, 16))
|
||||
>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 14, 16))
|
||||
>args : Symbol(args, Decl(inferTypes1.ts, 14, 50))
|
||||
>R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110))
|
||||
>args : Symbol(args, Decl(inferTypes1.ts, 14, 86))
|
||||
>R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110))
|
||||
>R : Symbol(R, Decl(inferTypes1.ts, 14, 74), Decl(inferTypes1.ts, 14, 110))
|
||||
|
||||
function f1(s: string) {
|
||||
>f1 : Symbol(f1, Decl(inferTypes1.ts, 14, 124))
|
||||
>s : Symbol(s, Decl(inferTypes1.ts, 16, 12))
|
||||
|
||||
return { a: 1, b: s };
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 17, 12))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 17, 18))
|
||||
>s : Symbol(s, Decl(inferTypes1.ts, 16, 12))
|
||||
}
|
||||
|
||||
class C {
|
||||
>C : Symbol(C, Decl(inferTypes1.ts, 18, 1))
|
||||
|
||||
x = 0;
|
||||
>x : Symbol(C.x, Decl(inferTypes1.ts, 20, 9))
|
||||
|
||||
y = 0;
|
||||
>y : Symbol(C.y, Decl(inferTypes1.ts, 21, 10))
|
||||
}
|
||||
|
||||
type T10 = ReturnType<() => string>; // string
|
||||
>T10 : Symbol(T10, Decl(inferTypes1.ts, 23, 1))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
|
||||
type T11 = ReturnType<(s: string) => void>; // void
|
||||
>T11 : Symbol(T11, Decl(inferTypes1.ts, 25, 36))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>s : Symbol(s, Decl(inferTypes1.ts, 26, 23))
|
||||
|
||||
type T12 = ReturnType<(<T>() => T)>; // {}
|
||||
>T12 : Symbol(T12, Decl(inferTypes1.ts, 26, 43))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 27, 24))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 27, 24))
|
||||
|
||||
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
|
||||
>T13 : Symbol(T13, Decl(inferTypes1.ts, 27, 36))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 28, 24))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 28, 36))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 28, 36))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 28, 24))
|
||||
|
||||
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
|
||||
>T14 : Symbol(T14, Decl(inferTypes1.ts, 28, 66))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>f1 : Symbol(f1, Decl(inferTypes1.ts, 14, 124))
|
||||
|
||||
type T15 = ReturnType<typeof C>; // C
|
||||
>T15 : Symbol(T15, Decl(inferTypes1.ts, 29, 33))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>C : Symbol(C, Decl(inferTypes1.ts, 18, 1))
|
||||
|
||||
type T16 = ReturnType<any>; // any
|
||||
>T16 : Symbol(T16, Decl(inferTypes1.ts, 30, 32))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
|
||||
type T17 = ReturnType<never>; // any
|
||||
>T17 : Symbol(T17, Decl(inferTypes1.ts, 31, 27))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
|
||||
type T18 = ReturnType<string>; // Error
|
||||
>T18 : Symbol(T18, Decl(inferTypes1.ts, 32, 29))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
|
||||
type T19 = ReturnType<Function>; // any
|
||||
>T19 : Symbol(T19, Decl(inferTypes1.ts, 33, 30))
|
||||
>ReturnType : Symbol(ReturnType, Decl(inferTypes1.ts, 12, 27))
|
||||
>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
|
||||
|
||||
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 36, 18))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 36, 29))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 36, 18))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 36, 58))
|
||||
>A : Symbol(A, Decl(inferTypes1.ts, 36, 66))
|
||||
>A : Symbol(A, Decl(inferTypes1.ts, 36, 66))
|
||||
|
||||
type T20 = ArgumentType<() => void>; // never
|
||||
>T20 : Symbol(T20, Decl(inferTypes1.ts, 36, 87))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
|
||||
type T21 = ArgumentType<(x: string) => number>; // string
|
||||
>T21 : Symbol(T21, Decl(inferTypes1.ts, 38, 36))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 39, 25))
|
||||
|
||||
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
|
||||
>T22 : Symbol(T22, Decl(inferTypes1.ts, 39, 47))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 40, 25))
|
||||
|
||||
type T23 = ArgumentType<(...args: string[]) => number>; // string
|
||||
>T23 : Symbol(T23, Decl(inferTypes1.ts, 40, 48))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>args : Symbol(args, Decl(inferTypes1.ts, 41, 25))
|
||||
|
||||
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
|
||||
>T24 : Symbol(T24, Decl(inferTypes1.ts, 41, 55))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 42, 25))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 42, 35))
|
||||
|
||||
type T25 = ArgumentType<Function>; // Error
|
||||
>T25 : Symbol(T25, Decl(inferTypes1.ts, 42, 58))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
|
||||
|
||||
type T26 = ArgumentType<any>; // any
|
||||
>T26 : Symbol(T26, Decl(inferTypes1.ts, 43, 34))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
|
||||
type T27 = ArgumentType<never>; // any
|
||||
>T27 : Symbol(T27, Decl(inferTypes1.ts, 44, 29))
|
||||
>ArgumentType : Symbol(ArgumentType, Decl(inferTypes1.ts, 34, 32))
|
||||
|
||||
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
|
||||
>X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 47, 8))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 47, 19))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 47, 27))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 47, 8))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 47, 51))
|
||||
>X : Symbol(X, Decl(inferTypes1.ts, 47, 60))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 47, 63))
|
||||
>Y : Symbol(Y, Decl(inferTypes1.ts, 47, 72))
|
||||
>X : Symbol(X, Decl(inferTypes1.ts, 47, 60))
|
||||
>Y : Symbol(Y, Decl(inferTypes1.ts, 47, 72))
|
||||
|
||||
type T30 = X1<{ x: any, y: any }>; // [any, any]
|
||||
>T30 : Symbol(T30, Decl(inferTypes1.ts, 47, 92))
|
||||
>X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 49, 15))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 49, 23))
|
||||
|
||||
type T31 = X1<{ x: number, y: string }>; // [number, string]
|
||||
>T31 : Symbol(T31, Decl(inferTypes1.ts, 49, 34))
|
||||
>X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 50, 15))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 50, 26))
|
||||
|
||||
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
|
||||
>T32 : Symbol(T32, Decl(inferTypes1.ts, 50, 40))
|
||||
>X1 : Symbol(X1, Decl(inferTypes1.ts, 45, 31))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 51, 15))
|
||||
>y : Symbol(y, Decl(inferTypes1.ts, 51, 26))
|
||||
>z : Symbol(z, Decl(inferTypes1.ts, 51, 37))
|
||||
|
||||
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 53, 8))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 53, 8))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 53, 24))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 53, 36))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 53, 33), Decl(inferTypes1.ts, 53, 45))
|
||||
|
||||
type T40 = X2<{}>; // never
|
||||
>T40 : Symbol(T40, Decl(inferTypes1.ts, 53, 62))
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
|
||||
type T41 = X2<{ a: string }>; // never
|
||||
>T41 : Symbol(T41, Decl(inferTypes1.ts, 55, 18))
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 56, 15))
|
||||
|
||||
type T42 = X2<{ a: string, b: string }>; // string
|
||||
>T42 : Symbol(T42, Decl(inferTypes1.ts, 56, 29))
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 57, 15))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 57, 26))
|
||||
|
||||
type T43 = X2<{ a: number, b: string }>; // string | number
|
||||
>T43 : Symbol(T43, Decl(inferTypes1.ts, 57, 40))
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 58, 15))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 58, 26))
|
||||
|
||||
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
|
||||
>T44 : Symbol(T44, Decl(inferTypes1.ts, 58, 40))
|
||||
>X2 : Symbol(X2, Decl(inferTypes1.ts, 51, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 59, 15))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 59, 26))
|
||||
>c : Symbol(c, Decl(inferTypes1.ts, 59, 37))
|
||||
|
||||
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 61, 8))
|
||||
>T : Symbol(T, Decl(inferTypes1.ts, 61, 8))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 61, 24))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 61, 29))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 61, 49))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 61, 54))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62))
|
||||
>U : Symbol(U, Decl(inferTypes1.ts, 61, 37), Decl(inferTypes1.ts, 61, 62))
|
||||
|
||||
type T50 = X3<{}>; // never
|
||||
>T50 : Symbol(T50, Decl(inferTypes1.ts, 61, 88))
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
|
||||
type T51 = X3<{ a: (x: string) => void }>; // never
|
||||
>T51 : Symbol(T51, Decl(inferTypes1.ts, 63, 18))
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 64, 15))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 64, 20))
|
||||
|
||||
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
|
||||
>T52 : Symbol(T52, Decl(inferTypes1.ts, 64, 42))
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 65, 15))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 65, 20))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 65, 39))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 65, 44))
|
||||
|
||||
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
|
||||
>T53 : Symbol(T53, Decl(inferTypes1.ts, 65, 66))
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 66, 15))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 66, 20))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 66, 39))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 66, 44))
|
||||
|
||||
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
|
||||
>T54 : Symbol(T54, Decl(inferTypes1.ts, 66, 66))
|
||||
>X3 : Symbol(X3, Decl(inferTypes1.ts, 59, 52))
|
||||
>a : Symbol(a, Decl(inferTypes1.ts, 67, 15))
|
||||
>x : Symbol(x, Decl(inferTypes1.ts, 67, 20))
|
||||
>b : Symbol(b, Decl(inferTypes1.ts, 67, 39))
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
=== tests/cases/conformance/types/conditional/inferTypes1.ts ===
|
||||
type Unpacked<T> =
|
||||
>Unpacked : Unpacked<T>
|
||||
>T : T
|
||||
|
||||
T extends (infer U)[] ? U :
|
||||
>T : T
|
||||
>U : U
|
||||
>U : U
|
||||
|
||||
T extends (...args: any[]) => infer U ? U :
|
||||
>T : T
|
||||
>args : any[]
|
||||
>U : U
|
||||
>U : U
|
||||
|
||||
T extends Promise<infer U> ? U :
|
||||
>T : T
|
||||
>Promise : Promise<T>
|
||||
>U : U
|
||||
>U : U
|
||||
|
||||
T;
|
||||
>T : T
|
||||
|
||||
type T00 = Unpacked<string>; // string
|
||||
>T00 : string
|
||||
>Unpacked : Unpacked<T>
|
||||
|
||||
type T01 = Unpacked<string[]>; // string
|
||||
>T01 : string
|
||||
>Unpacked : Unpacked<T>
|
||||
|
||||
type T02 = Unpacked<() => string>; // string
|
||||
>T02 : string
|
||||
>Unpacked : Unpacked<T>
|
||||
|
||||
type T03 = Unpacked<Promise<string>>; // string
|
||||
>T03 : string
|
||||
>Unpacked : Unpacked<T>
|
||||
>Promise : Promise<T>
|
||||
|
||||
type T04 = Unpacked<Unpacked<Promise<string>[]>>; // string
|
||||
>T04 : string
|
||||
>Unpacked : Unpacked<T>
|
||||
>Unpacked : Unpacked<T>
|
||||
>Promise : Promise<T>
|
||||
|
||||
type T05 = Unpacked<any>; // any
|
||||
>T05 : any
|
||||
>Unpacked : Unpacked<T>
|
||||
|
||||
type T06 = Unpacked<never>; // never
|
||||
>T06 : never
|
||||
>Unpacked : Unpacked<T>
|
||||
|
||||
type ReturnType<T extends Function> = T extends ((...args: any[]) => infer R) | (new (...args: any[]) => infer R) ? R : any;
|
||||
>ReturnType : ReturnType<T>
|
||||
>T : T
|
||||
>Function : Function
|
||||
>T : T
|
||||
>args : any[]
|
||||
>R : R
|
||||
>args : any[]
|
||||
>R : R
|
||||
>R : R
|
||||
|
||||
function f1(s: string) {
|
||||
>f1 : (s: string) => { a: number; b: string; }
|
||||
>s : string
|
||||
|
||||
return { a: 1, b: s };
|
||||
>{ a: 1, b: s } : { a: number; b: string; }
|
||||
>a : number
|
||||
>1 : 1
|
||||
>b : string
|
||||
>s : string
|
||||
}
|
||||
|
||||
class C {
|
||||
>C : C
|
||||
|
||||
x = 0;
|
||||
>x : number
|
||||
>0 : 0
|
||||
|
||||
y = 0;
|
||||
>y : number
|
||||
>0 : 0
|
||||
}
|
||||
|
||||
type T10 = ReturnType<() => string>; // string
|
||||
>T10 : string
|
||||
>ReturnType : ReturnType<T>
|
||||
|
||||
type T11 = ReturnType<(s: string) => void>; // void
|
||||
>T11 : void
|
||||
>ReturnType : ReturnType<T>
|
||||
>s : string
|
||||
|
||||
type T12 = ReturnType<(<T>() => T)>; // {}
|
||||
>T12 : {}
|
||||
>ReturnType : ReturnType<T>
|
||||
>T : T
|
||||
>T : T
|
||||
|
||||
type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
|
||||
>T13 : number[]
|
||||
>ReturnType : ReturnType<T>
|
||||
>T : T
|
||||
>U : U
|
||||
>U : U
|
||||
>T : T
|
||||
|
||||
type T14 = ReturnType<typeof f1>; // { a: number, b: string }
|
||||
>T14 : { a: number; b: string; }
|
||||
>ReturnType : ReturnType<T>
|
||||
>f1 : (s: string) => { a: number; b: string; }
|
||||
|
||||
type T15 = ReturnType<typeof C>; // C
|
||||
>T15 : C
|
||||
>ReturnType : ReturnType<T>
|
||||
>C : typeof C
|
||||
|
||||
type T16 = ReturnType<any>; // any
|
||||
>T16 : any
|
||||
>ReturnType : ReturnType<T>
|
||||
|
||||
type T17 = ReturnType<never>; // any
|
||||
>T17 : any
|
||||
>ReturnType : ReturnType<T>
|
||||
|
||||
type T18 = ReturnType<string>; // Error
|
||||
>T18 : any
|
||||
>ReturnType : ReturnType<T>
|
||||
|
||||
type T19 = ReturnType<Function>; // any
|
||||
>T19 : any
|
||||
>ReturnType : ReturnType<T>
|
||||
>Function : Function
|
||||
|
||||
type ArgumentType<T extends (x: any) => any> = T extends (a: infer A) => any ? A : any;
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>T : T
|
||||
>x : any
|
||||
>T : T
|
||||
>a : A
|
||||
>A : A
|
||||
>A : A
|
||||
|
||||
type T20 = ArgumentType<() => void>; // never
|
||||
>T20 : never
|
||||
>ArgumentType : ArgumentType<T>
|
||||
|
||||
type T21 = ArgumentType<(x: string) => number>; // string
|
||||
>T21 : string
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>x : string
|
||||
|
||||
type T22 = ArgumentType<(x?: string) => number>; // string | undefined
|
||||
>T22 : string | undefined
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>x : string | undefined
|
||||
|
||||
type T23 = ArgumentType<(...args: string[]) => number>; // string
|
||||
>T23 : string
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>args : string[]
|
||||
|
||||
type T24 = ArgumentType<(x: string, y: string) => number>; // Error
|
||||
>T24 : any
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>x : string
|
||||
>y : string
|
||||
|
||||
type T25 = ArgumentType<Function>; // Error
|
||||
>T25 : any
|
||||
>ArgumentType : ArgumentType<T>
|
||||
>Function : Function
|
||||
|
||||
type T26 = ArgumentType<any>; // any
|
||||
>T26 : any
|
||||
>ArgumentType : ArgumentType<T>
|
||||
|
||||
type T27 = ArgumentType<never>; // any
|
||||
>T27 : any
|
||||
>ArgumentType : ArgumentType<T>
|
||||
|
||||
type X1<T extends { x: any, y: any }> = T extends { x: infer X, y: infer Y } ? [X, Y] : any;
|
||||
>X1 : X1<T>
|
||||
>T : T
|
||||
>x : any
|
||||
>y : any
|
||||
>T : T
|
||||
>x : X
|
||||
>X : X
|
||||
>y : Y
|
||||
>Y : Y
|
||||
>X : X
|
||||
>Y : Y
|
||||
|
||||
type T30 = X1<{ x: any, y: any }>; // [any, any]
|
||||
>T30 : [any, any]
|
||||
>X1 : X1<T>
|
||||
>x : any
|
||||
>y : any
|
||||
|
||||
type T31 = X1<{ x: number, y: string }>; // [number, string]
|
||||
>T31 : [number, string]
|
||||
>X1 : X1<T>
|
||||
>x : number
|
||||
>y : string
|
||||
|
||||
type T32 = X1<{ x: number, y: string, z: boolean }>; // [number, string]
|
||||
>T32 : [number, string]
|
||||
>X1 : X1<T>
|
||||
>x : number
|
||||
>y : string
|
||||
>z : boolean
|
||||
|
||||
type X2<T> = T extends { a: infer U, b: infer U } ? U : never;
|
||||
>X2 : X2<T>
|
||||
>T : T
|
||||
>T : T
|
||||
>a : U
|
||||
>U : U
|
||||
>b : U
|
||||
>U : U
|
||||
>U : U
|
||||
|
||||
type T40 = X2<{}>; // never
|
||||
>T40 : never
|
||||
>X2 : X2<T>
|
||||
|
||||
type T41 = X2<{ a: string }>; // never
|
||||
>T41 : never
|
||||
>X2 : X2<T>
|
||||
>a : string
|
||||
|
||||
type T42 = X2<{ a: string, b: string }>; // string
|
||||
>T42 : string
|
||||
>X2 : X2<T>
|
||||
>a : string
|
||||
>b : string
|
||||
|
||||
type T43 = X2<{ a: number, b: string }>; // string | number
|
||||
>T43 : string | number
|
||||
>X2 : X2<T>
|
||||
>a : number
|
||||
>b : string
|
||||
|
||||
type T44 = X2<{ a: number, b: string, c: boolean }>; // string | number
|
||||
>T44 : string | number
|
||||
>X2 : X2<T>
|
||||
>a : number
|
||||
>b : string
|
||||
>c : boolean
|
||||
|
||||
type X3<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
|
||||
>X3 : X3<T>
|
||||
>T : T
|
||||
>T : T
|
||||
>a : (x: U) => void
|
||||
>x : U
|
||||
>U : U
|
||||
>b : (x: U) => void
|
||||
>x : U
|
||||
>U : U
|
||||
>U : U
|
||||
|
||||
type T50 = X3<{}>; // never
|
||||
>T50 : never
|
||||
>X3 : X3<T>
|
||||
|
||||
type T51 = X3<{ a: (x: string) => void }>; // never
|
||||
>T51 : never
|
||||
>X3 : X3<T>
|
||||
>a : (x: string) => void
|
||||
>x : string
|
||||
|
||||
type T52 = X3<{ a: (x: string) => void, b: (x: string) => void }>; // string
|
||||
>T52 : string
|
||||
>X3 : X3<T>
|
||||
>a : (x: string) => void
|
||||
>x : string
|
||||
>b : (x: string) => void
|
||||
>x : string
|
||||
|
||||
type T53 = X3<{ a: (x: number) => void, b: (x: string) => void }>; // string & number
|
||||
>T53 : number & string
|
||||
>X3 : X3<T>
|
||||
>a : (x: number) => void
|
||||
>x : number
|
||||
>b : (x: string) => void
|
||||
>x : string
|
||||
|
||||
type T54 = X3<{ a: (x: number) => void, b: () => void }>; // number
|
||||
>T54 : number
|
||||
>X3 : X3<T>
|
||||
>a : (x: number) => void
|
||||
>x : number
|
||||
>b : () => void
|
||||
|
||||
Reference in New Issue
Block a user