strictFunctionTypes1.types

=== tests/cases/compiler/strictFunctionTypes1.ts ===
declare function f1<T>(f1: (x: T) => void, f2: (x: T) => void): (x: T) => void;
>f1 : <T>(f1: (x: T) => void, f2: (x: T) => void) => (x: T) => void
>f1 : (x: T) => void
>x : T
>f2 : (x: T) => void
>x : T
>x : T

declare function f2<T>(obj: T, f1: (x: T) => void, f2: (x: T) => void): T;
>f2 : <T>(obj: T, f1: (x: T) => void, f2: (x: T) => void) => T
>obj : T
>f1 : (x: T) => void
>x : T
>f2 : (x: T) => void
>x : T

declare function f3<T>(obj: T, f1: (x: T) => void, f2: (f: (x: T) => void) => void): T;
>f3 : <T>(obj: T, f1: (x: T) => void, f2: (f: (x: T) => void) => void) => T
>obj : T
>f1 : (x: T) => void
>x : T
>f2 : (f: (x: T) => void) => void
>f : (x: T) => void
>x : T

interface Func<T> { (x: T): void }
>x : T

declare function f4<T>(f1: Func<T>, f2: Func<T>): Func<T>;
>f4 : <T>(f1: Func<T>, f2: Func<T>) => Func<T>
>f1 : Func<T>
>f2 : Func<T>

declare function fo(x: Object): void;
>fo : (x: Object) => void
>x : Object

declare function fs(x: string): void;
>fs : (x: string) => void
>x : string

declare function fx(f: (x: "def") => void): void;
>fx : (f: (x: "def") => void) => void
>f : (x: "def") => void
>x : "def"

const x1 = f1(fo, fs);  // (x: string) => void
>x1 : (x: string) => void
>f1(fo, fs) : (x: string) => void
>f1 : <T>(f1: (x: T) => void, f2: (x: T) => void) => (x: T) => void
>fo : (x: Object) => void
>fs : (x: string) => void

const x2 = f2("abc", fo, fs);  // "abc"
>x2 : "abc"
>f2("abc", fo, fs) : "abc"
>f2 : <T>(obj: T, f1: (x: T) => void, f2: (x: T) => void) => T
>"abc" : "abc"
>fo : (x: Object) => void
>fs : (x: string) => void

const x3 = f3("abc", fo, fx);  // "abc" | "def"
>x3 : "def" | "abc"
>f3("abc", fo, fx) : "def" | "abc"
>f3 : <T>(obj: T, f1: (x: T) => void, f2: (f: (x: T) => void) => void) => T
>"abc" : "abc"
>fo : (x: Object) => void
>fx : (f: (x: "def") => void) => void

const x4 = f4(fo, fs);  // Func<string>
>x4 : Func<string>
>f4(fo, fs) : Func<string>
>f4 : <T>(f1: Func<T>, f2: Func<T>) => Func<T>
>fo : (x: Object) => void
>fs : (x: string) => void

declare const never: never;
>never : never

const x10 = f2(never, fo, fs);  // string
>x10 : string
>f2(never, fo, fs) : string
>f2 : <T>(obj: T, f1: (x: T) => void, f2: (x: T) => void) => T
>never : never
>fo : (x: Object) => void
>fs : (x: string) => void

const x11 = f3(never, fo, fx);  // "def"
>x11 : "def"
>f3(never, fo, fx) : "def"
>f3 : <T>(obj: T, f1: (x: T) => void, f2: (f: (x: T) => void) => void) => T
>never : never
>fo : (x: Object) => void
>fx : (f: (x: "def") => void) => void

// Repro from #21112

declare function foo<T>(a: ReadonlyArray<T>): T;
>foo : <T>(a: ReadonlyArray<T>) => T
>a : ReadonlyArray<T>

let x = foo([]);  // never
>x : never
>foo([]) : never
>foo : <T>(a: ReadonlyArray<T>) => T
>[] : never[]

// Modified repros from #26127

interface A { a: string }
>a : string

interface B extends A { b: string }
>b : string

declare function acceptUnion(x: A | number): void;
>acceptUnion : (x: number | A) => void
>x : number | A

declare function acceptA(x: A): void;
>acceptA : (x: A) => void
>x : A

declare let a: A;
>a : A

declare let b: B;
>b : B

declare function coAndContra<T>(value: T, func: (t: T) => void): T;
>coAndContra : <T>(value: T, func: (t: T) => void) => T
>value : T
>func : (t: T) => void
>t : T

const t1: A = coAndContra(a, acceptUnion);
>t1 : A
>coAndContra(a, acceptUnion) : A
>coAndContra : <T>(value: T, func: (t: T) => void) => T
>a : A
>acceptUnion : (x: number | A) => void

const t2: B = coAndContra(b, acceptA);
>t2 : B
>coAndContra(b, acceptA) : B
>coAndContra : <T>(value: T, func: (t: T) => void) => T
>b : B
>acceptA : (x: A) => void

const t3: A = coAndContra(never, acceptA);
>t3 : A
>coAndContra(never, acceptA) : A
>coAndContra : <T>(value: T, func: (t: T) => void) => T
>never : never
>acceptA : (x: A) => void

declare function coAndContraArray<T>(value: T[], func: (t: T) => void): T[];
>coAndContraArray : <T>(value: T[], func: (t: T) => void) => T[]
>value : T[]
>func : (t: T) => void
>t : T

const t4: A[] = coAndContraArray([a], acceptUnion);
>t4 : A[]
>coAndContraArray([a], acceptUnion) : A[]
>coAndContraArray : <T>(value: T[], func: (t: T) => void) => T[]
>[a] : A[]
>a : A
>acceptUnion : (x: number | A) => void

const t5: B[] = coAndContraArray([b], acceptA);
>t5 : B[]
>coAndContraArray([b], acceptA) : B[]
>coAndContraArray : <T>(value: T[], func: (t: T) => void) => T[]
>[b] : B[]
>b : B
>acceptA : (x: A) => void

const t6: A[] = coAndContraArray([], acceptA);
>t6 : A[]
>coAndContraArray([], acceptA) : A[]
>coAndContraArray : <T>(value: T[], func: (t: T) => void) => T[]
>[] : never[]
>acceptA : (x: A) => void