instantiateContextualTypes.types

=== 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 "a" | "b">(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 "a" | "b">(x: P, callback: R[P]) => void
>x : O
>on : <P extends "a" | "b">(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<DooDad>
>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 : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>Promise : PromiseConstructor
>resolve : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>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<DooDad>
>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 : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>Promise : PromiseConstructor
>resolve : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>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<DooDad>
>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 : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>Promise : PromiseConstructor
>resolve : { <T>(value: T): Promise<T extends PromiseLike<infer U> ? U : T>; (): Promise<void>; }
>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 : [string]