449 lines
14 KiB
Plaintext
449 lines
14 KiB
Plaintext
=== tests/cases/compiler/instantiateContextualTypes.ts ===
|
|
// #6611
|
|
|
|
export interface A<a> {
|
|
value: a;
|
|
>value : a
|
|
}
|
|
|
|
function fn<a>(values: A<a>, value: a) : void {
|
|
>fn : <a>(values: A<a>, value: a) => void
|
|
>values : A<a>
|
|
>value : a
|
|
}
|
|
|
|
declare let handlers: A<(value: number) => void>;
|
|
>handlers : A<(value: number) => void>
|
|
>value : number
|
|
|
|
fn(handlers, value => alert(value));
|
|
>fn(handlers, value => alert(value)) : void
|
|
>fn : <a>(values: A<a>, value: a) => void
|
|
>handlers : A<(value: number) => void>
|
|
>value => alert(value) : (value: number) => void
|
|
>value : number
|
|
>alert(value) : void
|
|
>alert : (message?: any) => void
|
|
>value : number
|
|
|
|
// #21382
|
|
|
|
interface BaseProps<T> {
|
|
initialValues: T;
|
|
>initialValues : T
|
|
|
|
nextValues: (cur: T) => T;
|
|
>nextValues : (cur: T) => T
|
|
>cur : T
|
|
}
|
|
declare class Component<P> { constructor(props: P); props: P; }
|
|
>Component : Component<P>
|
|
>props : P
|
|
>props : P
|
|
|
|
declare class GenericComponent<Props = {}, Values = object>
|
|
>GenericComponent : GenericComponent<Props, Values>
|
|
|
|
extends Component<Props & BaseProps<Values>> {
|
|
>Component : Component<Props & BaseProps<Values>>
|
|
|
|
iv: Values;
|
|
>iv : Values
|
|
}
|
|
|
|
new GenericComponent({ initialValues: 12, nextValues: val => 12 });
|
|
>new GenericComponent({ initialValues: 12, nextValues: val => 12 }) : GenericComponent<{ initialValues: number; nextValues: (val: number) => number; }, number>
|
|
>GenericComponent : typeof GenericComponent
|
|
>{ initialValues: 12, nextValues: val => 12 } : { initialValues: number; nextValues: (val: number) => number; }
|
|
>initialValues : number
|
|
>12 : 12
|
|
>nextValues : (val: number) => number
|
|
>val => 12 : (val: number) => number
|
|
>val : number
|
|
>12 : 12
|
|
|
|
// #22149
|
|
|
|
declare function useStringOrNumber<T extends string | number>(t: T, useIt: T extends string ? ((s: string) => void) : ((n: number) => void)): void;
|
|
>useStringOrNumber : <T extends string | number>(t: T, useIt: T extends string ? (s: string) => void : (n: number) => void) => void
|
|
>t : T
|
|
>useIt : T extends string ? (s: string) => void : (n: number) => void
|
|
>s : string
|
|
>n : number
|
|
|
|
useStringOrNumber("", foo => {});
|
|
>useStringOrNumber("", foo => {}) : void
|
|
>useStringOrNumber : <T extends string | number>(t: T, useIt: T extends string ? (s: string) => void : (n: number) => void) => void
|
|
>"" : ""
|
|
>foo => {} : (foo: string) => void
|
|
>foo : string
|
|
|
|
// #25299
|
|
|
|
type ActionType<P> = string & { attachPayloadTypeHack?: P & never }
|
|
>ActionType : ActionType<P>
|
|
>attachPayloadTypeHack : undefined
|
|
|
|
type Handler<S, P> = P extends void
|
|
>Handler : Handler<S, P>
|
|
|
|
? (state: S) => S
|
|
>state : S
|
|
|
|
: (state: S, payload: P) => S
|
|
>state : S
|
|
>payload : P
|
|
|
|
interface ActionHandler<S, P> {
|
|
actionType: ActionType<P>
|
|
>actionType : ActionType<P>
|
|
|
|
handler: Handler<S, P>
|
|
>handler : Handler<S, P>
|
|
}
|
|
|
|
declare function handler<S, P>(actionType: ActionType<P>, handler: Handler<S, P>): ActionHandler<S, P>
|
|
>handler : <S, P>(actionType: ActionType<P>, handler: Handler<S, P>) => ActionHandler<S, P>
|
|
>actionType : ActionType<P>
|
|
>handler : Handler<S, P>
|
|
|
|
declare function createReducer<S>(
|
|
>createReducer : <S>(defaultState: S, ...actionHandlers: ActionHandler<S, any>[]) => any
|
|
|
|
defaultState: S,
|
|
>defaultState : S
|
|
|
|
...actionHandlers: ActionHandler<S, any>[]
|
|
>actionHandlers : ActionHandler<S, any>[]
|
|
|
|
): any
|
|
|
|
interface AppState {
|
|
dummy: string
|
|
>dummy : string
|
|
}
|
|
|
|
const defaultState: AppState = {
|
|
>defaultState : AppState
|
|
>{ dummy: ''} : { dummy: string; }
|
|
|
|
dummy: ''
|
|
>dummy : string
|
|
>'' : ""
|
|
}
|
|
|
|
const NON_VOID_ACTION: ActionType<number> = 'NON_VOID_ACTION'
|
|
>NON_VOID_ACTION : ActionType<number>
|
|
>'NON_VOID_ACTION' : "NON_VOID_ACTION"
|
|
|
|
, VOID_ACTION: ActionType<void> = 'VOID_ACTION'
|
|
>VOID_ACTION : ActionType<void>
|
|
>'VOID_ACTION' : "VOID_ACTION"
|
|
|
|
createReducer(
|
|
>createReducer( defaultState, handler(NON_VOID_ACTION, (state, _payload) => state), handler(VOID_ACTION, state => state)) : any
|
|
>createReducer : <S>(defaultState: S, ...actionHandlers: ActionHandler<S, any>[]) => any
|
|
|
|
defaultState,
|
|
>defaultState : AppState
|
|
|
|
handler(NON_VOID_ACTION, (state, _payload) => state),
|
|
>handler(NON_VOID_ACTION, (state, _payload) => state) : ActionHandler<AppState, number>
|
|
>handler : <S, P>(actionType: ActionType<P>, handler: Handler<S, P>) => ActionHandler<S, P>
|
|
>NON_VOID_ACTION : ActionType<number>
|
|
>(state, _payload) => state : (state: AppState, _payload: number) => AppState
|
|
>state : AppState
|
|
>_payload : number
|
|
>state : AppState
|
|
|
|
handler(VOID_ACTION, state => state)
|
|
>handler(VOID_ACTION, state => state) : ActionHandler<AppState, void>
|
|
>handler : <S, P>(actionType: ActionType<P>, handler: Handler<S, P>) => ActionHandler<S, P>
|
|
>VOID_ACTION : ActionType<void>
|
|
>state => state : (state: AppState) => AppState
|
|
>state : AppState
|
|
>state : AppState
|
|
|
|
)
|
|
|
|
// #25814
|
|
|
|
type R = {
|
|
>R : R
|
|
|
|
a: (x: number) => void;
|
|
>a : (x: number) => void
|
|
>x : number
|
|
|
|
b: (x: string) => void;
|
|
>b : (x: string) => void
|
|
>x : string
|
|
|
|
};
|
|
|
|
type O = {
|
|
>O : O
|
|
|
|
on<P extends keyof R>(x: P, callback: R[P]): void;
|
|
>on : <P extends keyof R>(x: P, callback: R[P]) => void
|
|
>x : P
|
|
>callback : R[P]
|
|
|
|
};
|
|
|
|
declare var x: O;
|
|
>x : O
|
|
|
|
x.on('a', a => {});
|
|
>x.on('a', a => {}) : void
|
|
>x.on : <P extends keyof R>(x: P, callback: R[P]) => void
|
|
>x : O
|
|
>on : <P extends keyof R>(x: P, callback: R[P]) => void
|
|
>'a' : "a"
|
|
>a => {} : (a: number) => void
|
|
>a : number
|
|
|
|
// #29775
|
|
|
|
namespace N1 {
|
|
>N1 : typeof N1
|
|
|
|
declare class Component<P> {
|
|
>Component : Component<P>
|
|
|
|
constructor(props: P);
|
|
>props : P
|
|
}
|
|
|
|
interface ComponentClass<P = {}> {
|
|
new (props: P): Component<P>;
|
|
>props : P
|
|
}
|
|
|
|
type CreateElementChildren<P> =
|
|
>CreateElementChildren : P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown
|
|
|
|
P extends { children?: infer C }
|
|
>children : C | undefined
|
|
|
|
? C extends any[]
|
|
? C
|
|
: C[]
|
|
: unknown;
|
|
|
|
declare function createElement<P extends {}>(
|
|
>createElement : <P extends {}>(type: ComponentClass<P>, ...children: P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown) => any
|
|
|
|
type: ComponentClass<P>,
|
|
>type : ComponentClass<P>
|
|
|
|
...children: CreateElementChildren<P>
|
|
>children : P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown
|
|
|
|
): any;
|
|
|
|
declare function createElement2<P extends {}>(
|
|
>createElement2 : <P extends {}>(type: ComponentClass<P>, child: P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown) => any
|
|
|
|
type: ComponentClass<P>,
|
|
>type : ComponentClass<P>
|
|
|
|
child: CreateElementChildren<P>
|
|
>child : P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown
|
|
|
|
): any;
|
|
|
|
class InferFunctionTypes extends Component<{children: (foo: number) => string}> {}
|
|
>InferFunctionTypes : InferFunctionTypes
|
|
>Component : Component<{ children: (foo: number) => string; }>
|
|
>children : (foo: number) => string
|
|
>foo : number
|
|
|
|
createElement(InferFunctionTypes, (foo) => "" + foo);
|
|
>createElement(InferFunctionTypes, (foo) => "" + foo) : any
|
|
>createElement : <P extends {}>(type: ComponentClass<P>, ...children: P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown) => any
|
|
>InferFunctionTypes : typeof InferFunctionTypes
|
|
>(foo) => "" + foo : (foo: number) => string
|
|
>foo : number
|
|
>"" + foo : string
|
|
>"" : ""
|
|
>foo : number
|
|
|
|
createElement2(InferFunctionTypes, [(foo) => "" + foo]);
|
|
>createElement2(InferFunctionTypes, [(foo) => "" + foo]) : any
|
|
>createElement2 : <P extends {}>(type: ComponentClass<P>, child: P extends { children?: infer C | undefined; } ? C extends any[] ? C : C[] : unknown) => any
|
|
>InferFunctionTypes : typeof InferFunctionTypes
|
|
>[(foo) => "" + foo] : ((foo: number) => string)[]
|
|
>(foo) => "" + foo : (foo: number) => string
|
|
>foo : number
|
|
>"" + foo : string
|
|
>"" : ""
|
|
>foo : number
|
|
|
|
}
|
|
|
|
// #30341
|
|
|
|
type InnerBox<T> = {
|
|
>InnerBox : InnerBox<T>
|
|
|
|
value: T;
|
|
>value : T
|
|
}
|
|
|
|
type OuterBox<T> = {
|
|
>OuterBox : OuterBox<T>
|
|
|
|
inner: InnerBox<T>
|
|
>inner : InnerBox<T>
|
|
|
|
};
|
|
|
|
type BoxConsumerFromOuterBox<T> =
|
|
>BoxConsumerFromOuterBox : BoxConsumerFromOuterBox<T>
|
|
|
|
T extends OuterBox<infer U> ?
|
|
(box: InnerBox<U>) => void :
|
|
>box : InnerBox<U>
|
|
|
|
never;
|
|
|
|
declare function passContentsToFunc<T>(outerBox: T, consumer: BoxConsumerFromOuterBox<T>): void;
|
|
>passContentsToFunc : <T>(outerBox: T, consumer: BoxConsumerFromOuterBox<T>) => void
|
|
>outerBox : T
|
|
>consumer : BoxConsumerFromOuterBox<T>
|
|
|
|
declare const outerBoxOfString: OuterBox<string>;
|
|
>outerBoxOfString : OuterBox<string>
|
|
|
|
passContentsToFunc(outerBoxOfString, box => box.value);
|
|
>passContentsToFunc(outerBoxOfString, box => box.value) : void
|
|
>passContentsToFunc : <T>(outerBox: T, consumer: BoxConsumerFromOuterBox<T>) => void
|
|
>outerBoxOfString : OuterBox<string>
|
|
>box => box.value : (box: InnerBox<string>) => string
|
|
>box : InnerBox<string>
|
|
>box.value : string
|
|
>box : InnerBox<string>
|
|
>value : string
|
|
|
|
// Repro from #32349
|
|
|
|
type DooDad = 'SOMETHING' | 'ELSE' ;
|
|
>DooDad : DooDad
|
|
|
|
class Interesting {
|
|
>Interesting : Interesting
|
|
|
|
public compiles = () : Promise<DooDad> => {
|
|
>compiles : () => Promise<DooDad>
|
|
>() : Promise<DooDad> => { return Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; }); } : () => Promise<DooDad>
|
|
|
|
return Promise.resolve().then(() => {
|
|
>Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE">
|
|
>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>Promise.resolve() : Promise<void>
|
|
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>Promise : PromiseConstructor
|
|
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>() => { if (1 < 2) { return 'SOMETHING'; } return 'ELSE'; } : () => "SOMETHING" | "ELSE"
|
|
|
|
if (1 < 2) {
|
|
>1 < 2 : boolean
|
|
>1 : 1
|
|
>2 : 2
|
|
|
|
return 'SOMETHING';
|
|
>'SOMETHING' : "SOMETHING"
|
|
}
|
|
return 'ELSE';
|
|
>'ELSE' : "ELSE"
|
|
|
|
});
|
|
};
|
|
public doesnt = () : Promise<DooDad> => {
|
|
>doesnt : () => Promise<DooDad>
|
|
>() : Promise<DooDad> => { return Promise.resolve().then(() => { return 'ELSE'; }); } : () => Promise<DooDad>
|
|
|
|
return Promise.resolve().then(() => {
|
|
>Promise.resolve().then(() => { return 'ELSE'; }) : Promise<"SOMETHING" | "ELSE">
|
|
>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>Promise.resolve() : Promise<void>
|
|
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>Promise : PromiseConstructor
|
|
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>() => { return 'ELSE'; } : () => "ELSE"
|
|
|
|
return 'ELSE';
|
|
>'ELSE' : "ELSE"
|
|
|
|
});
|
|
};
|
|
public slightlyDifferentErrorMessage = () : Promise<DooDad> => {
|
|
>slightlyDifferentErrorMessage : () => Promise<DooDad>
|
|
>() : Promise<DooDad> => { return Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; }); } : () => Promise<DooDad>
|
|
|
|
return Promise.resolve().then(() => {
|
|
>Promise.resolve().then(() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; }) : Promise<"SOMETHING" | "ELSE">
|
|
>Promise.resolve().then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>Promise.resolve() : Promise<void>
|
|
>Promise.resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>Promise : PromiseConstructor
|
|
>resolve : { (): Promise<void>; <T>(value: T | PromiseLike<T>): Promise<T>; }
|
|
>then : <TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
|
|
>() => { if (1 < 2) { return 'SOMETHING'; } return 'SOMETHING'; } : () => "SOMETHING"
|
|
|
|
if (1 < 2) {
|
|
>1 < 2 : boolean
|
|
>1 : 1
|
|
>2 : 2
|
|
|
|
return 'SOMETHING';
|
|
>'SOMETHING' : "SOMETHING"
|
|
}
|
|
return 'SOMETHING';
|
|
>'SOMETHING' : "SOMETHING"
|
|
|
|
});
|
|
};
|
|
}
|
|
|
|
// Repro from #32349
|
|
|
|
declare function invoke<T>(f: () => T): T;
|
|
>invoke : <T>(f: () => T) => T
|
|
>f : () => T
|
|
|
|
let xx: 0 | 1 | 2 = invoke(() => 1);
|
|
>xx : 0 | 1 | 2
|
|
>invoke(() => 1) : 1
|
|
>invoke : <T>(f: () => T) => T
|
|
>() => 1 : () => 1
|
|
>1 : 1
|
|
|
|
// Repro from #32416
|
|
|
|
declare function assignPartial<T>(target: T, partial: Partial<T>): T;
|
|
>assignPartial : <T>(target: T, partial: Partial<T>) => T
|
|
>target : T
|
|
>partial : Partial<T>
|
|
|
|
let obj = {
|
|
>obj : { foo(bar: string): void; }
|
|
>{ foo(bar: string) {}} : { foo(bar: string): void; }
|
|
|
|
foo(bar: string) {}
|
|
>foo : (bar: string) => void
|
|
>bar : string
|
|
}
|
|
|
|
assignPartial(obj, { foo(...args) {} }); // args has type [string]
|
|
>assignPartial(obj, { foo(...args) {} }) : { foo(bar: string): void; }
|
|
>assignPartial : <T>(target: T, partial: Partial<T>) => T
|
|
>obj : { foo(bar: string): void; }
|
|
>{ foo(...args) {} } : { foo(bar: string): void; }
|
|
>foo : (bar: string) => void
|
|
>args : [bar: string]
|
|
|