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/subtypingWithCallSignatures2.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: (x: number) => number[]): typeof a; 29declare function foo1(a: any): any; 30 31declare function foo2(a: (x: number) => string[]): typeof a; 32declare function foo2(a: any): any; 33 34declare function foo3(a: (x: number) => void): typeof a; 35declare function foo3(a: any): any; 36 37declare function foo4(a: (x: string, y: number) => string): typeof a; 38declare function foo4(a: any): any; 39 40declare function foo5(a: (x: (arg: string) => number) => string): typeof a; 41declare function foo5(a: any): any; 42 43declare function foo6(a: (x: (arg: Base) => Derived) => Base): typeof a; 44declare function foo6(a: any): any; 45 46declare function foo7(a: (x: (arg: Base) => Derived) => (r: Base) => Derived): typeof a; 47declare function foo7(a: any): any; 48 49declare function foo8(a: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived): typeof a; 50declare function foo8(a: any): any; 51 52declare function foo9(a: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived): typeof a; 53declare function foo9(a: any): any; 54 55declare function foo10(a: (...x: Derived[]) => Derived): typeof a; 56declare function foo10(a: any): any; 57 58declare function foo11(a: (x: { foo: string }, y: { foo: string; bar: string }) => Base): typeof a; 59declare function foo11(a: any): any; 60 61declare function foo12(a: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>): typeof a; 62declare function foo12(a: any): any; 63 64declare function foo13(a: (x: Array<Base>, y: Array<Derived>) => Array<Derived>): typeof a; 65declare function foo13(a: any): any; 66 67declare function foo14(a: (x: { a: string; b: number }) => Object): typeof a; 68declare function foo14(a: any): any; 69 70declare function foo15(a: { 71 (x: number): number[]; 72 (x: string): string[]; 73}): typeof a; 74declare function foo15(a: any): any; 75 76declare function foo16(a: { 77 <T extends Derived>(x: T): number[]; 78 <U extends Base>(x: U): number[]; 79}): typeof a; 80declare function foo16(a: any): any; 81 82declare function foo17(a: { 83 (x: (a: number) => number): number[]; 84 (x: (a: string) => string): string[]; 85}): typeof a; 86declare function foo17(a: any): any; 87 88declare function foo18(a: { 89 (x: { 90 (a: number): number; 91 (a: string): string; 92 }): any[]; 93 (x: { 94 (a: boolean): boolean; 95 (a: Date): Date; 96 }): any[]; 97}): typeof a; 98declare function foo18(a: any): any; 99 100let r1arg1 = <T>(x: T) => [x]; 101AssertType(r1arg1, "<T>(T) => T[]"); 102AssertType(<T>(x: T) => [x], "<T>(T) => T[]"); 103AssertType(x, "T"); 104AssertType([x], "T[]"); 105AssertType(x, "T"); 106 107let r1arg2 = (x: number) => [1]; 108AssertType(r1arg2, "(number) => number[]"); 109AssertType((x: number) => [1], "(number) => number[]"); 110AssertType(x, "number"); 111AssertType([1], "number[]"); 112AssertType(1, "int"); 113 114let r1 = foo1(r1arg1); // any, 115AssertType(r1, "(number) => number[]"); 116AssertType(foo1(r1arg1), "(number) => number[]"); 117AssertType(foo1, "{ ((number) => number[]): (number) => number[]; (any): any; }"); 118AssertType(r1arg1, "<T>(T) => T[]"); 119return types are not subtype of first overload 120 121let r1a = [r1arg2, r1arg1]; // generic signature, subtype in both directions 122AssertType(r1a, "((number) => number[])[]"); 123AssertType([r1arg2, r1arg1], "((number) => number[])[]"); 124AssertType(r1arg2, "(number) => number[]"); 125AssertType(r1arg1, "<T>(T) => T[]"); 126 127let r1b = [r1arg1, r1arg2]; // generic signature, subtype in both directions 128AssertType(r1b, "((number) => number[])[]"); 129AssertType([r1arg1, r1arg2], "((number) => number[])[]"); 130AssertType(r1arg1, "<T>(T) => T[]"); 131AssertType(r1arg2, "(number) => number[]"); 132 133let r2arg1 = <T>(x: T) => ['']; 134AssertType(r2arg1, "<T>(T) => string[]"); 135AssertType(<T>(x: T) => [''], "<T>(T) => string[]"); 136AssertType(x, "T"); 137AssertType([''], "string[]"); 138AssertType('', "string"); 139 140let r2arg2 = (x: number) => ['']; 141AssertType(r2arg2, "(number) => string[]"); 142AssertType((x: number) => [''], "(number) => string[]"); 143AssertType(x, "number"); 144AssertType([''], "string[]"); 145AssertType('', "string"); 146 147let r2 = foo2(r2arg1); 148AssertType(r2, "(number) => string[]"); 149AssertType(foo2(r2arg1), "(number) => string[]"); 150AssertType(foo2, "{ ((number) => string[]): (number) => string[]; (any): any; }"); 151AssertType(r2arg1, "<T>(T) => string[]"); 152 153let r2a = [r2arg1, r2arg2]; 154AssertType(r2a, "((number) => string[])[]"); 155AssertType([r2arg1, r2arg2], "((number) => string[])[]"); 156AssertType(r2arg1, "<T>(T) => string[]"); 157AssertType(r2arg2, "(number) => string[]"); 158 159let r2b = [r2arg2, r2arg1]; 160AssertType(r2b, "((number) => string[])[]"); 161AssertType([r2arg2, r2arg1], "((number) => string[])[]"); 162AssertType(r2arg2, "(number) => string[]"); 163AssertType(r2arg1, "<T>(T) => string[]"); 164 165let r3arg1 = <T>(x: T) => x; 166AssertType(r3arg1, "<T>(T) => T"); 167AssertType(<T>(x: T) => x, "<T>(T) => T"); 168AssertType(x, "T"); 169AssertType(x, "T"); 170 171let r3arg2 = (x: number) => { }; 172AssertType(r3arg2, "(number) => void"); 173AssertType((x: number) => { }, "(number) => void"); 174AssertType(x, "number"); 175 176let r3 = foo3(r3arg1); 177AssertType(r3, "(number) => void"); 178AssertType(foo3(r3arg1), "(number) => void"); 179AssertType(foo3, "{ ((number) => void): (number) => void; (any): any; }"); 180AssertType(r3arg1, "<T>(T) => T"); 181 182let r3a = [r3arg1, r3arg2]; 183AssertType(r3a, "((number) => void)[]"); 184AssertType([r3arg1, r3arg2], "((number) => void)[]"); 185AssertType(r3arg1, "<T>(T) => T"); 186AssertType(r3arg2, "(number) => void"); 187 188let r3b = [r3arg2, r3arg1]; 189AssertType(r3b, "((number) => void)[]"); 190AssertType([r3arg2, r3arg1], "((number) => void)[]"); 191AssertType(r3arg2, "(number) => void"); 192AssertType(r3arg1, "<T>(T) => T"); 193 194let r4arg1 = <T, U>(x: T, y: U) => x; 195AssertType(r4arg1, "<T, U>(T, U) => T"); 196AssertType(<T, U>(x: T, y: U) => x, "<T, U>(T, U) => T"); 197AssertType(x, "T"); 198AssertType(y, "U"); 199AssertType(x, "T"); 200 201let r4arg2 = (x: string, y: number) => ''; 202AssertType(r4arg2, "(string, number) => string"); 203AssertType((x: string, y: number) => '', "(string, number) => string"); 204AssertType(x, "string"); 205AssertType(y, "number"); 206AssertType('', "string"); 207 208let r4 = foo4(r4arg1); // any 209AssertType(r4, "(string, number) => string"); 210AssertType(foo4(r4arg1), "(string, number) => string"); 211AssertType(foo4, "{ ((string, number) => string): (string, number) => string; (any): any; }"); 212AssertType(r4arg1, "<T, U>(T, U) => T"); 213 214let r4a = [r4arg1, r4arg2]; 215AssertType(r4a, "((string, number) => string)[]"); 216AssertType([r4arg1, r4arg2], "((string, number) => string)[]"); 217AssertType(r4arg1, "<T, U>(T, U) => T"); 218AssertType(r4arg2, "(string, number) => string"); 219 220let r4b = [r4arg2, r4arg1]; 221AssertType(r4b, "((string, number) => string)[]"); 222AssertType([r4arg2, r4arg1], "((string, number) => string)[]"); 223AssertType(r4arg2, "(string, number) => string"); 224AssertType(r4arg1, "<T, U>(T, U) => T"); 225 226let r5arg1 = <T, U>(x: (arg: T) => U) => <T>null; 227AssertType(r5arg1, "<T, U>((T) => U) => T"); 228AssertType(<T, U>(x: (arg: T) => U) => <T>null, "<T, U>((T) => U) => T"); 229AssertType(x, "(T) => U"); 230AssertType(arg, "T"); 231AssertType(<T>null, "T"); 232AssertType(null, "null"); 233 234let r5arg2 = (x: (arg: string) => number) => ''; 235AssertType(r5arg2, "((string) => number) => string"); 236AssertType((x: (arg: string) => number) => '', "((string) => number) => string"); 237AssertType(x, "(string) => number"); 238AssertType(arg, "string"); 239AssertType('', "string"); 240 241let r5 = foo5(r5arg1); // any 242AssertType(r5, "((string) => number) => string"); 243AssertType(foo5(r5arg1), "((string) => number) => string"); 244AssertType(foo5, "{ (((string) => number) => string): ((string) => number) => string; (any): any; }"); 245AssertType(r5arg1, "<T, U>((T) => U) => T"); 246 247let r5a = [r5arg1, r5arg2]; 248AssertType(r5a, "(((string) => number) => string)[]"); 249AssertType([r5arg1, r5arg2], "(((string) => number) => string)[]"); 250AssertType(r5arg1, "<T, U>((T) => U) => T"); 251AssertType(r5arg2, "((string) => number) => string"); 252 253let r5b = [r5arg2, r5arg1]; 254AssertType(r5b, "(((string) => number) => string)[]"); 255AssertType([r5arg2, r5arg1], "(((string) => number) => string)[]"); 256AssertType(r5arg2, "((string) => number) => string"); 257AssertType(r5arg1, "<T, U>((T) => U) => T"); 258 259let r6arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null; 260AssertType(r6arg1, "<T extends Base, U extends Derived>((T) => U) => T"); 261AssertType(<T extends Base, U extends Derived>(x: (arg: T) => U) => <T>null, "<T extends Base, U extends Derived>((T) => U) => T"); 262AssertType(x, "(T) => U"); 263AssertType(arg, "T"); 264AssertType(<T>null, "T"); 265AssertType(null, "null"); 266 267let r6arg2 = (x: (arg: Base) => Derived) => <Base>null; 268AssertType(r6arg2, "((Base) => Derived) => Base"); 269AssertType((x: (arg: Base) => Derived) => <Base>null, "((Base) => Derived) => Base"); 270AssertType(x, "(Base) => Derived"); 271AssertType(arg, "Base"); 272AssertType(<Base>null, "Base"); 273AssertType(null, "null"); 274 275let r6 = foo6(r6arg1); // any 276AssertType(r6, "((Base) => Derived) => Base"); 277AssertType(foo6(r6arg1), "((Base) => Derived) => Base"); 278AssertType(foo6, "{ (((Base) => Derived) => Base): ((Base) => Derived) => Base; (any): any; }"); 279AssertType(r6arg1, "<T extends Base, U extends Derived>((T) => U) => T"); 280 281let r6a = [r6arg1, r6arg2]; 282AssertType(r6a, "(((Base) => Derived) => Base)[]"); 283AssertType([r6arg1, r6arg2], "(((Base) => Derived) => Base)[]"); 284AssertType(r6arg1, "<T extends Base, U extends Derived>((T) => U) => T"); 285AssertType(r6arg2, "((Base) => Derived) => Base"); 286 287let r6b = [r6arg2, r6arg1]; 288AssertType(r6b, "(((Base) => Derived) => Base)[]"); 289AssertType([r6arg2, r6arg1], "(((Base) => Derived) => Base)[]"); 290AssertType(r6arg2, "((Base) => Derived) => Base"); 291AssertType(r6arg1, "<T extends Base, U extends Derived>((T) => U) => T"); 292 293let r7arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null; 294AssertType(r7arg1, "<T extends Base, U extends Derived>((T) => U) => (T) => U"); 295AssertType(<T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => <U>null, "<T extends Base, U extends Derived>((T) => U) => (T) => U"); 296AssertType(x, "(T) => U"); 297AssertType(arg, "T"); 298AssertType((r: T) => <U>null, "(T) => U"); 299AssertType(r, "T"); 300AssertType(<U>null, "U"); 301AssertType(null, "null"); 302 303let r7arg2 = (x: (arg: Base) => Derived) => (r: Base) => <Derived>null; 304AssertType(r7arg2, "((Base) => Derived) => (Base) => Derived"); 305AssertType((x: (arg: Base) => Derived) => (r: Base) => <Derived>null, "((Base) => Derived) => (Base) => Derived"); 306AssertType(x, "(Base) => Derived"); 307AssertType(arg, "Base"); 308AssertType((r: Base) => <Derived>null, "(Base) => Derived"); 309AssertType(r, "Base"); 310AssertType(<Derived>null, "Derived"); 311AssertType(null, "null"); 312 313let r7 = foo7(r7arg1); // any 314AssertType(r7, "((Base) => Derived) => (Base) => Derived"); 315AssertType(foo7(r7arg1), "((Base) => Derived) => (Base) => Derived"); 316AssertType(foo7, "{ (((Base) => Derived) => (Base) => Derived): ((Base) => Derived) => (Base) => Derived; (any): any; }"); 317AssertType(r7arg1, "<T extends Base, U extends Derived>((T) => U) => (T) => U"); 318 319let r7a = [r7arg1, r7arg2]; 320AssertType(r7a, "(((Base) => Derived) => (Base) => Derived)[]"); 321AssertType([r7arg1, r7arg2], "(((Base) => Derived) => (Base) => Derived)[]"); 322AssertType(r7arg1, "<T extends Base, U extends Derived>((T) => U) => (T) => U"); 323AssertType(r7arg2, "((Base) => Derived) => (Base) => Derived"); 324 325let r7b = [r7arg2, r7arg1]; 326AssertType(r7b, "(((Base) => Derived) => (Base) => Derived)[]"); 327AssertType([r7arg2, r7arg1], "(((Base) => Derived) => (Base) => Derived)[]"); 328AssertType(r7arg2, "((Base) => Derived) => (Base) => Derived"); 329AssertType(r7arg1, "<T extends Base, U extends Derived>((T) => U) => (T) => U"); 330 331let r8arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null; 332AssertType(r8arg1, "<T extends Base, U extends Derived>((T) => U, (T) => U) => (T) => U"); 333AssertType(<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => <U>null, "<T extends Base, U extends Derived>((T) => U, (T) => U) => (T) => U"); 334AssertType(x, "(T) => U"); 335AssertType(arg, "T"); 336AssertType(y, "(T) => U"); 337AssertType(arg2, "T"); 338AssertType((r: T) => <U>null, "(T) => U"); 339AssertType(r, "T"); 340AssertType(<U>null, "U"); 341AssertType(null, "null"); 342 343let r8arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null; 344AssertType(r8arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 345AssertType((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 346AssertType(x, "(Base) => Derived"); 347AssertType(arg, "Base"); 348AssertType(y, "(Base) => Derived"); 349AssertType(arg2, "Base"); 350AssertType((r: Base) => <Derived>null, "(Base) => Derived"); 351AssertType(r, "Base"); 352AssertType(<Derived>null, "Derived"); 353AssertType(null, "null"); 354 355let r8 = foo8(r8arg1); // any 356AssertType(r8, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 357AssertType(foo8(r8arg1), "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 358AssertType(foo8, "{ (((Base) => Derived, (Base) => Derived) => (Base) => Derived): ((Base) => Derived, (Base) => Derived) => (Base) => Derived; (any): any; }"); 359AssertType(r8arg1, "<T extends Base, U extends Derived>((T) => U, (T) => U) => (T) => U"); 360 361let r8a = [r8arg1, r8arg2]; 362AssertType(r8a, "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 363AssertType([r8arg1, r8arg2], "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 364AssertType(r8arg1, "<T extends Base, U extends Derived>((T) => U, (T) => U) => (T) => U"); 365AssertType(r8arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 366 367let r8b = [r8arg2, r8arg1]; 368AssertType(r8b, "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 369AssertType([r8arg2, r8arg1], "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 370AssertType(r8arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 371AssertType(r8arg1, "<T extends Base, U extends Derived>((T) => U, (T) => U) => (T) => U"); 372 373let r9arg1 = <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null; 374AssertType(r9arg1, "<T extends Base, U extends Derived>((T) => U, ({ foo: string; bing: number;}) => U) => (T) => U"); 375AssertType(<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => <U>null, "<T extends Base, U extends Derived>((T) => U, ({ foo: string; bing: number;}) => U) => (T) => U"); 376AssertType(x, "(T) => U"); 377AssertType(arg, "T"); 378AssertType(y, "({ foo: string; bing: number;}) => U"); 379AssertType(arg2, "{ foo: string; bing: number; }"); 380AssertType(foo, "string"); 381AssertType(bing, "number"); 382AssertType((r: T) => <U>null, "(T) => U"); 383AssertType(r, "T"); 384AssertType(<U>null, "U"); 385AssertType(null, "null"); 386 387let r9arg2 = (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null; 388AssertType(r9arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 389AssertType((x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => <Derived>null, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 390AssertType(x, "(Base) => Derived"); 391AssertType(arg, "Base"); 392AssertType(y, "(Base) => Derived"); 393AssertType(arg2, "Base"); 394AssertType((r: Base) => <Derived>null, "(Base) => Derived"); 395AssertType(r, "Base"); 396AssertType(<Derived>null, "Derived"); 397AssertType(null, "null"); 398 399let r9 = foo9(r9arg1); // any 400AssertType(r9, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 401AssertType(foo9(r9arg1), "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 402AssertType(foo9, "{ (((Base) => Derived, (Base) => Derived) => (Base) => Derived): ((Base) => Derived, (Base) => Derived) => (Base) => Derived; (any): any; }"); 403AssertType(r9arg1, "<T extends Base, U extends Derived>((T) => U, ({ foo: string; bing: number; }) => U) => (T) => U"); 404 405let r9a = [r9arg1, r9arg2]; 406AssertType(r9a, "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 407AssertType([r9arg1, r9arg2], "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 408AssertType(r9arg1, "<T extends Base, U extends Derived>((T) => U, ({ foo: string; bing: number; }) => U) => (T) => U"); 409AssertType(r9arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 410 411let r9b = [r9arg2, r9arg1]; 412AssertType(r9b, "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 413AssertType([r9arg2, r9arg1], "(((Base) => Derived, (Base) => Derived) => (Base) => Derived)[]"); 414AssertType(r9arg2, "((Base) => Derived, (Base) => Derived) => (Base) => Derived"); 415AssertType(r9arg1, "<T extends Base, U extends Derived>((T) => U, ({ foo: string; bing: number; }) => U) => (T) => U"); 416 417let r10arg1 = <T extends Derived>(...x: T[]) => x[0]; 418AssertType(r10arg1, "<T extends Derived>(...T[]) => T"); 419AssertType(<T extends Derived>(...x: T[]) => x[0], "<T extends Derived>(...T[]) => T"); 420AssertType(x, "T[]"); 421AssertType(x[0], "T"); 422AssertType(x, "T[]"); 423AssertType(0, "int"); 424 425let r10arg2 = (...x: Derived[]) => <Derived>null; 426AssertType(r10arg2, "(...Derived[]) => Derived"); 427AssertType((...x: Derived[]) => <Derived>null, "(...Derived[]) => Derived"); 428AssertType(x, "Derived[]"); 429AssertType(<Derived>null, "Derived"); 430AssertType(null, "null"); 431 432let r10 = foo10(r10arg1); // any 433AssertType(r10, "(...Derived[]) => Derived"); 434AssertType(foo10(r10arg1), "(...Derived[]) => Derived"); 435AssertType(foo10, "{ ((...Derived[]) => Derived): (...Derived[]) => Derived; (any): any; }"); 436AssertType(r10arg1, "<T extends Derived>(...T[]) => T"); 437 438let r10a = [r10arg1, r10arg2]; 439AssertType(r10a, "((...Derived[]) => Derived)[]"); 440AssertType([r10arg1, r10arg2], "((...Derived[]) => Derived)[]"); 441AssertType(r10arg1, "<T extends Derived>(...T[]) => T"); 442AssertType(r10arg2, "(...Derived[]) => Derived"); 443 444let r10b = [r10arg2, r10arg1]; 445AssertType(r10b, "((...Derived[]) => Derived)[]"); 446AssertType([r10arg2, r10arg1], "((...Derived[]) => Derived)[]"); 447AssertType(r10arg2, "(...Derived[]) => Derived"); 448AssertType(r10arg1, "<T extends Derived>(...T[]) => T"); 449 450let r11arg1 = <T extends Base>(x: T, y: T) => x; 451AssertType(r11arg1, "<T extends Base>(T, T) => T"); 452AssertType(<T extends Base>(x: T, y: T) => x, "<T extends Base>(T, T) => T"); 453AssertType(x, "T"); 454AssertType(y, "T"); 455AssertType(x, "T"); 456 457let r11arg2 = (x: { foo: string }, y: { foo: string; bar: string }) => <Base>null; 458AssertType(r11arg2, "({ foo: string;}, { foo: string; bar: string;}) => Base"); 459AssertType((x: { foo: string }, y: { foo: string; bar: string }) => <Base>null, "({ foo: string;}, { foo: string; bar: string;}) => Base"); 460AssertType(x, "{ foo: string; }"); 461AssertType(foo, "string"); 462AssertType(y, "{ foo: string; bar: string; }"); 463AssertType(foo, "string"); 464AssertType(bar, "string"); 465AssertType(<Base>null, "Base"); 466AssertType(null, "null"); 467 468let r11 = foo11(r11arg1); // any 469AssertType(r11, "({ foo: string; }, { foo: string; bar: string; }) => Base"); 470AssertType(foo11(r11arg1), "({ foo: string; }, { foo: string; bar: string; }) => Base"); 471AssertType(foo11, "{ (({ foo: string; }, { foo: string; bar: string; }) => Base): ({ foo: string; }, { foo: string; bar: string; }) => Base; (any): any; }"); 472AssertType(r11arg1, "<T extends Base>(T, T) => T"); 473 474let r11a = [r11arg1, r11arg2]; 475AssertType(r11a, "(({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 476AssertType([r11arg1, r11arg2], "(({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 477AssertType(r11arg1, "<T extends Base>(T, T) => T"); 478AssertType(r11arg2, "({ foo: string; }, { foo: string; bar: string; }) => Base"); 479 480let r11b = [r11arg2, r11arg1]; 481AssertType(r11b, "(({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 482AssertType([r11arg2, r11arg1], "(({ foo: string; }, { foo: string; bar: string; }) => Base)[]"); 483AssertType(r11arg2, "({ foo: string; }, { foo: string; bar: string; }) => Base"); 484AssertType(r11arg1, "<T extends Base>(T, T) => T"); 485 486let r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null; 487AssertType(r12arg1, "<T extends Base[]>(Array<Base>, T) => Derived[]"); 488AssertType(<T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null, "<T extends Base[]>(Array<Base>, T) => Derived[]"); 489AssertType(x, "Base[]"); 490AssertType(y, "T"); 491AssertType(<Array<Derived>>null, "Derived[]"); 492AssertType(null, "null"); 493 494let r12arg2 = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null; 495AssertType(r12arg2, "(Array<Base>, Array<Derived2>) => Derived[]"); 496AssertType((x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null, "(Array<Base>, Array<Derived2>) => Derived[]"); 497AssertType(x, "Base[]"); 498AssertType(y, "Derived2[]"); 499AssertType(<Array<Derived>>null, "Derived[]"); 500AssertType(null, "null"); 501 502let r12 = foo12(r12arg1); // any 503AssertType(r12, "(Base[], Derived2[]) => Derived[]"); 504AssertType(foo12(r12arg1), "(Base[], Derived2[]) => Derived[]"); 505AssertType(foo12, "{ ((Base[], Derived2[]) => Derived[]): (Base[], Derived2[]) => Derived[]; (any): any; }"); 506AssertType(r12arg1, "<T extends Base[]>(Base[], T) => Derived[]"); 507 508let r12a = [r12arg1, r12arg2]; 509AssertType(r12a, "((Base[], Derived2[]) => Derived[])[]"); 510AssertType([r12arg1, r12arg2], "((Base[], Derived2[]) => Derived[])[]"); 511AssertType(r12arg1, "<T extends Base[]>(Base[], T) => Derived[]"); 512AssertType(r12arg2, "(Base[], Derived2[]) => Derived[]"); 513 514let r12b = [r12arg2, r12arg1]; 515AssertType(r12b, "((Base[], Derived2[]) => Derived[])[]"); 516AssertType([r12arg2, r12arg1], "((Base[], Derived2[]) => Derived[])[]"); 517AssertType(r12arg2, "(Base[], Derived2[]) => Derived[]"); 518AssertType(r12arg1, "<T extends Base[]>(Base[], T) => Derived[]"); 519 520let r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y; 521AssertType(r13arg1, "<T extends Derived[]>(Array<Base>, T) => T"); 522AssertType(<T extends Array<Derived>>(x: Array<Base>, y: T) => y, "<T extends Derived[]>(Array<Base>, T) => T"); 523AssertType(x, "Base[]"); 524AssertType(y, "T"); 525AssertType(y, "T"); 526 527let r13arg2 = (x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null; 528AssertType(r13arg2, "(Array<Base>, Array<Derived>) => Derived[]"); 529AssertType((x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null, "(Array<Base>, Array<Derived>) => Derived[]"); 530AssertType(x, "Base[]"); 531AssertType(y, "Derived[]"); 532AssertType(<Array<Derived>>null, "Derived[]"); 533AssertType(null, "null"); 534 535let r13 = foo13(r13arg1); // any 536AssertType(r13, "(Base[], Derived[]) => Derived[]"); 537AssertType(foo13(r13arg1), "(Base[], Derived[]) => Derived[]"); 538AssertType(foo13, "{ ((Base[], Derived[]) => Derived[]): (Base[], Derived[]) => Derived[]; (any): any; }"); 539AssertType(r13arg1, "<T extends Derived[]>(Base[], T) => T"); 540 541let r13a = [r13arg1, r13arg2]; 542AssertType(r13a, "((Base[], Derived[]) => Derived[])[]"); 543AssertType([r13arg1, r13arg2], "((Base[], Derived[]) => Derived[])[]"); 544AssertType(r13arg1, "<T extends Derived[]>(Base[], T) => T"); 545AssertType(r13arg2, "(Base[], Derived[]) => Derived[]"); 546 547let r13b = [r13arg2, r13arg1]; 548AssertType(r13b, "((Base[], Derived[]) => Derived[])[]"); 549AssertType([r13arg2, r13arg1], "((Base[], Derived[]) => Derived[])[]"); 550AssertType(r13arg2, "(Base[], Derived[]) => Derived[]"); 551AssertType(r13arg1, "<T extends Derived[]>(Base[], T) => T"); 552 553let r14arg1 = <T>(x: { a: T; b: T }) => x.a; 554AssertType(r14arg1, "<T>({ a: T; b: T; }) => T"); 555AssertType(<T>(x: { a: T; b: T }) => x.a, "<T>({ a: T; b: T; }) => T"); 556AssertType(x, "{ a: T; b: T; }"); 557AssertType(a, "T"); 558AssertType(b, "T"); 559AssertType(x.a, "T"); 560 561let r14arg2 = (x: { a: string; b: number }) => <Object>null; 562AssertType(r14arg2, "({ a: string; b: number;}) => Object"); 563AssertType((x: { a: string; b: number }) => <Object>null, "({ a: string; b: number;}) => Object"); 564AssertType(x, "{ a: string; b: number; }"); 565AssertType(a, "string"); 566AssertType(b, "number"); 567AssertType(<Object>null, "Object"); 568AssertType(null, "null"); 569 570let r14 = foo14(r14arg1); // any 571AssertType(r14, "any"); 572AssertType(foo14(r14arg1), "any"); 573AssertType(foo14, "{ (({ a: string; b: number; }) => Object): ({ a: string; b: number; }) => Object; (any): any; }"); 574AssertType(r14arg1, "<T>({ a: T; b: T; }) => T"); 575 576let r14a = [r14arg1, r14arg2]; 577AssertType(r14a, "(union)[]"); 578AssertType([r14arg1, r14arg2], "(union)[]"); 579AssertType(r14arg1, "<T>({ a: T; b: T; }) => T"); 580AssertType(r14arg2, "({ a: string; b: number; }) => Object"); 581 582let r14b = [r14arg2, r14arg1]; 583AssertType(r14b, "(union)[]"); 584AssertType([r14arg2, r14arg1], "(union)[]"); 585AssertType(r14arg2, "({ a: string; b: number; }) => Object"); 586AssertType(r14arg1, "<T>({ a: T; b: T; }) => T"); 587 588let r15arg1 = <T>(x: T) => <T[]>null 589AssertType(r15arg1, "<T>(T) => T[]"); 590AssertType(<T>(x: T) => <T[]>null, "<T>(T) => T[]"); 591AssertType(x, "T"); 592AssertType(<T[]>null, "T[]"); 593AssertType(null, "null"); 594 595let r15 = foo15(r15arg1); // any 596AssertType(r15, "any"); 597AssertType(foo15(r15arg1), "any"); 598AssertType(foo15, "{ ({ (number): number[]; (string): string[]; }): { (number): number[]; (string): string[]; }; (any): any; }"); 599AssertType(r15arg1, "<T>(T) => T[]"); 600 601let r16arg1 = <T extends Base>(x: T) => [1]; 602AssertType(r16arg1, "<T extends Base>(T) => number[]"); 603AssertType(<T extends Base>(x: T) => [1], "<T extends Base>(T) => number[]"); 604AssertType(x, "T"); 605AssertType([1], "number[]"); 606AssertType(1, "int"); 607 608let r16 = foo16(r16arg1); 609AssertType(r16, "{ <T extends Derived>(T): number[]; <U extends Base>(U): number[]; }"); 610AssertType(foo16(r16arg1), "{ <T extends Derived>(T): number[]; <U extends Base>(U): number[]; }"); 611AssertType(foo16, "{ ({ <T extends Derived>(T): number[]; <U extends Base>(U): number[]; }): { <T extends Derived>(T): number[]; <U extends Base>(U): number[]; }; (any): any; }"); 612AssertType(r16arg1, "<T extends Base>(T) => number[]"); 613 614let r17arg1 = <T>(x: (a: T) => T) => <T[]>null; 615AssertType(r17arg1, "<T>((T) => T) => T[]"); 616AssertType(<T>(x: (a: T) => T) => <T[]>null, "<T>((T) => T) => T[]"); 617AssertType(x, "(T) => T"); 618AssertType(a, "T"); 619AssertType(<T[]>null, "T[]"); 620AssertType(null, "null"); 621 622let r17 = foo17(r17arg1); // any 623AssertType(r17, "any"); 624AssertType(foo17(r17arg1), "any"); 625AssertType(foo17, "{ ({ ((number) => number): number[]; ((string) => string): string[]; }): { ((number) => number): number[]; ((string) => string): string[]; }; (any): any; }"); 626AssertType(r17arg1, "<T>((T) => T) => T[]"); 627 628let r18arg1 = <T>(x: (a: T) => T) => <T[]>null; 629AssertType(r18arg1, "<T>((T) => T) => T[]"); 630AssertType(<T>(x: (a: T) => T) => <T[]>null, "<T>((T) => T) => T[]"); 631AssertType(x, "(T) => T"); 632AssertType(a, "T"); 633AssertType(<T[]>null, "T[]"); 634AssertType(null, "null"); 635 636let r18 = foo18(r18arg1); 637AssertType(r18, "{ ({ (number): number; (string): string; }): any[]; ({ (boolean): boolean; (Date): Date; }): any[]; }"); 638AssertType(foo18(r18arg1), "{ ({ (number): number; (string): string; }): any[]; ({ (boolean): boolean; (Date): Date; }): any[]; }"); 639AssertType(foo18, "{ ({ ({ (number): number; (string): string; }): any[]; ({ (boolean): boolean; (Date): Date; }): any[]; }): { ({ (number): number; (string): string; }): any[]; ({ (boolean): boolean; (Date): Date; }): any[]; }; (any): any; }"); 640AssertType(r18arg1, "<T>((T) => T) => T[]"); 641 642 643