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