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/subtypingWithConstructSignatures4.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 <T>(x: T) => T[]); 29declare function foo1(a: any): any; 30 31declare function foo2(a2: new <T>(x: T) => string[]); 32declare function foo2(a: any): any; 33 34declare function foo3(a3: new <T>(x: T) => void); 35declare function foo3(a: any): any; 36 37declare function foo4(a4: new <T, U>(x: T, y: U) => string); 38declare function foo4(a: any): any; 39 40declare function foo5(a5: new <T, U>(x: new (arg: T) => U) => T); 41declare function foo5(a: any): any; 42 43declare function foo6(a6: new <T extends Base>(x: new (arg: T) => Derived) => T); 44declare function foo6(a: any): any; 45 46declare function foo11(a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base); 47declare function foo11(a: any): any; 48 49declare function foo15(a15: new <T>(x: { a: T; b: T }) => T[]); 50declare function foo15(a: any): any; 51 52declare function foo16(a16: new <T extends Base>(x: { a: T; b: T }) => T[]); 53declare function foo16(a: any): any; 54 55declare function foo17(a17: { 56 new <T extends Derived>(x: new (a: T) => T): T[]; 57 new <T extends Base>(x: new (a: T) => T): T[]; 58}); 59declare function foo17(a: any): any; 60 61declare function foo18(a18: { 62 new (x: { 63 new <T extends Derived>(a: T): T; 64 new <T extends Base>(a: T): T; 65 }): any[]; 66 new (x: { 67 new <T extends Derived2>(a: T): T; 68 new <T extends Base>(a: T): T; 69 }): any[]; 70}); 71declare function foo18(a: any): any; 72 73let r1arg: new <T>(x: T) => T[]; 74AssertType(r1arg, "new <T>(T) => T[]"); 75AssertType(x, "T"); 76 77let r1arg2: new <T>(x: T) => T[]; 78AssertType(r1arg2, "new <T>(T) => T[]"); 79AssertType(x, "T"); 80 81let r1 = foo1(r1arg); 82AssertType(r1, "any"); 83AssertType(foo1(r1arg), "any"); 84AssertType(foo1, "{ (new <T>(T) => T[]): any; (any): any; }"); 85AssertType(r1arg, "new <T>(T) => T[]"); 86 87let r1a = [r1arg, r1arg2]; 88AssertType(r1a, "(new <T>(T) => T[])[]"); 89AssertType([r1arg, r1arg2], "(new <T>(T) => T[])[]"); 90AssertType(r1arg, "new <T>(T) => T[]"); 91AssertType(r1arg2, "new <T>(T) => T[]"); 92 93let r1b = [r1arg2, r1arg]; 94AssertType(r1b, "(new <T>(T) => T[])[]"); 95AssertType([r1arg2, r1arg], "(new <T>(T) => T[])[]"); 96AssertType(r1arg2, "new <T>(T) => T[]"); 97AssertType(r1arg, "new <T>(T) => T[]"); 98 99let r2arg: new <T>(x: T) => string[]; 100AssertType(r2arg, "new <T>(T) => string[]"); 101AssertType(x, "T"); 102 103let r2arg2: new <T>(x: T) => string[]; 104AssertType(r2arg2, "new <T>(T) => string[]"); 105AssertType(x, "T"); 106 107let r2 = foo2(r2arg); 108AssertType(r2, "any"); 109AssertType(foo2(r2arg), "any"); 110AssertType(foo2, "{ (new <T>(T) => string[]): any; (any): any; }"); 111AssertType(r2arg, "new <T>(T) => string[]"); 112 113let r2a = [r2arg, r2arg2]; 114AssertType(r2a, "(new <T>(T) => string[])[]"); 115AssertType([r2arg, r2arg2], "(new <T>(T) => string[])[]"); 116AssertType(r2arg, "new <T>(T) => string[]"); 117AssertType(r2arg2, "new <T>(T) => string[]"); 118 119let r2b = [r2arg2, r2arg]; 120AssertType(r2b, "(new <T>(T) => string[])[]"); 121AssertType([r2arg2, r2arg], "(new <T>(T) => string[])[]"); 122AssertType(r2arg2, "new <T>(T) => string[]"); 123AssertType(r2arg, "new <T>(T) => string[]"); 124 125let r3arg: new <T>(x: T) => T; 126AssertType(r3arg, "new <T>(T) => T"); 127AssertType(x, "T"); 128 129let r3arg2: new <T>(x: T) => void; 130AssertType(r3arg2, "new <T>(T) => void"); 131AssertType(x, "T"); 132 133let r3 = foo3(r3arg); 134AssertType(r3, "any"); 135AssertType(foo3(r3arg), "any"); 136AssertType(foo3, "{ (new <T>(T) => void): any; (any): any; }"); 137AssertType(r3arg, "new <T>(T) => T"); 138 139let r3a = [r3arg, r3arg2]; 140AssertType(r3a, "(new <T>(T) => void)[]"); 141AssertType([r3arg, r3arg2], "(new <T>(T) => void)[]"); 142AssertType(r3arg, "new <T>(T) => T"); 143AssertType(r3arg2, "new <T>(T) => void"); 144 145let r3b = [r3arg2, r3arg]; 146AssertType(r3b, "(new <T>(T) => void)[]"); 147AssertType([r3arg2, r3arg], "(new <T>(T) => void)[]"); 148AssertType(r3arg2, "new <T>(T) => void"); 149AssertType(r3arg, "new <T>(T) => T"); 150 151let r4arg: new <T, U>(x: T, y: U) => string; 152AssertType(r4arg, "new <T, U>(T, U) => string"); 153AssertType(x, "T"); 154AssertType(y, "U"); 155 156let r4arg2: new <T, U>(x: T, y: U) => string; 157AssertType(r4arg2, "new <T, U>(T, U) => string"); 158AssertType(x, "T"); 159AssertType(y, "U"); 160 161let r4 = foo4(r4arg); 162AssertType(r4, "any"); 163AssertType(foo4(r4arg), "any"); 164AssertType(foo4, "{ (new <T, U>(T, U) => string): any; (any): any; }"); 165AssertType(r4arg, "new <T, U>(T, U) => string"); 166 167let r4a = [r4arg, r4arg2]; 168AssertType(r4a, "(new <T, U>(T, U) => string)[]"); 169AssertType([r4arg, r4arg2], "(new <T, U>(T, U) => string)[]"); 170AssertType(r4arg, "new <T, U>(T, U) => string"); 171AssertType(r4arg2, "new <T, U>(T, U) => string"); 172 173let r4b = [r4arg2, r4arg]; 174AssertType(r4b, "(new <T, U>(T, U) => string)[]"); 175AssertType([r4arg2, r4arg], "(new <T, U>(T, U) => string)[]"); 176AssertType(r4arg2, "new <T, U>(T, U) => string"); 177AssertType(r4arg, "new <T, U>(T, U) => string"); 178 179let r5arg: new <T, U>(x: new (arg: T) => U) => T; 180AssertType(r5arg, "new <T, U>(new (T) => U) => T"); 181AssertType(x, "new (T) => U"); 182AssertType(arg, "T"); 183 184let r5arg2: new <T, U>(x: new (arg: T) => U) => T; 185AssertType(r5arg2, "new <T, U>(new (T) => U) => T"); 186AssertType(x, "new (T) => U"); 187AssertType(arg, "T"); 188 189let r5 = foo5(r5arg); 190AssertType(r5, "any"); 191AssertType(foo5(r5arg), "any"); 192AssertType(foo5, "{ (new <T, U>(new (T) => U) => T): any; (any): any; }"); 193AssertType(r5arg, "new <T, U>(new (T) => U) => T"); 194 195let r5a = [r5arg, r5arg2]; 196AssertType(r5a, "(new <T, U>(new (T) => U) => T)[]"); 197AssertType([r5arg, r5arg2], "(new <T, U>(new (T) => U) => T)[]"); 198AssertType(r5arg, "new <T, U>(new (T) => U) => T"); 199AssertType(r5arg2, "new <T, U>(new (T) => U) => T"); 200 201let r5b = [r5arg2, r5arg]; 202AssertType(r5b, "(new <T, U>(new (T) => U) => T)[]"); 203AssertType([r5arg2, r5arg], "(new <T, U>(new (T) => U) => T)[]"); 204AssertType(r5arg2, "new <T, U>(new (T) => U) => T"); 205AssertType(r5arg, "new <T, U>(new (T) => U) => T"); 206 207let r6arg: new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T; 208AssertType(r6arg, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 209AssertType(x, "new (T) => U"); 210AssertType(arg, "T"); 211 212let r6arg2: new <T extends Base>(x: new (arg: T) => Derived) => T; 213AssertType(r6arg2, "new <T extends Base>(new (T) => Derived) => T"); 214AssertType(x, "new (T) => Derived"); 215AssertType(arg, "T"); 216 217let r6 = foo6(r6arg); 218AssertType(r6, "any"); 219AssertType(foo6(r6arg), "any"); 220AssertType(foo6, "{ (new <T extends Base>(new (T) => Derived) => T): any; (any): any; }"); 221AssertType(r6arg, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 222 223let r6a = [r6arg, r6arg2]; 224AssertType(r6a, "(new <T extends Base, U extends Derived>(new (T) => U) => T)[]"); 225AssertType([r6arg, r6arg2], "(new <T extends Base, U extends Derived>(new (T) => U) => T)[]"); 226AssertType(r6arg, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 227AssertType(r6arg2, "new <T extends Base>(new (T) => Derived) => T"); 228 229let r6b = [r6arg2, r6arg]; 230AssertType(r6b, "(new <T extends Base, U extends Derived>(new (T) => U) => T)[]"); 231AssertType([r6arg2, r6arg], "(new <T extends Base, U extends Derived>(new (T) => U) => T)[]"); 232AssertType(r6arg2, "new <T extends Base>(new (T) => Derived) => T"); 233AssertType(r6arg, "new <T extends Base, U extends Derived>(new (T) => U) => T"); 234 235let r11arg: new <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base; 236AssertType(r11arg, "new <T, U>({ foo: T; }, { foo: U; bar: U; }) => Base"); 237AssertType(x, "{ foo: T; }"); 238AssertType(foo, "T"); 239AssertType(y, "{ foo: U; bar: U; }"); 240AssertType(foo, "U"); 241AssertType(bar, "U"); 242 243let r11arg2: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base; 244AssertType(r11arg2, "new <T>({ foo: T; }, { foo: T; bar: T; }) => Base"); 245AssertType(x, "{ foo: T; }"); 246AssertType(foo, "T"); 247AssertType(y, "{ foo: T; bar: T; }"); 248AssertType(foo, "T"); 249AssertType(bar, "T"); 250 251let r11 = foo11(r11arg); 252AssertType(r11, "any"); 253AssertType(foo11(r11arg), "any"); 254AssertType(foo11, "{ (new <T>({ foo: T; }, { foo: T; bar: T; }) => Base): any; (any): any; }"); 255AssertType(r11arg, "new <T, U>({ foo: T; }, { foo: U; bar: U; }) => Base"); 256 257let r11a = [r11arg, r11arg2]; 258AssertType(r11a, "(new <T>({ foo: T; }, { foo: T; bar: T; }) => Base)[]"); 259AssertType([r11arg, r11arg2], "(new <T>({ foo: T; }, { foo: T; bar: T; }) => Base)[]"); 260AssertType(r11arg, "new <T, U>({ foo: T; }, { foo: U; bar: U; }) => Base"); 261AssertType(r11arg2, "new <T>({ foo: T; }, { foo: T; bar: T; }) => Base"); 262 263let r11b = [r11arg2, r11arg]; 264AssertType(r11b, "(new <T>({ foo: T; }, { foo: T; bar: T; }) => Base)[]"); 265AssertType([r11arg2, r11arg], "(new <T>({ foo: T; }, { foo: T; bar: T; }) => Base)[]"); 266AssertType(r11arg2, "new <T>({ foo: T; }, { foo: T; bar: T; }) => Base"); 267AssertType(r11arg, "new <T, U>({ foo: T; }, { foo: U; bar: U; }) => Base"); 268 269let r15arg: new <U, V>(x: { a: U; b: V; }) => U[]; 270AssertType(r15arg, "new <U, V>({ a: U; b: V; }) => U[]"); 271AssertType(x, "{ a: U; b: V; }"); 272AssertType(a, "U"); 273AssertType(b, "V"); 274 275let r15arg2: new <T>(x: { a: T; b: T }) => T[]; 276AssertType(r15arg2, "new <T>({ a: T; b: T; }) => T[]"); 277AssertType(x, "{ a: T; b: T; }"); 278AssertType(a, "T"); 279AssertType(b, "T"); 280 281let r15 = foo15(r15arg); 282AssertType(r15, "any"); 283AssertType(foo15(r15arg), "any"); 284AssertType(foo15, "{ (new <T>({ a: T; b: T; }) => T[]): any; (any): any; }"); 285AssertType(r15arg, "new <U, V>({ a: U; b: V; }) => U[]"); 286 287let r15a = [r15arg, r15arg2]; 288AssertType(r15a, "(new <T>({ a: T; b: T; }) => T[])[]"); 289AssertType([r15arg, r15arg2], "(new <T>({ a: T; b: T; }) => T[])[]"); 290AssertType(r15arg, "new <U, V>({ a: U; b: V; }) => U[]"); 291AssertType(r15arg2, "new <T>({ a: T; b: T; }) => T[]"); 292 293let r15b = [r15arg2, r15arg]; 294AssertType(r15b, "(new <T>({ a: T; b: T; }) => T[])[]"); 295AssertType([r15arg2, r15arg], "(new <T>({ a: T; b: T; }) => T[])[]"); 296AssertType(r15arg2, "new <T>({ a: T; b: T; }) => T[]"); 297AssertType(r15arg, "new <U, V>({ a: U; b: V; }) => U[]"); 298 299let r16arg: new <T extends Base>(x: { a: T; b: T }) => T[]; 300AssertType(r16arg, "new <T extends Base>({ a: T; b: T; }) => T[]"); 301AssertType(x, "{ a: T; b: T; }"); 302AssertType(a, "T"); 303AssertType(b, "T"); 304 305let r16arg2: new <T extends Base>(x: { a: T; b: T }) => T[]; 306AssertType(r16arg2, "new <T extends Base>({ a: T; b: T; }) => T[]"); 307AssertType(x, "{ a: T; b: T; }"); 308AssertType(a, "T"); 309AssertType(b, "T"); 310 311let r16 = foo16(r16arg); 312AssertType(r16, "any"); 313AssertType(foo16(r16arg), "any"); 314AssertType(foo16, "{ (new <T extends Base>({ a: T; b: T; }) => T[]): any; (any): any; }"); 315AssertType(r16arg, "new <T extends Base>({ a: T; b: T; }) => T[]"); 316 317let r16a = [r16arg, r16arg2]; 318AssertType(r16a, "(new <T extends Base>({ a: T; b: T; }) => T[])[]"); 319AssertType([r16arg, r16arg2], "(new <T extends Base>({ a: T; b: T; }) => T[])[]"); 320AssertType(r16arg, "new <T extends Base>({ a: T; b: T; }) => T[]"); 321AssertType(r16arg2, "new <T extends Base>({ a: T; b: T; }) => T[]"); 322 323let r16b = [r16arg2, r16arg]; 324AssertType(r16b, "(new <T extends Base>({ a: T; b: T; }) => T[])[]"); 325AssertType([r16arg2, r16arg], "(new <T extends Base>({ a: T; b: T; }) => T[])[]"); 326AssertType(r16arg2, "new <T extends Base>({ a: T; b: T; }) => T[]"); 327AssertType(r16arg, "new <T extends Base>({ a: T; b: T; }) => T[]"); 328 329let r17arg: new <T>(x: new (a: T) => T) => T[]; 330AssertType(r17arg, "new <T>(new (T) => T) => T[]"); 331AssertType(x, "new (T) => T"); 332AssertType(a, "T"); 333 334let r17 = foo17(r17arg); 335AssertType(r17, "any"); 336AssertType(foo17(r17arg), "any"); 337AssertType(foo17, "{ ({ new <T extends Derived>(new (T) => T): T[]; new <T extends Base>(new (T) => T): T[]; }): any; (any): any; }"); 338AssertType(r17arg, "new <T>(new (T) => T) => T[]"); 339 340let r18arg: new (x: new <T>(a: T) => T) => any[]; 341AssertType(r18arg, "new (new <T>(T) => T) => any[]"); 342AssertType(x, "new <T>(T) => T"); 343AssertType(a, "T"); 344 345let r18 = foo18(r18arg); 346AssertType(r18, "any"); 347AssertType(foo18(r18arg), "any"); 348AssertType(foo18, "{ ({ new ({ new <T extends Derived>(T): T; new <T extends Base>(T): T; }): any[]; new ({ new <T extends Derived2>(T): T; new <T extends Base>(T): T; }): any[]; }): any; (any): any; }"); 349AssertType(r18arg, "new (new <T>(T) => T) => any[]"); 350 351 352