1/* 2* Copyright (c) Microsoft Corporation. All rights reserved. 3* Copyright (c) 2023 Huawei Device Co., Ltd. 4* Licensed under the Apache License, Version 2.0 (the "License"); 5* you may not use this file except in compliance with the License. 6* You may obtain a copy of the License at 7* 8* http://www.apache.org/licenses/LICENSE-2.0 9* 10* Unless required by applicable law or agreed to in writing, software 11* distributed under the License is distributed on an "AS IS" BASIS, 12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13* See the License for the specific language governing permissions and 14* limitations under the License. 15* 16* This file has been modified by Huawei to verify type inference by adding verification statements. 17*/ 18 19// === tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithConstructSignatures2.ts === 20declare function AssertType(value:any, type:string):void; 21// checking subtype relations for function types as it relates to contextual signature instantiation 22 23class Base { foo: string; } 24class Derived extends Base { bar: string; } 25class Derived2 extends Derived { baz: string; } 26class OtherDerived extends Base { bing: string; } 27 28declare function foo1(a: new (x: number) => number[]): typeof a; 29declare function foo1(a: any): any; 30 31declare function foo2(a: new (x: number) => string[]): typeof a; 32declare function foo2(a: any): any; 33 34declare function foo3(a: new (x: number) => void): typeof a; 35declare function foo3(a: any): any; 36 37declare function foo4(a: new (x: string, y: number) => string): typeof a; 38declare function foo4(a: any): any; 39 40declare function foo5(a: new (x: new (arg: string) => number) => string): typeof a; 41declare function foo5(a: any): any; 42 43declare function foo6(a: new (x: new (arg: Base) => Derived) => Base): typeof a; 44declare function foo6(a: any): any; 45 46declare function foo7(a: new (x: new (arg: Base) => Derived) => new (r: Base) => Derived): typeof a; 47declare function foo7(a: any): any; 48 49declare function foo8(a: new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived): typeof a; 50declare function foo8(a: any): any; 51 52declare function foo9(a: new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived): typeof a; 53declare function foo9(a: any): any; 54 55declare function foo10(a: new (...x: Derived[]) => Derived): typeof a; 56declare function foo10(a: any): any; 57 58declare function foo11(a: new (x: { foo: string }, y: { foo: string; bar: string }) => Base): typeof a; 59declare function foo11(a: any): any; 60 61declare function foo12(a: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>): typeof a; 62declare function foo12(a: any): any; 63 64declare function foo13(a: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>): typeof a; 65declare function foo13(a: any): any; 66 67declare function foo14(a: new (x: { a: string; b: number }) => Object): typeof a; 68declare function foo14(a: any): any; 69 70declare function foo15(a: { 71 new (x: number): number[]; 72 new (x: string): string[]; 73}): typeof a; 74declare function foo15(a: any): any; 75 76declare function foo16(a: { 77 new <T extends Derived>(x: T): number[]; 78 new <U extends Base>(x: U): number[]; 79}): typeof a; 80declare function foo16(a: any): any; 81 82declare function foo17(a: { 83 new (x: (a: number) => number): number[]; 84 new (x: (a: string) => string): string[]; 85}): typeof a; 86declare function foo17(a: any): any; 87 88declare function foo18(a: { 89 new (x: { 90 new (a: number): number; 91 new (a: string): string; 92 }): any[]; 93 new (x: { 94 new (a: boolean): boolean; 95 new (a: Date): Date; 96 }): any[]; 97}): typeof a; 98declare function foo18(a: any): any; 99 100let r1arg1: new <T>(x: T) => T[]; 101AssertType(r1arg1, "new <T>(T) => T[]"); 102AssertType(x, "T"); 103 104let r1arg2: new (x: number) => number[]; 105AssertType(r1arg2, "new (number) => number[]"); 106AssertType(x, "number"); 107 108let r1 = foo1(r1arg1); // any, 109AssertType(r1, "new (number) => number[]"); 110AssertType(foo1(r1arg1), "new (number) => number[]"); 111AssertType(foo1, "{ (new (number) => number[]): new (number) => number[]; (any): any; }"); 112AssertType(r1arg1, "new <T>(T) => T[]"); 113return types are not subtype of first overload 114 115let r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions 116AssertType(r1a, "(new (number) => number[])[]"); 117AssertType([r1arg2, r1arg1], "(new (number) => number[])[]"); 118AssertType(r1arg2, "new (number) => number[]"); 119AssertType(r1arg1, "new <T>(T) => T[]"); 120 121let r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions 122AssertType(r1b, "(new (number) => number[])[]"); 123AssertType([r1arg1, r1arg2], "(new (number) => number[])[]"); 124AssertType(r1arg1, "new <T>(T) => T[]"); 125AssertType(r1arg2, "new (number) => number[]"); 126 127let r2arg1: new <T>(x: T) => string[]; 128AssertType(r2arg1, "new <T>(T) => string[]"); 129AssertType(x, "T"); 130 131let r2arg2: new (x: number) => string[]; 132AssertType(r2arg2, "new (number) => string[]"); 133AssertType(x, "number"); 134 135let r2 = foo2(r2arg1); 136AssertType(r2, "new (number) => string[]"); 137AssertType(foo2(r2arg1), "new (number) => string[]"); 138AssertType(foo2, "{ (new (number) => string[]): new (number) => string[]; (any): any; }"); 139AssertType(r2arg1, "new <T>(T) => string[]"); 140 141let r2a = [r2arg1, r2arg2]; 142AssertType(r2a, "(new (number) => string[])[]"); 143AssertType([r2arg1, r2arg2], "(new (number) => string[])[]"); 144AssertType(r2arg1, "new <T>(T) => string[]"); 145AssertType(r2arg2, "new (number) => string[]"); 146 147let r2b = [r2arg2, r2arg1]; 148AssertType(r2b, "(new (number) => string[])[]"); 149AssertType([r2arg2, r2arg1], "(new (number) => string[])[]"); 150AssertType(r2arg2, "new (number) => string[]"); 151AssertType(r2arg1, "new <T>(T) => string[]"); 152 153let r3arg1: new <T>(x: T) => T; 154AssertType(r3arg1, "new <T>(T) => T"); 155AssertType(x, "T"); 156 157let r3arg2: new (x: number) => void; 158AssertType(r3arg2, "new (number) => void"); 159AssertType(x, "number"); 160 161let r3 = foo3(r3arg1); 162AssertType(r3, "new (number) => void"); 163AssertType(foo3(r3arg1), "new (number) => void"); 164AssertType(foo3, "{ (new (number) => void): new (number) => void; (any): any; }"); 165AssertType(r3arg1, "new <T>(T) => T"); 166 167let r3a = [r3arg1, r3arg2]; 168AssertType(r3a, "(new (number) => void)[]"); 169AssertType([r3arg1, r3arg2], "(new (number) => void)[]"); 170AssertType(r3arg1, "new <T>(T) => T"); 171AssertType(r3arg2, "new (number) => void"); 172 173let r3b = [r3arg2, r3arg1]; 174AssertType(r3b, "(new (number) => void)[]"); 175AssertType([r3arg2, r3arg1], "(new (number) => void)[]"); 176AssertType(r3arg2, "new (number) => void"); 177AssertType(r3arg1, "new <T>(T) => T"); 178 179let r4arg1: new <T, U>(x: T, y: U) => T; 180AssertType(r4arg1, "new <T, U>(T, U) => T"); 181AssertType(x, "T"); 182AssertType(y, "U"); 183 184let r4arg2: new (x: string, y: number) => string; 185AssertType(r4arg2, "new (string, number) => string"); 186AssertType(x, "string"); 187AssertType(y, "number"); 188 189let r4 = foo4(r4arg1); // any 190AssertType(r4, "new (string, number) => string"); 191AssertType(foo4(r4arg1), "new (string, number) => string"); 192AssertType(foo4, "{ (new (string, number) => string): new (string, number) => string; (any): any; }"); 193AssertType(r4arg1, "new <T, U>(T, U) => T"); 194 195let r4a = [r4arg1, r4arg2]; 196AssertType(r4a, "(new (string, number) => string)[]"); 197AssertType([r4arg1, r4arg2], "(new (string, number) => string)[]"); 198AssertType(r4arg1, "new <T, U>(T, U) => T"); 199AssertType(r4arg2, "new (string, number) => string"); 200 201let r4b = [r4arg2, r4arg1]; 202AssertType(r4b, "(new (string, number) => string)[]"); 203AssertType([r4arg2, r4arg1], "(new (string, number) => string)[]"); 204AssertType(r4arg2, "new (string, number) => string"); 205AssertType(r4arg1, "new <T, U>(T, U) => T"); 206 207let r5arg1: new <T, U>(x: new (arg: T) => U) => T; 208AssertType(r5arg1, "new <T, U>(new (T) => U) => T"); 209AssertType(x, "new (T) => U"); 210AssertType(arg, "T"); 211 212let r5arg2: new (x: new (arg: string) => number) => string; 213AssertType(r5arg2, "new (new (string) => number) => string"); 214AssertType(x, "new (string) => number"); 215AssertType(arg, "string"); 216 217let r5 = foo5(r5arg1); // any 218AssertType(r5, "new (new (string) => number) => string"); 219AssertType(foo5(r5arg1), "new (new (string) => number) => string"); 220AssertType(foo5, "{ (new (new (string) => number) => string): new (new (string) => number) => string; (any): any; }"); 221AssertType(r5arg1, "new <T, U>(new (T) => U) => T"); 222 223let r5a = [r5arg1, r5arg2]; 224AssertType(r5a, "(new (new (string) => number) => string)[]"); 225AssertType([r5arg1, r5arg2], "(new (new (string) => number) => string)[]"); 226AssertType(r5arg1, "new <T, U>(new (T) => U) => T"); 227AssertType(r5arg2, "new (new (string) => number) => string"); 228 229let r5b = [r5arg2, r5arg1]; 230AssertType(r5b, "(new (new (string) => number) => string)[]"); 231AssertType([r5arg2, r5arg1], "(new (new (string) => number) => string)[]"); 232AssertType(r5arg2, "new (new (string) => number) => string"); 233AssertType(r5arg1, "new <T, U>(new (T) => U) => T"); 234 235let r6arg1: new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T; 236AssertType(r6arg1, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 237AssertType(x, "new (T) => U"); 238AssertType(arg, "T"); 239 240let r6arg2: new (x: new (arg: Base) => Derived) => Base; 241AssertType(r6arg2, "new (new (Base) => Derived) => Base"); 242AssertType(x, "new (Base) => Derived"); 243AssertType(arg, "Base"); 244 245let r6 = foo6(r6arg1); // any 246AssertType(r6, "new (new (Base) => Derived) => Base"); 247AssertType(foo6(r6arg1), "new (new (Base) => Derived) => Base"); 248AssertType(foo6, "{ (new (new (Base) => Derived) => Base): new (new (Base) => Derived) => Base; (any): any; }"); 249AssertType(r6arg1, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 250 251let r6a = [r6arg1, r6arg2]; 252AssertType(r6a, "(new (new (Base) => Derived) => Base)[]"); 253AssertType([r6arg1, r6arg2], "(new (new (Base) => Derived) => Base)[]"); 254AssertType(r6arg1, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 255AssertType(r6arg2, "new (new (Base) => Derived) => Base"); 256 257let r6b = [r6arg2, r6arg1]; 258AssertType(r6b, "(new (new (Base) => Derived) => Base)[]"); 259AssertType([r6arg2, r6arg1], "(new (new (Base) => Derived) => Base)[]"); 260AssertType(r6arg2, "new (new (Base) => Derived) => Base"); 261AssertType(r6arg1, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 262 263let r7arg1: new <T extends Base, U extends Derived>(x: new (arg: T) => U) => new (r: T) => U; 264AssertType(r7arg1, "new <T extends Base, U extends Derived>(new (T) => U) => new (T) => U"); 265AssertType(x, "new (T) => U"); 266AssertType(arg, "T"); 267AssertType(r, "T"); 268 269let r7arg2: new (x: new (arg: Base) => Derived) => new (r: Base) => Derived; 270AssertType(r7arg2, "new (new (Base) => Derived) => new (Base) => Derived"); 271AssertType(x, "new (Base) => Derived"); 272AssertType(arg, "Base"); 273AssertType(r, "Base"); 274 275let r7 = foo7(r7arg1); // any 276AssertType(r7, "new (new (Base) => Derived) => new (Base) => Derived"); 277AssertType(foo7(r7arg1), "new (new (Base) => Derived) => new (Base) => Derived"); 278AssertType(foo7, "{ (new (new (Base) => Derived) => new (Base) => Derived): new (new (Base) => Derived) => new (Base) => Derived; (any): any; }"); 279AssertType(r7arg1, "new <T extends Base, U extends Derived>(new (T) => U) => new (T) => U"); 280 281let r7a = [r7arg1, r7arg2]; 282AssertType(r7a, "(new (new (Base) => Derived) => new (Base) => Derived)[]"); 283AssertType([r7arg1, r7arg2], "(new (new (Base) => Derived) => new (Base) => Derived)[]"); 284AssertType(r7arg1, "new <T extends Base, U extends Derived>(new (T) => U) => new (T) => U"); 285AssertType(r7arg2, "new (new (Base) => Derived) => new (Base) => Derived"); 286 287let r7b = [r7arg2, r7arg1]; 288AssertType(r7b, "(new (new (Base) => Derived) => new (Base) => Derived)[]"); 289AssertType([r7arg2, r7arg1], "(new (new (Base) => Derived) => new (Base) => Derived)[]"); 290AssertType(r7arg2, "new (new (Base) => Derived) => new (Base) => Derived"); 291AssertType(r7arg1, "new <T extends Base, U extends Derived>(new (T) => U) => new (T) => U"); 292 293let r8arg1: new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: new (arg2: T) => U) => new (r: T) => U; 294AssertType(r8arg1, "new <T extends Base, U extends Derived>(new (T) => U, new (T) => U) => new (T) => U"); 295AssertType(x, "new (T) => U"); 296AssertType(arg, "T"); 297AssertType(y, "new (T) => U"); 298AssertType(arg2, "T"); 299AssertType(r, "T"); 300 301let r8arg2: new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived; 302AssertType(r8arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 303AssertType(x, "new (Base) => Derived"); 304AssertType(arg, "Base"); 305AssertType(y, "new (Base) => Derived"); 306AssertType(arg2, "Base"); 307AssertType(r, "Base"); 308 309let r8 = foo8(r8arg1); // any 310AssertType(r8, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 311AssertType(foo8(r8arg1), "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 312AssertType(foo8, "{ (new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived): new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived; (any): any; }"); 313AssertType(r8arg1, "new <T extends Base, U extends Derived>(new (T) => U, new (T) => U) => new (T) => U"); 314 315let r8a = [r8arg1, r8arg2]; 316AssertType(r8a, "(new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived)[]"); 317AssertType([r8arg1, r8arg2], "(new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived)[]"); 318AssertType(r8arg1, "new <T extends Base, U extends Derived>(new (T) => U, new (T) => U) => new (T) => U"); 319AssertType(r8arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 320 321let r8b = [r8arg2, r8arg1]; 322AssertType(r8b, "(new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived)[]"); 323AssertType([r8arg2, r8arg1], "(new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived)[]"); 324AssertType(r8arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 325AssertType(r8arg1, "new <T extends Base, U extends Derived>(new (T) => U, new (T) => U) => new (T) => U"); 326 327let r9arg1: new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => new (r: T) => U; 328AssertType(r9arg1, "new <T extends Base, U extends Derived>(new (T) => U, ({ foo: string; bing: number;}) => U) => new (T) => U"); 329AssertType(x, "new (T) => U"); 330AssertType(arg, "T"); 331AssertType(y, "({ foo: string; bing: number;}) => U"); 332AssertType(arg2, "{ foo: string; bing: number; }"); 333AssertType(foo, "string"); 334AssertType(bing, "number"); 335AssertType(r, "T"); 336 337let r9arg2: new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived; 338AssertType(r9arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 339AssertType(x, "new (Base) => Derived"); 340AssertType(arg, "Base"); 341AssertType(y, "new (Base) => Derived"); 342AssertType(arg2, "Base"); 343AssertType(r, "Base"); 344 345let r9 = foo9(r9arg1); // any 346AssertType(r9, "any"); 347AssertType(foo9(r9arg1), "any"); 348AssertType(foo9, "{ (new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived): new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived; (any): any; }"); 349AssertType(r9arg1, "new <T extends Base, U extends Derived>(new (T) => U, ({ foo: string; bing: number; }) => U) => new (T) => U"); 350 351let r9a = [r9arg1, r9arg2]; 352AssertType(r9a, "(union)[]"); 353AssertType([r9arg1, r9arg2], "(union)[]"); 354AssertType(r9arg1, "new <T extends Base, U extends Derived>(new (T) => U, ({ foo: string; bing: number; }) => U) => new (T) => U"); 355AssertType(r9arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 356 357let r9b = [r9arg2, r9arg1]; 358AssertType(r9b, "(union)[]"); 359AssertType([r9arg2, r9arg1], "(union)[]"); 360AssertType(r9arg2, "new (new (Base) => Derived, new (Base) => Derived) => new (Base) => Derived"); 361AssertType(r9arg1, "new <T extends Base, U extends Derived>(new (T) => U, ({ foo: string; bing: number; }) => U) => new (T) => U"); 362 363let r10arg1: new <T extends Derived>(...x: T[]) => T; 364AssertType(r10arg1, "new <T extends Derived>(...T[]) => T"); 365AssertType(x, "T[]"); 366 367let r10arg2: new (...x: Derived[]) => Derived; 368AssertType(r10arg2, "new (...Derived[]) => Derived"); 369AssertType(x, "Derived[]"); 370 371let r10 = foo10(r10arg1); // any 372AssertType(r10, "new (...Derived[]) => Derived"); 373AssertType(foo10(r10arg1), "new (...Derived[]) => Derived"); 374AssertType(foo10, "{ (new (...Derived[]) => Derived): new (...Derived[]) => Derived; (any): any; }"); 375AssertType(r10arg1, "new <T extends Derived>(...T[]) => T"); 376 377let r10a = [r10arg1, r10arg2]; 378AssertType(r10a, "(new (...Derived[]) => Derived)[]"); 379AssertType([r10arg1, r10arg2], "(new (...Derived[]) => Derived)[]"); 380AssertType(r10arg1, "new <T extends Derived>(...T[]) => T"); 381AssertType(r10arg2, "new (...Derived[]) => Derived"); 382 383let r10b = [r10arg2, r10arg1]; 384AssertType(r10b, "(new (...Derived[]) => Derived)[]"); 385AssertType([r10arg2, r10arg1], "(new (...Derived[]) => Derived)[]"); 386AssertType(r10arg2, "new (...Derived[]) => Derived"); 387AssertType(r10arg1, "new <T extends Derived>(...T[]) => T"); 388 389let r11arg1: new <T extends Base>(x: T, y: T) => T; 390AssertType(r11arg1, "new <T extends Base>(T, T) => T"); 391AssertType(x, "T"); 392AssertType(y, "T"); 393 394let r11arg2: new (x: { foo: string }, y: { foo: string; bar: string }) => Base; 395AssertType(r11arg2, "new ({ foo: string;}, { foo: string; bar: string;}) => Base"); 396AssertType(x, "{ foo: string; }"); 397AssertType(foo, "string"); 398AssertType(y, "{ foo: string; bar: string; }"); 399AssertType(foo, "string"); 400AssertType(bar, "string"); 401 402let r11 = foo11(r11arg1); // any 403AssertType(r11, "new ({ foo: string; }, { foo: string; bar: string; }) => Base"); 404AssertType(foo11(r11arg1), "new ({ foo: string; }, { foo: string; bar: string; }) => Base"); 405AssertType(foo11, "{ (new ({ foo: string; }, { foo: string; bar: string; }) => Base): new ({ foo: string; }, { foo: string; bar: string; }) => Base; (any): any; }"); 406AssertType(r11arg1, "new <T extends Base>(T, T) => T"); 407 408let r11a = [r11arg1, r11arg2]; 409AssertType(r11a, "(new ({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 410AssertType([r11arg1, r11arg2], "(new ({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 411AssertType(r11arg1, "new <T extends Base>(T, T) => T"); 412AssertType(r11arg2, "new ({ foo: string; }, { foo: string; bar: string; }) => Base"); 413 414let r11b = [r11arg2, r11arg1]; 415AssertType(r11b, "(new ({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 416AssertType([r11arg2, r11arg1], "(new ({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 417AssertType(r11arg2, "new ({ foo: string; }, { foo: string; bar: string; }) => Base"); 418AssertType(r11arg1, "new <T extends Base>(T, T) => T"); 419 420let r12arg1: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 421AssertType(r12arg1, "new <T extends Base[]>(Array<Base>, T) => Array<Derived>"); 422AssertType(x, "Base[]"); 423AssertType(y, "T"); 424 425let r12arg2: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>; 426AssertType(r12arg2, "new (Array<Base>, Array<Derived2>) => Array<Derived>"); 427AssertType(x, "Base[]"); 428AssertType(y, "Derived2[]"); 429 430let r12 = foo12(r12arg1); // any 431AssertType(r12, "new (Base[], Derived2[]) => Derived[]"); 432AssertType(foo12(r12arg1), "new (Base[], Derived2[]) => Derived[]"); 433AssertType(foo12, "{ (new (Base[], Derived2[]) => Derived[]): new (Base[], Derived2[]) => Derived[]; (any): any; }"); 434AssertType(r12arg1, "new <T extends Base[]>(Base[], T) => Derived[]"); 435 436let r12a = [r12arg1, r12arg2]; 437AssertType(r12a, "(new (Base[], Derived2[]) => Derived[])[]"); 438AssertType([r12arg1, r12arg2], "(new (Base[], Derived2[]) => Derived[])[]"); 439AssertType(r12arg1, "new <T extends Base[]>(Base[], T) => Derived[]"); 440AssertType(r12arg2, "new (Base[], Derived2[]) => Derived[]"); 441 442let r12b = [r12arg2, r12arg1]; 443AssertType(r12b, "(new (Base[], Derived2[]) => Derived[])[]"); 444AssertType([r12arg2, r12arg1], "(new (Base[], Derived2[]) => Derived[])[]"); 445AssertType(r12arg2, "new (Base[], Derived2[]) => Derived[]"); 446AssertType(r12arg1, "new <T extends Base[]>(Base[], T) => Derived[]"); 447 448let r13arg1: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 449AssertType(r13arg1, "new <T extends Derived[]>(Array<Base>, T) => T"); 450AssertType(x, "Base[]"); 451AssertType(y, "T"); 452 453let r13arg2: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>; 454AssertType(r13arg2, "new (Array<Base>, Array<Derived>) => Array<Derived>"); 455AssertType(x, "Base[]"); 456AssertType(y, "Derived[]"); 457 458let r13 = foo13(r13arg1); // any 459AssertType(r13, "new (Base[], Derived[]) => Derived[]"); 460AssertType(foo13(r13arg1), "new (Base[], Derived[]) => Derived[]"); 461AssertType(foo13, "{ (new (Base[], Derived[]) => Derived[]): new (Base[], Derived[]) => Derived[]; (any): any; }"); 462AssertType(r13arg1, "new <T extends Derived[]>(Base[], T) => T"); 463 464let r13a = [r13arg1, r13arg2]; 465AssertType(r13a, "(new (Base[], Derived[]) => Derived[])[]"); 466AssertType([r13arg1, r13arg2], "(new (Base[], Derived[]) => Derived[])[]"); 467AssertType(r13arg1, "new <T extends Derived[]>(Base[], T) => T"); 468AssertType(r13arg2, "new (Base[], Derived[]) => Derived[]"); 469 470let r13b = [r13arg2, r13arg1]; 471AssertType(r13b, "(new (Base[], Derived[]) => Derived[])[]"); 472AssertType([r13arg2, r13arg1], "(new (Base[], Derived[]) => Derived[])[]"); 473AssertType(r13arg2, "new (Base[], Derived[]) => Derived[]"); 474AssertType(r13arg1, "new <T extends Derived[]>(Base[], T) => T"); 475 476let r14arg1: new <T>(x: { a: T; b: T }) => T; 477AssertType(r14arg1, "new <T>({ a: T; b: T; }) => T"); 478AssertType(x, "{ a: T; b: T; }"); 479AssertType(a, "T"); 480AssertType(b, "T"); 481 482let r14arg2: new (x: { a: string; b: number }) => Object; 483AssertType(r14arg2, "new ({ a: string; b: number;}) => Object"); 484AssertType(x, "{ a: string; b: number; }"); 485AssertType(a, "string"); 486AssertType(b, "number"); 487 488let r14 = foo14(r14arg1); // any 489AssertType(r14, "any"); 490AssertType(foo14(r14arg1), "any"); 491AssertType(foo14, "{ (new ({ a: string; b: number; }) => Object): new ({ a: string; b: number; }) => Object; (any): any; }"); 492AssertType(r14arg1, "new <T>({ a: T; b: T; }) => T"); 493 494let r14a = [r14arg1, r14arg2]; 495AssertType(r14a, "(union)[]"); 496AssertType([r14arg1, r14arg2], "(union)[]"); 497AssertType(r14arg1, "new <T>({ a: T; b: T; }) => T"); 498AssertType(r14arg2, "new ({ a: string; b: number; }) => Object"); 499 500let r14b = [r14arg2, r14arg1]; 501AssertType(r14b, "(union)[]"); 502AssertType([r14arg2, r14arg1], "(union)[]"); 503AssertType(r14arg2, "new ({ a: string; b: number; }) => Object"); 504AssertType(r14arg1, "new <T>({ a: T; b: T; }) => T"); 505 506let r15arg1: new <T>(x: T) => T[]; 507AssertType(r15arg1, "new <T>(T) => T[]"); 508AssertType(x, "T"); 509 510let r15 = foo15(r15arg1); // any 511AssertType(r15, "any"); 512AssertType(foo15(r15arg1), "any"); 513AssertType(foo15, "{ ({ new (number): number[]; new (string): string[]; }): { new (number): number[]; new (string): string[]; }; (any): any; }"); 514AssertType(r15arg1, "new <T>(T) => T[]"); 515 516let r16arg1: new <T extends Base>(x: T) => number[]; 517AssertType(r16arg1, "new <T extends Base>(T) => number[]"); 518AssertType(x, "T"); 519 520let r16 = foo16(r16arg1); 521AssertType(r16, "{ new <T extends Derived>(T): number[]; new <U extends Base>(U): number[]; }"); 522AssertType(foo16(r16arg1), "{ new <T extends Derived>(T): number[]; new <U extends Base>(U): number[]; }"); 523AssertType(foo16, "{ ({ new <T extends Derived>(T): number[]; new <U extends Base>(U): number[]; }): { new <T extends Derived>(T): number[]; new <U extends Base>(U): number[]; }; (any): any; }"); 524AssertType(r16arg1, "new <T extends Base>(T) => number[]"); 525 526let r17arg1: new <T>(x: (a: T) => T) => T[]; 527AssertType(r17arg1, "new <T>((T) => T) => T[]"); 528AssertType(x, "(T) => T"); 529AssertType(a, "T"); 530 531let r17 = foo17(r17arg1); // any 532AssertType(r17, "any"); 533AssertType(foo17(r17arg1), "any"); 534AssertType(foo17, "{ ({ new ((number) => number): number[]; new ((string) => string): string[]; }): { new ((number) => number): number[]; new ((string) => string): string[]; }; (any): any; }"); 535AssertType(r17arg1, "new <T>((T) => T) => T[]"); 536 537let r18arg1: new <T>(x: (a: T) => T) => T[]; 538AssertType(r18arg1, "new <T>((T) => T) => T[]"); 539AssertType(x, "(T) => T"); 540AssertType(a, "T"); 541 542let r18 = foo18(r18arg1); 543AssertType(r18, "any"); 544AssertType(foo18(r18arg1), "any"); 545AssertType(foo18, "{ ({ new ({ new (number): number; new (string): string; }): any[]; new ({ new (boolean): boolean; new (Date): Date; }): any[]; }): { new ({ new (number): number; new (string): string; }): any[]; new ({ new (boolean): boolean; new (Date): Date; }): any[]; }; (any): any; }"); 546AssertType(r18arg1, "new <T>((T) => T) => T[]"); 547 548 549