=== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts ===
// Generic call with no parameters
interface NoParams {
    new <T>();
}
var noParams: NoParams;
>noParams : NoParams

new noParams();
>new noParams() : any
>noParams : NoParams

new noParams<string>();
>new noParams<string>() : any
>noParams : NoParams

new noParams<{}>();
>new noParams<{}>() : any
>noParams : NoParams

// Generic call with parameters but none use type parameter type
interface noGenericParams {
    new <T>(n: string);
>n : string
}
var noGenericParams: noGenericParams;
>noGenericParams : noGenericParams

new noGenericParams('');
>new noGenericParams('') : any
>noGenericParams : noGenericParams
>'' : ""

new noGenericParams<number>('');
>new noGenericParams<number>('') : any
>noGenericParams : noGenericParams
>'' : ""

new noGenericParams<{}>('');
>new noGenericParams<{}>('') : any
>noGenericParams : noGenericParams
>'' : ""

// Generic call with multiple type parameters and only one used in parameter type annotation
interface someGenerics1 {
    new <T, U>(n: T, m: number);
>n : T
>m : number
}
var someGenerics1: someGenerics1;
>someGenerics1 : someGenerics1

new someGenerics1(3, 4);
>new someGenerics1(3, 4) : any
>someGenerics1 : someGenerics1
>3 : 3
>4 : 4

new someGenerics1<string, number>(3, 4); // Error
>new someGenerics1<string, number>(3, 4) : any
>someGenerics1 : someGenerics1
>3 : 3
>4 : 4

new someGenerics1<number, {}>(3, 4);
>new someGenerics1<number, {}>(3, 4) : any
>someGenerics1 : someGenerics1
>3 : 3
>4 : 4

// Generic call with argument of function type whose parameter is of type parameter type
interface someGenerics2a {
    new <T>(n: (x: T) => void);
>n : (x: T) => void
>x : T
}
var someGenerics2a: someGenerics2a;
>someGenerics2a : someGenerics2a

new someGenerics2a((n: string) => n);
>new someGenerics2a((n: string) => n) : any
>someGenerics2a : someGenerics2a
>(n: string) => n : (n: string) => string
>n : string
>n : string

new someGenerics2a<string>((n: string) => n);
>new someGenerics2a<string>((n: string) => n) : any
>someGenerics2a : someGenerics2a
>(n: string) => n : (n: string) => string
>n : string
>n : string

new someGenerics2a<string>((n) => n.substr(0));
>new someGenerics2a<string>((n) => n.substr(0)) : any
>someGenerics2a : someGenerics2a
>(n) => n.substr(0) : (n: string) => string
>n : string
>n.substr(0) : string
>n.substr : (from: number, length?: number) => string
>n : string
>substr : (from: number, length?: number) => string
>0 : 0

interface someGenerics2b {
    new <T, U>(n: (x: T, y: U) => void);
>n : (x: T, y: U) => void
>x : T
>y : U
}
var someGenerics2b: someGenerics2b;
>someGenerics2b : someGenerics2b

new someGenerics2b((n: string, x: number) => n);
>new someGenerics2b((n: string, x: number) => n) : any
>someGenerics2b : someGenerics2b
>(n: string, x: number) => n : (n: string, x: number) => string
>n : string
>x : number
>n : string

new someGenerics2b<string, number>((n: string, t: number) => n);
>new someGenerics2b<string, number>((n: string, t: number) => n) : any
>someGenerics2b : someGenerics2b
>(n: string, t: number) => n : (n: string, t: number) => string
>n : string
>t : number
>n : string

new someGenerics2b<string, number>((n, t) => n.substr(t * t));
>new someGenerics2b<string, number>((n, t) => n.substr(t * t)) : any
>someGenerics2b : someGenerics2b
>(n, t) => n.substr(t * t) : (n: string, t: number) => string
>n : string
>t : number
>n.substr(t * t) : string
>n.substr : (from: number, length?: number) => string
>n : string
>substr : (from: number, length?: number) => string
>t * t : number
>t : number
>t : number

// Generic call with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
interface someGenerics3 {
    new <T>(producer: () => T);
>producer : () => T
}
var someGenerics3: someGenerics3;
>someGenerics3 : someGenerics3

new someGenerics3(() => '');
>new someGenerics3(() => '') : any
>someGenerics3 : someGenerics3
>() => '' : () => string
>'' : ""

new someGenerics3<Window>(() => undefined);
>new someGenerics3<Window>(() => undefined) : any
>someGenerics3 : someGenerics3
>() => undefined : () => any
>undefined : undefined

new someGenerics3<number>(() => 3);
>new someGenerics3<number>(() => 3) : any
>someGenerics3 : someGenerics3
>() => 3 : () => number
>3 : 3

// 2 parameter generic call with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
interface someGenerics4 {
    new <T, U>(n: T, f: (x: U) => void);
>n : T
>f : (x: U) => void
>x : U
}
var someGenerics4: someGenerics4;
>someGenerics4 : someGenerics4

new someGenerics4(4, () => null);
>new someGenerics4(4, () => null) : any
>someGenerics4 : someGenerics4
>4 : 4
>() => null : () => any
>null : null

new someGenerics4<string, number>('', () => 3);
>new someGenerics4<string, number>('', () => 3) : any
>someGenerics4 : someGenerics4
>'' : ""
>() => 3 : () => number
>3 : 3

new someGenerics4<string, number>('', (x: string) => ''); // Error
>new someGenerics4<string, number>('', (x: string) => '') : any
>someGenerics4 : someGenerics4
>'' : ""
>(x: string) => '' : (x: string) => string
>x : string
>'' : ""

new someGenerics4<string, number>(null, null);
>new someGenerics4<string, number>(null, null) : any
>someGenerics4 : someGenerics4
>null : null
>null : null

// 2 parameter generic call with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
interface someGenerics5 {
    new <U, T>(n: T, f: (x: U) => void);
>n : T
>f : (x: U) => void
>x : U
}
var someGenerics5: someGenerics5;
>someGenerics5 : someGenerics5

new someGenerics5(4, () => null);
>new someGenerics5(4, () => null) : any
>someGenerics5 : someGenerics5
>4 : 4
>() => null : () => any
>null : null

new someGenerics5<number, string>('', () => 3);
>new someGenerics5<number, string>('', () => 3) : any
>someGenerics5 : someGenerics5
>'' : ""
>() => 3 : () => number
>3 : 3

new someGenerics5<number, string>('', (x: string) => ''); // Error
>new someGenerics5<number, string>('', (x: string) => '') : any
>someGenerics5 : someGenerics5
>'' : ""
>(x: string) => '' : (x: string) => string
>x : string
>'' : ""

new someGenerics5<string, number>(null, null);
>new someGenerics5<string, number>(null, null) : any
>someGenerics5 : someGenerics5
>null : null
>null : null

// Generic call with multiple arguments of function types that each have parameters of the same generic type
interface someGenerics6 {
    new <A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A);
>a : (a: A) => A
>a : A
>b : (b: A) => A
>b : A
>c : (c: A) => A
>c : A
}
var someGenerics6: someGenerics6;
>someGenerics6 : someGenerics6

new someGenerics6(n => n, n => n, n => n);
>new someGenerics6(n => n, n => n, n => n) : any
>someGenerics6 : someGenerics6
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown

new someGenerics6<number>(n => n, n => n, n => n);
>new someGenerics6<number>(n => n, n => n, n => n) : any
>someGenerics6 : someGenerics6
>n => n : (n: number) => number
>n : number
>n : number
>n => n : (n: number) => number
>n : number
>n : number
>n => n : (n: number) => number
>n : number
>n : number

new someGenerics6<number>((n: number) => n, (n: string) => n, (n: number) => n); // Error
>new someGenerics6<number>((n: number) => n, (n: string) => n, (n: number) => n) : any
>someGenerics6 : someGenerics6
>(n: number) => n : (n: number) => number
>n : number
>n : number
>(n: string) => n : (n: string) => string
>n : string
>n : string
>(n: number) => n : (n: number) => number
>n : number
>n : number

new someGenerics6<number>((n: number) => n, (n: number) => n, (n: number) => n);
>new someGenerics6<number>((n: number) => n, (n: number) => n, (n: number) => n) : any
>someGenerics6 : someGenerics6
>(n: number) => n : (n: number) => number
>n : number
>n : number
>(n: number) => n : (n: number) => number
>n : number
>n : number
>(n: number) => n : (n: number) => number
>n : number
>n : number

// Generic call with multiple arguments of function types that each have parameters of different generic type
interface someGenerics7 {
    new <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C);
>a : (a: A) => A
>a : A
>b : (b: B) => B
>b : B
>c : (c: C) => C
>c : C
}
var someGenerics7: someGenerics7;
>someGenerics7 : someGenerics7

new someGenerics7(n => n, n => n, n => n);
>new someGenerics7(n => n, n => n, n => n) : any
>someGenerics7 : someGenerics7
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown
>n => n : (n: unknown) => unknown
>n : unknown
>n : unknown

new someGenerics7<number, string, number>(n => n, n => n, n => n);
>new someGenerics7<number, string, number>(n => n, n => n, n => n) : any
>someGenerics7 : someGenerics7
>n => n : (n: number) => number
>n : number
>n : number
>n => n : (n: string) => string
>n : string
>n : string
>n => n : (n: number) => number
>n : number
>n : number

new someGenerics7<number, string, number>((n: number) => n, (n: string) => n, (n: number) => n);
>new someGenerics7<number, string, number>((n: number) => n, (n: string) => n, (n: number) => n) : any
>someGenerics7 : someGenerics7
>(n: number) => n : (n: number) => number
>n : number
>n : number
>(n: string) => n : (n: string) => string
>n : string
>n : string
>(n: number) => n : (n: number) => number
>n : number
>n : number

// Generic call with argument of generic function type
interface someGenerics8 {
    new <T>(n: T): T;
>n : T
}
var someGenerics8: someGenerics8;
>someGenerics8 : someGenerics8

var x = new someGenerics8(someGenerics7);
>x : someGenerics7
>new someGenerics8(someGenerics7) : someGenerics7
>someGenerics8 : someGenerics8
>someGenerics7 : someGenerics7

new x<string, string, string>(null, null, null);
>new x<string, string, string>(null, null, null) : any
>x : someGenerics7
>null : null
>null : null
>null : null

// Generic call with multiple parameters of generic type passed arguments with no best common type
interface someGenerics9 {
    new <T>(a: T, b: T, c: T): T;
>a : T
>b : T
>c : T
}
var someGenerics9: someGenerics9;
>someGenerics9 : someGenerics9

var a9a = new someGenerics9('', 0, []);
>a9a : string
>new someGenerics9('', 0, []) : ""
>someGenerics9 : someGenerics9
>'' : ""
>0 : 0
>[] : undefined[]

var a9a: {};
>a9a : string

var a9b = new someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null);
>a9b : { a?: number; b?: string; }
>new someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null) : { a?: number; b?: string; }
>someGenerics9 : someGenerics9
>a : number
>b : string
>{ a: 0 } : { a: number; }
>a : number
>0 : 0
>{ b: '' } : { b: string; }
>b : string
>'' : ""
>null : null

var a9b: { a?: number; b?: string; };
>a9b : { a?: number; b?: string; }
>a : number
>b : string

// Generic call with multiple parameters of generic type passed arguments with multiple best common types
interface A91 {
    x: number;
>x : number

    y?: string;
>y : string
}
interface A92 {
    x: number;
>x : number

    z?: Window;
>z : Window
}
var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
>a9e : { x: number; z: Window & typeof globalThis; y?: undefined; } | { x: number; y: string; z?: undefined; }
>new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' }) : { x: number; z: Window & typeof globalThis; y?: undefined; } | { x: number; y: string; z?: undefined; }
>someGenerics9 : someGenerics9
>undefined : undefined
>{ x: 6, z: window } : { x: number; z: Window & typeof globalThis; }
>x : number
>6 : 6
>z : Window & typeof globalThis
>window : Window & typeof globalThis
>{ x: 6, y: '' } : { x: number; y: string; }
>x : number
>6 : 6
>y : string
>'' : ""

var a9e: {};
>a9e : { x: number; z: Window & typeof globalThis; y?: undefined; } | { x: number; y: string; z?: undefined; }

var a9f = new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' });
>a9f : A92
>new someGenerics9<A92>(undefined, { x: 6, z: window }, { x: 6, y: '' }) : A92
>someGenerics9 : someGenerics9
>undefined : undefined
>{ x: 6, z: window } : { x: number; z: Window & typeof globalThis; }
>x : number
>6 : 6
>z : Window & typeof globalThis
>window : Window & typeof globalThis
>{ x: 6, y: '' } : { x: number; y: string; }
>x : number
>6 : 6
>y : string
>'' : ""

var a9f: A92;
>a9f : A92

// Generic call with multiple parameters of generic type passed arguments with a single best common type
var a9d = new someGenerics9({ x: 3 }, { x: 6 }, { x: 6 });
>a9d : { x: number; }
>new someGenerics9({ x: 3 }, { x: 6 }, { x: 6 }) : { x: number; }
>someGenerics9 : someGenerics9
>{ x: 3 } : { x: number; }
>x : number
>3 : 3
>{ x: 6 } : { x: number; }
>x : number
>6 : 6
>{ x: 6 } : { x: number; }
>x : number
>6 : 6

var a9d: { x: number; };
>a9d : { x: number; }
>x : number

// Generic call with multiple parameters of generic type where one argument is of type 'any'
var anyVar: any;
>anyVar : any

var a = new someGenerics9(7, anyVar, 4);
>a : any
>new someGenerics9(7, anyVar, 4) : any
>someGenerics9 : someGenerics9
>7 : 7
>anyVar : any
>4 : 4

var a: any;
>a : any

// Generic call with multiple parameters of generic type where one argument is [] and the other is not 'any'
var arr = new someGenerics9([], null, undefined);
>arr : any[]
>new someGenerics9([], null, undefined) : any[]
>someGenerics9 : someGenerics9
>[] : undefined[]
>null : null
>undefined : undefined

var arr: any[];
>arr : any[]