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/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithSubtypeObjectOnCallSignature.ts === 20declare function AssertType(value:any, type:string):void; 21class Base { 22 public a: string; 23} 24 25class Derived extends Base { 26 public b: string; 27} 28 29let a1: { fn(): void }; 30AssertType(a1, "{ fn(): void; }"); 31AssertType(fn, "() => void"); 32 33let b1: { fn(): void }; 34AssertType(b1, "{ fn(): void; }"); 35AssertType(fn, "() => void"); 36 37let a2: { fn(a: number, b: string): void }; 38AssertType(a2, "{ fn(number, string): void; }"); 39AssertType(fn, "(number, string) => void"); 40AssertType(a, "number"); 41AssertType(b, "string"); 42 43let b2: { fn(a: number, b: string): void }; 44AssertType(b2, "{ fn(number, string): void; }"); 45AssertType(fn, "(number, string) => void"); 46AssertType(a, "number"); 47AssertType(b, "string"); 48 49let a3: { fn(a: number, b: string): void }; 50AssertType(a3, "{ fn(number, string): void; }"); 51AssertType(fn, "(number, string) => void"); 52AssertType(a, "number"); 53AssertType(b, "string"); 54 55let b3: { fn(a: number): void }; 56AssertType(b3, "{ fn(number): void; }"); 57AssertType(fn, "(number) => void"); 58AssertType(a, "number"); 59 60let a4: { fn(a: number, b: string): void }; 61AssertType(a4, "{ fn(number, string): void; }"); 62AssertType(fn, "(number, string) => void"); 63AssertType(a, "number"); 64AssertType(b, "string"); 65 66let b4: { fn(): void }; 67AssertType(b4, "{ fn(): void; }"); 68AssertType(fn, "() => void"); 69 70let a5: { fn(a: Base): void }; 71AssertType(a5, "{ fn(Base): void; }"); 72AssertType(fn, "(Base) => void"); 73AssertType(a, "Base"); 74 75let b5: { fn(a: Derived): void }; 76AssertType(b5, "{ fn(Derived): void; }"); 77AssertType(fn, "(Derived) => void"); 78AssertType(a, "Derived"); 79 80let a6: { fn(a: Derived, b: Base): void }; 81AssertType(a6, "{ fn(Derived, Base): void; }"); 82AssertType(fn, "(Derived, Base) => void"); 83AssertType(a, "Derived"); 84AssertType(b, "Base"); 85 86let b6: { fn(a: Base, b: Derived): void }; 87AssertType(b6, "{ fn(Base, Derived): void; }"); 88AssertType(fn, "(Base, Derived) => void"); 89AssertType(a, "Base"); 90AssertType(b, "Derived"); 91 92let a7: { fn(): void }; 93AssertType(a7, "{ fn(): void; }"); 94AssertType(fn, "() => void"); 95 96let b7: { fn(): Base }; 97AssertType(b7, "{ fn(): Base; }"); 98AssertType(fn, "() => Base"); 99 100let a8: { fn(): Base }; 101AssertType(a8, "{ fn(): Base; }"); 102AssertType(fn, "() => Base"); 103 104let b8: { fn(): Base }; 105AssertType(b8, "{ fn(): Base; }"); 106AssertType(fn, "() => Base"); 107 108let a9: { fn(): Base }; 109AssertType(a9, "{ fn(): Base; }"); 110AssertType(fn, "() => Base"); 111 112let b9: { fn(): Derived }; 113AssertType(b9, "{ fn(): Derived; }"); 114AssertType(fn, "() => Derived"); 115 116let a10: { fn(a?: Base): void }; 117AssertType(a10, "{ fn(?Base): void; }"); 118AssertType(fn, "(?Base) => void"); 119AssertType(a, "Base"); 120 121let b10: { fn(a?: Derived): void }; 122AssertType(b10, "{ fn(?Derived): void; }"); 123AssertType(fn, "(?Derived) => void"); 124AssertType(a, "Derived"); 125 126let a11: { fn(...a: Base[]): void }; 127AssertType(a11, "{ fn(...Base[]): void; }"); 128AssertType(fn, "(...Base[]) => void"); 129AssertType(a, "Base[]"); 130 131let b11: { fn(...a: Derived[]): void }; 132AssertType(b11, "{ fn(...Derived[]): void; }"); 133AssertType(fn, "(...Derived[]) => void"); 134AssertType(a, "Derived[]"); 135 136// operator < 137let r1a1 = a1 < b1; 138AssertType(r1a1, "boolean"); 139AssertType(a1 < b1, "boolean"); 140AssertType(a1, "{ fn(): void; }"); 141AssertType(b1, "{ fn(): void; }"); 142 143let r1a2 = a2 < b2; 144AssertType(r1a2, "boolean"); 145AssertType(a2 < b2, "boolean"); 146AssertType(a2, "{ fn(number, string): void; }"); 147AssertType(b2, "{ fn(number, string): void; }"); 148 149let r1a3 = a3 < b3; 150AssertType(r1a3, "boolean"); 151AssertType(a3 < b3, "boolean"); 152AssertType(a3, "{ fn(number, string): void; }"); 153AssertType(b3, "{ fn(number): void; }"); 154 155let r1a4 = a4 < b4; 156AssertType(r1a4, "boolean"); 157AssertType(a4 < b4, "boolean"); 158AssertType(a4, "{ fn(number, string): void; }"); 159AssertType(b4, "{ fn(): void; }"); 160 161let r1a5 = a5 < b5; 162AssertType(r1a5, "boolean"); 163AssertType(a5 < b5, "boolean"); 164AssertType(a5, "{ fn(Base): void; }"); 165AssertType(b5, "{ fn(Derived): void; }"); 166 167let r1a6 = a6 < b6; 168AssertType(r1a6, "boolean"); 169AssertType(a6 < b6, "boolean"); 170AssertType(a6, "{ fn(Derived, Base): void; }"); 171AssertType(b6, "{ fn(Base, Derived): void; }"); 172 173let r1a7 = a7 < b7; 174AssertType(r1a7, "boolean"); 175AssertType(a7 < b7, "boolean"); 176AssertType(a7, "{ fn(): void; }"); 177AssertType(b7, "{ fn(): Base; }"); 178 179let r1a8 = a8 < b8; 180AssertType(r1a8, "boolean"); 181AssertType(a8 < b8, "boolean"); 182AssertType(a8, "{ fn(): Base; }"); 183AssertType(b8, "{ fn(): Base; }"); 184 185let r1a9 = a9 < b9; 186AssertType(r1a9, "boolean"); 187AssertType(a9 < b9, "boolean"); 188AssertType(a9, "{ fn(): Base; }"); 189AssertType(b9, "{ fn(): Derived; }"); 190 191let r1a10 = a10 < b10; 192AssertType(r1a10, "boolean"); 193AssertType(a10 < b10, "boolean"); 194AssertType(a10, "{ fn(?Base): void; }"); 195AssertType(b10, "{ fn(?Derived): void; }"); 196 197let r1a11 = a11 < b11; 198AssertType(r1a11, "boolean"); 199AssertType(a11 < b11, "boolean"); 200AssertType(a11, "{ fn(...Base[]): void; }"); 201AssertType(b11, "{ fn(...Derived[]): void; }"); 202 203let r1b1 = b1 < a1; 204AssertType(r1b1, "boolean"); 205AssertType(b1 < a1, "boolean"); 206AssertType(b1, "{ fn(): void; }"); 207AssertType(a1, "{ fn(): void; }"); 208 209let r1b2 = b2 < a2; 210AssertType(r1b2, "boolean"); 211AssertType(b2 < a2, "boolean"); 212AssertType(b2, "{ fn(number, string): void; }"); 213AssertType(a2, "{ fn(number, string): void; }"); 214 215let r1b3 = b3 < a3; 216AssertType(r1b3, "boolean"); 217AssertType(b3 < a3, "boolean"); 218AssertType(b3, "{ fn(number): void; }"); 219AssertType(a3, "{ fn(number, string): void; }"); 220 221let r1b4 = b4 < a4; 222AssertType(r1b4, "boolean"); 223AssertType(b4 < a4, "boolean"); 224AssertType(b4, "{ fn(): void; }"); 225AssertType(a4, "{ fn(number, string): void; }"); 226 227let r1b5 = b5 < a5; 228AssertType(r1b5, "boolean"); 229AssertType(b5 < a5, "boolean"); 230AssertType(b5, "{ fn(Derived): void; }"); 231AssertType(a5, "{ fn(Base): void; }"); 232 233let r1b6 = b6 < a6; 234AssertType(r1b6, "boolean"); 235AssertType(b6 < a6, "boolean"); 236AssertType(b6, "{ fn(Base, Derived): void; }"); 237AssertType(a6, "{ fn(Derived, Base): void; }"); 238 239let r1b7 = b7 < a7; 240AssertType(r1b7, "boolean"); 241AssertType(b7 < a7, "boolean"); 242AssertType(b7, "{ fn(): Base; }"); 243AssertType(a7, "{ fn(): void; }"); 244 245let r1b8 = b8 < a8; 246AssertType(r1b8, "boolean"); 247AssertType(b8 < a8, "boolean"); 248AssertType(b8, "{ fn(): Base; }"); 249AssertType(a8, "{ fn(): Base; }"); 250 251let r1b9 = b9 < a9; 252AssertType(r1b9, "boolean"); 253AssertType(b9 < a9, "boolean"); 254AssertType(b9, "{ fn(): Derived; }"); 255AssertType(a9, "{ fn(): Base; }"); 256 257let r1b10 = b10 < a10; 258AssertType(r1b10, "boolean"); 259AssertType(b10 < a10, "boolean"); 260AssertType(b10, "{ fn(?Derived): void; }"); 261AssertType(a10, "{ fn(?Base): void; }"); 262 263let r1b11 = b11 < a11; 264AssertType(r1b11, "boolean"); 265AssertType(b11 < a11, "boolean"); 266AssertType(b11, "{ fn(...Derived[]): void; }"); 267AssertType(a11, "{ fn(...Base[]): void; }"); 268 269// operator > 270let r2a1 = a1 > b1; 271AssertType(r2a1, "boolean"); 272AssertType(a1 > b1, "boolean"); 273AssertType(a1, "{ fn(): void; }"); 274AssertType(b1, "{ fn(): void; }"); 275 276let r2a2 = a2 > b2; 277AssertType(r2a2, "boolean"); 278AssertType(a2 > b2, "boolean"); 279AssertType(a2, "{ fn(number, string): void; }"); 280AssertType(b2, "{ fn(number, string): void; }"); 281 282let r2a3 = a3 > b3; 283AssertType(r2a3, "boolean"); 284AssertType(a3 > b3, "boolean"); 285AssertType(a3, "{ fn(number, string): void; }"); 286AssertType(b3, "{ fn(number): void; }"); 287 288let r2a4 = a4 > b4; 289AssertType(r2a4, "boolean"); 290AssertType(a4 > b4, "boolean"); 291AssertType(a4, "{ fn(number, string): void; }"); 292AssertType(b4, "{ fn(): void; }"); 293 294let r2a5 = a5 > b5; 295AssertType(r2a5, "boolean"); 296AssertType(a5 > b5, "boolean"); 297AssertType(a5, "{ fn(Base): void; }"); 298AssertType(b5, "{ fn(Derived): void; }"); 299 300let r2a6 = a6 > b6; 301AssertType(r2a6, "boolean"); 302AssertType(a6 > b6, "boolean"); 303AssertType(a6, "{ fn(Derived, Base): void; }"); 304AssertType(b6, "{ fn(Base, Derived): void; }"); 305 306let r2a7 = a7 > b7; 307AssertType(r2a7, "boolean"); 308AssertType(a7 > b7, "boolean"); 309AssertType(a7, "{ fn(): void; }"); 310AssertType(b7, "{ fn(): Base; }"); 311 312let r2a8 = a8 > b8; 313AssertType(r2a8, "boolean"); 314AssertType(a8 > b8, "boolean"); 315AssertType(a8, "{ fn(): Base; }"); 316AssertType(b8, "{ fn(): Base; }"); 317 318let r2a9 = a9 > b9; 319AssertType(r2a9, "boolean"); 320AssertType(a9 > b9, "boolean"); 321AssertType(a9, "{ fn(): Base; }"); 322AssertType(b9, "{ fn(): Derived; }"); 323 324let r2a10 = a10 > b10; 325AssertType(r2a10, "boolean"); 326AssertType(a10 > b10, "boolean"); 327AssertType(a10, "{ fn(?Base): void; }"); 328AssertType(b10, "{ fn(?Derived): void; }"); 329 330let r2a11 = a11 > b11; 331AssertType(r2a11, "boolean"); 332AssertType(a11 > b11, "boolean"); 333AssertType(a11, "{ fn(...Base[]): void; }"); 334AssertType(b11, "{ fn(...Derived[]): void; }"); 335 336let r2b1 = b1 > a1; 337AssertType(r2b1, "boolean"); 338AssertType(b1 > a1, "boolean"); 339AssertType(b1, "{ fn(): void; }"); 340AssertType(a1, "{ fn(): void; }"); 341 342let r2b2 = b2 > a2; 343AssertType(r2b2, "boolean"); 344AssertType(b2 > a2, "boolean"); 345AssertType(b2, "{ fn(number, string): void; }"); 346AssertType(a2, "{ fn(number, string): void; }"); 347 348let r2b3 = b3 > a3; 349AssertType(r2b3, "boolean"); 350AssertType(b3 > a3, "boolean"); 351AssertType(b3, "{ fn(number): void; }"); 352AssertType(a3, "{ fn(number, string): void; }"); 353 354let r2b4 = b4 > a4; 355AssertType(r2b4, "boolean"); 356AssertType(b4 > a4, "boolean"); 357AssertType(b4, "{ fn(): void; }"); 358AssertType(a4, "{ fn(number, string): void; }"); 359 360let r2b5 = b5 > a5; 361AssertType(r2b5, "boolean"); 362AssertType(b5 > a5, "boolean"); 363AssertType(b5, "{ fn(Derived): void; }"); 364AssertType(a5, "{ fn(Base): void; }"); 365 366let r2b6 = b6 > a6; 367AssertType(r2b6, "boolean"); 368AssertType(b6 > a6, "boolean"); 369AssertType(b6, "{ fn(Base, Derived): void; }"); 370AssertType(a6, "{ fn(Derived, Base): void; }"); 371 372let r2b7 = b7 > a7; 373AssertType(r2b7, "boolean"); 374AssertType(b7 > a7, "boolean"); 375AssertType(b7, "{ fn(): Base; }"); 376AssertType(a7, "{ fn(): void; }"); 377 378let r2b8 = b8 > a8; 379AssertType(r2b8, "boolean"); 380AssertType(b8 > a8, "boolean"); 381AssertType(b8, "{ fn(): Base; }"); 382AssertType(a8, "{ fn(): Base; }"); 383 384let r2b9 = b9 > a9; 385AssertType(r2b9, "boolean"); 386AssertType(b9 > a9, "boolean"); 387AssertType(b9, "{ fn(): Derived; }"); 388AssertType(a9, "{ fn(): Base; }"); 389 390let r2b10 = b10 > a10; 391AssertType(r2b10, "boolean"); 392AssertType(b10 > a10, "boolean"); 393AssertType(b10, "{ fn(?Derived): void; }"); 394AssertType(a10, "{ fn(?Base): void; }"); 395 396let r2b11 = b11 > a11; 397AssertType(r2b11, "boolean"); 398AssertType(b11 > a11, "boolean"); 399AssertType(b11, "{ fn(...Derived[]): void; }"); 400AssertType(a11, "{ fn(...Base[]): void; }"); 401 402// operator <= 403let r3a1 = a1 <= b1; 404AssertType(r3a1, "boolean"); 405AssertType(a1 <= b1, "boolean"); 406AssertType(a1, "{ fn(): void; }"); 407AssertType(b1, "{ fn(): void; }"); 408 409let r3a2 = a2 <= b2; 410AssertType(r3a2, "boolean"); 411AssertType(a2 <= b2, "boolean"); 412AssertType(a2, "{ fn(number, string): void; }"); 413AssertType(b2, "{ fn(number, string): void; }"); 414 415let r3a3 = a3 <= b3; 416AssertType(r3a3, "boolean"); 417AssertType(a3 <= b3, "boolean"); 418AssertType(a3, "{ fn(number, string): void; }"); 419AssertType(b3, "{ fn(number): void; }"); 420 421let r3a4 = a4 <= b4; 422AssertType(r3a4, "boolean"); 423AssertType(a4 <= b4, "boolean"); 424AssertType(a4, "{ fn(number, string): void; }"); 425AssertType(b4, "{ fn(): void; }"); 426 427let r3a5 = a5 <= b5; 428AssertType(r3a5, "boolean"); 429AssertType(a5 <= b5, "boolean"); 430AssertType(a5, "{ fn(Base): void; }"); 431AssertType(b5, "{ fn(Derived): void; }"); 432 433let r3a6 = a6 <= b6; 434AssertType(r3a6, "boolean"); 435AssertType(a6 <= b6, "boolean"); 436AssertType(a6, "{ fn(Derived, Base): void; }"); 437AssertType(b6, "{ fn(Base, Derived): void; }"); 438 439let r3a7 = a7 <= b7; 440AssertType(r3a7, "boolean"); 441AssertType(a7 <= b7, "boolean"); 442AssertType(a7, "{ fn(): void; }"); 443AssertType(b7, "{ fn(): Base; }"); 444 445let r3a8 = a8 <= b8; 446AssertType(r3a8, "boolean"); 447AssertType(a8 <= b8, "boolean"); 448AssertType(a8, "{ fn(): Base; }"); 449AssertType(b8, "{ fn(): Base; }"); 450 451let r3a9 = a9 <= b9; 452AssertType(r3a9, "boolean"); 453AssertType(a9 <= b9, "boolean"); 454AssertType(a9, "{ fn(): Base; }"); 455AssertType(b9, "{ fn(): Derived; }"); 456 457let r3a10 = a10 <= b10; 458AssertType(r3a10, "boolean"); 459AssertType(a10 <= b10, "boolean"); 460AssertType(a10, "{ fn(?Base): void; }"); 461AssertType(b10, "{ fn(?Derived): void; }"); 462 463let r3a11 = a11 <= b11; 464AssertType(r3a11, "boolean"); 465AssertType(a11 <= b11, "boolean"); 466AssertType(a11, "{ fn(...Base[]): void; }"); 467AssertType(b11, "{ fn(...Derived[]): void; }"); 468 469//let r3a12 = a12 <= b12; 470 471let r3b1 = b1 <= a1; 472AssertType(r3b1, "boolean"); 473AssertType(b1 <= a1, "boolean"); 474AssertType(b1, "{ fn(): void; }"); 475AssertType(a1, "{ fn(): void; }"); 476 477let r3b2 = b2 <= a2; 478AssertType(r3b2, "boolean"); 479AssertType(b2 <= a2, "boolean"); 480AssertType(b2, "{ fn(number, string): void; }"); 481AssertType(a2, "{ fn(number, string): void; }"); 482 483let r3b3 = b3 <= a3; 484AssertType(r3b3, "boolean"); 485AssertType(b3 <= a3, "boolean"); 486AssertType(b3, "{ fn(number): void; }"); 487AssertType(a3, "{ fn(number, string): void; }"); 488 489let r3b4 = b4 <= a4; 490AssertType(r3b4, "boolean"); 491AssertType(b4 <= a4, "boolean"); 492AssertType(b4, "{ fn(): void; }"); 493AssertType(a4, "{ fn(number, string): void; }"); 494 495let r3b5 = b5 <= a5; 496AssertType(r3b5, "boolean"); 497AssertType(b5 <= a5, "boolean"); 498AssertType(b5, "{ fn(Derived): void; }"); 499AssertType(a5, "{ fn(Base): void; }"); 500 501let r3b6 = b6 <= a6; 502AssertType(r3b6, "boolean"); 503AssertType(b6 <= a6, "boolean"); 504AssertType(b6, "{ fn(Base, Derived): void; }"); 505AssertType(a6, "{ fn(Derived, Base): void; }"); 506 507let r3b7 = b7 <= a7; 508AssertType(r3b7, "boolean"); 509AssertType(b7 <= a7, "boolean"); 510AssertType(b7, "{ fn(): Base; }"); 511AssertType(a7, "{ fn(): void; }"); 512 513let r3b8 = b8 <= a8; 514AssertType(r3b8, "boolean"); 515AssertType(b8 <= a8, "boolean"); 516AssertType(b8, "{ fn(): Base; }"); 517AssertType(a8, "{ fn(): Base; }"); 518 519let r3b9 = b9 <= a9; 520AssertType(r3b9, "boolean"); 521AssertType(b9 <= a9, "boolean"); 522AssertType(b9, "{ fn(): Derived; }"); 523AssertType(a9, "{ fn(): Base; }"); 524 525let r3b10 = b10 <= a10; 526AssertType(r3b10, "boolean"); 527AssertType(b10 <= a10, "boolean"); 528AssertType(b10, "{ fn(?Derived): void; }"); 529AssertType(a10, "{ fn(?Base): void; }"); 530 531let r3b11 = b11 <= a11; 532AssertType(r3b11, "boolean"); 533AssertType(b11 <= a11, "boolean"); 534AssertType(b11, "{ fn(...Derived[]): void; }"); 535AssertType(a11, "{ fn(...Base[]): void; }"); 536 537//let r3b12 = b12 <= a12; 538 539// operator >= 540let r4a1 = a1 >= b1; 541AssertType(r4a1, "boolean"); 542AssertType(a1 >= b1, "boolean"); 543AssertType(a1, "{ fn(): void; }"); 544AssertType(b1, "{ fn(): void; }"); 545 546let r4a2 = a2 >= b2; 547AssertType(r4a2, "boolean"); 548AssertType(a2 >= b2, "boolean"); 549AssertType(a2, "{ fn(number, string): void; }"); 550AssertType(b2, "{ fn(number, string): void; }"); 551 552let r4a3 = a3 >= b3; 553AssertType(r4a3, "boolean"); 554AssertType(a3 >= b3, "boolean"); 555AssertType(a3, "{ fn(number, string): void; }"); 556AssertType(b3, "{ fn(number): void; }"); 557 558let r4a4 = a4 >= b4; 559AssertType(r4a4, "boolean"); 560AssertType(a4 >= b4, "boolean"); 561AssertType(a4, "{ fn(number, string): void; }"); 562AssertType(b4, "{ fn(): void; }"); 563 564let r4a5 = a5 >= b5; 565AssertType(r4a5, "boolean"); 566AssertType(a5 >= b5, "boolean"); 567AssertType(a5, "{ fn(Base): void; }"); 568AssertType(b5, "{ fn(Derived): void; }"); 569 570let r4a6 = a6 >= b6; 571AssertType(r4a6, "boolean"); 572AssertType(a6 >= b6, "boolean"); 573AssertType(a6, "{ fn(Derived, Base): void; }"); 574AssertType(b6, "{ fn(Base, Derived): void; }"); 575 576let r4a7 = a7 >= b7; 577AssertType(r4a7, "boolean"); 578AssertType(a7 >= b7, "boolean"); 579AssertType(a7, "{ fn(): void; }"); 580AssertType(b7, "{ fn(): Base; }"); 581 582let r4a8 = a8 >= b8; 583AssertType(r4a8, "boolean"); 584AssertType(a8 >= b8, "boolean"); 585AssertType(a8, "{ fn(): Base; }"); 586AssertType(b8, "{ fn(): Base; }"); 587 588let r4a9 = a9 >= b9; 589AssertType(r4a9, "boolean"); 590AssertType(a9 >= b9, "boolean"); 591AssertType(a9, "{ fn(): Base; }"); 592AssertType(b9, "{ fn(): Derived; }"); 593 594let r4a10 = a10 >= b10; 595AssertType(r4a10, "boolean"); 596AssertType(a10 >= b10, "boolean"); 597AssertType(a10, "{ fn(?Base): void; }"); 598AssertType(b10, "{ fn(?Derived): void; }"); 599 600let r4a11 = a11 >= b11; 601AssertType(r4a11, "boolean"); 602AssertType(a11 >= b11, "boolean"); 603AssertType(a11, "{ fn(...Base[]): void; }"); 604AssertType(b11, "{ fn(...Derived[]): void; }"); 605 606//let r4a12 = a12 >= b12; 607 608let r4b1 = b1 >= a1; 609AssertType(r4b1, "boolean"); 610AssertType(b1 >= a1, "boolean"); 611AssertType(b1, "{ fn(): void; }"); 612AssertType(a1, "{ fn(): void; }"); 613 614let r4b2 = b2 >= a2; 615AssertType(r4b2, "boolean"); 616AssertType(b2 >= a2, "boolean"); 617AssertType(b2, "{ fn(number, string): void; }"); 618AssertType(a2, "{ fn(number, string): void; }"); 619 620let r4b3 = b3 >= a3; 621AssertType(r4b3, "boolean"); 622AssertType(b3 >= a3, "boolean"); 623AssertType(b3, "{ fn(number): void; }"); 624AssertType(a3, "{ fn(number, string): void; }"); 625 626let r4b4 = b4 >= a4; 627AssertType(r4b4, "boolean"); 628AssertType(b4 >= a4, "boolean"); 629AssertType(b4, "{ fn(): void; }"); 630AssertType(a4, "{ fn(number, string): void; }"); 631 632let r4b5 = b5 >= a5; 633AssertType(r4b5, "boolean"); 634AssertType(b5 >= a5, "boolean"); 635AssertType(b5, "{ fn(Derived): void; }"); 636AssertType(a5, "{ fn(Base): void; }"); 637 638let r4b6 = b6 >= a6; 639AssertType(r4b6, "boolean"); 640AssertType(b6 >= a6, "boolean"); 641AssertType(b6, "{ fn(Base, Derived): void; }"); 642AssertType(a6, "{ fn(Derived, Base): void; }"); 643 644let r4b7 = b7 >= a7; 645AssertType(r4b7, "boolean"); 646AssertType(b7 >= a7, "boolean"); 647AssertType(b7, "{ fn(): Base; }"); 648AssertType(a7, "{ fn(): void; }"); 649 650let r4b8 = b8 >= a8; 651AssertType(r4b8, "boolean"); 652AssertType(b8 >= a8, "boolean"); 653AssertType(b8, "{ fn(): Base; }"); 654AssertType(a8, "{ fn(): Base; }"); 655 656let r4b9 = b9 >= a9; 657AssertType(r4b9, "boolean"); 658AssertType(b9 >= a9, "boolean"); 659AssertType(b9, "{ fn(): Derived; }"); 660AssertType(a9, "{ fn(): Base; }"); 661 662let r4b10 = b10 >= a10; 663AssertType(r4b10, "boolean"); 664AssertType(b10 >= a10, "boolean"); 665AssertType(b10, "{ fn(?Derived): void; }"); 666AssertType(a10, "{ fn(?Base): void; }"); 667 668let r4b11 = b11 >= a11; 669AssertType(r4b11, "boolean"); 670AssertType(b11 >= a11, "boolean"); 671AssertType(b11, "{ fn(...Derived[]): void; }"); 672AssertType(a11, "{ fn(...Base[]): void; }"); 673 674//let r4b12 = b12 >= a12; 675 676// operator == 677let r5a1 = a1 == b1; 678AssertType(r5a1, "boolean"); 679AssertType(a1 == b1, "boolean"); 680AssertType(a1, "{ fn(): void; }"); 681AssertType(b1, "{ fn(): void; }"); 682 683let r5a2 = a2 == b2; 684AssertType(r5a2, "boolean"); 685AssertType(a2 == b2, "boolean"); 686AssertType(a2, "{ fn(number, string): void; }"); 687AssertType(b2, "{ fn(number, string): void; }"); 688 689let r5a3 = a3 == b3; 690AssertType(r5a3, "boolean"); 691AssertType(a3 == b3, "boolean"); 692AssertType(a3, "{ fn(number, string): void; }"); 693AssertType(b3, "{ fn(number): void; }"); 694 695let r5a4 = a4 == b4; 696AssertType(r5a4, "boolean"); 697AssertType(a4 == b4, "boolean"); 698AssertType(a4, "{ fn(number, string): void; }"); 699AssertType(b4, "{ fn(): void; }"); 700 701let r5a5 = a5 == b5; 702AssertType(r5a5, "boolean"); 703AssertType(a5 == b5, "boolean"); 704AssertType(a5, "{ fn(Base): void; }"); 705AssertType(b5, "{ fn(Derived): void; }"); 706 707let r5a6 = a6 == b6; 708AssertType(r5a6, "boolean"); 709AssertType(a6 == b6, "boolean"); 710AssertType(a6, "{ fn(Derived, Base): void; }"); 711AssertType(b6, "{ fn(Base, Derived): void; }"); 712 713let r5a7 = a7 == b7; 714AssertType(r5a7, "boolean"); 715AssertType(a7 == b7, "boolean"); 716AssertType(a7, "{ fn(): void; }"); 717AssertType(b7, "{ fn(): Base; }"); 718 719let r5a8 = a8 == b8; 720AssertType(r5a8, "boolean"); 721AssertType(a8 == b8, "boolean"); 722AssertType(a8, "{ fn(): Base; }"); 723AssertType(b8, "{ fn(): Base; }"); 724 725let r5a9 = a9 == b9; 726AssertType(r5a9, "boolean"); 727AssertType(a9 == b9, "boolean"); 728AssertType(a9, "{ fn(): Base; }"); 729AssertType(b9, "{ fn(): Derived; }"); 730 731let r5a10 = a10 == b10; 732AssertType(r5a10, "boolean"); 733AssertType(a10 == b10, "boolean"); 734AssertType(a10, "{ fn(?Base): void; }"); 735AssertType(b10, "{ fn(?Derived): void; }"); 736 737let r5a11 = a11 == b11; 738AssertType(r5a11, "boolean"); 739AssertType(a11 == b11, "boolean"); 740AssertType(a11, "{ fn(...Base[]): void; }"); 741AssertType(b11, "{ fn(...Derived[]): void; }"); 742 743//let r5a12 = a12 == b12; 744 745let r5b1 = b1 == a1; 746AssertType(r5b1, "boolean"); 747AssertType(b1 == a1, "boolean"); 748AssertType(b1, "{ fn(): void; }"); 749AssertType(a1, "{ fn(): void; }"); 750 751let r5b2 = b2 == a2; 752AssertType(r5b2, "boolean"); 753AssertType(b2 == a2, "boolean"); 754AssertType(b2, "{ fn(number, string): void; }"); 755AssertType(a2, "{ fn(number, string): void; }"); 756 757let r5b3 = b3 == a3; 758AssertType(r5b3, "boolean"); 759AssertType(b3 == a3, "boolean"); 760AssertType(b3, "{ fn(number): void; }"); 761AssertType(a3, "{ fn(number, string): void; }"); 762 763let r5b4 = b4 == a4; 764AssertType(r5b4, "boolean"); 765AssertType(b4 == a4, "boolean"); 766AssertType(b4, "{ fn(): void; }"); 767AssertType(a4, "{ fn(number, string): void; }"); 768 769let r5b5 = b5 == a5; 770AssertType(r5b5, "boolean"); 771AssertType(b5 == a5, "boolean"); 772AssertType(b5, "{ fn(Derived): void; }"); 773AssertType(a5, "{ fn(Base): void; }"); 774 775let r5b6 = b6 == a6; 776AssertType(r5b6, "boolean"); 777AssertType(b6 == a6, "boolean"); 778AssertType(b6, "{ fn(Base, Derived): void; }"); 779AssertType(a6, "{ fn(Derived, Base): void; }"); 780 781let r5b7 = b7 == a7; 782AssertType(r5b7, "boolean"); 783AssertType(b7 == a7, "boolean"); 784AssertType(b7, "{ fn(): Base; }"); 785AssertType(a7, "{ fn(): void; }"); 786 787let r5b8 = b8 == a8; 788AssertType(r5b8, "boolean"); 789AssertType(b8 == a8, "boolean"); 790AssertType(b8, "{ fn(): Base; }"); 791AssertType(a8, "{ fn(): Base; }"); 792 793let r5b9 = b9 == a9; 794AssertType(r5b9, "boolean"); 795AssertType(b9 == a9, "boolean"); 796AssertType(b9, "{ fn(): Derived; }"); 797AssertType(a9, "{ fn(): Base; }"); 798 799let r5b10 = b10 == a10; 800AssertType(r5b10, "boolean"); 801AssertType(b10 == a10, "boolean"); 802AssertType(b10, "{ fn(?Derived): void; }"); 803AssertType(a10, "{ fn(?Base): void; }"); 804 805let r5b11 = b11 == a11; 806AssertType(r5b11, "boolean"); 807AssertType(b11 == a11, "boolean"); 808AssertType(b11, "{ fn(...Derived[]): void; }"); 809AssertType(a11, "{ fn(...Base[]): void; }"); 810 811//let r5b12 = b12 == a12; 812 813// operator != 814let r6a1 = a1 != b1; 815AssertType(r6a1, "boolean"); 816AssertType(a1 != b1, "boolean"); 817AssertType(a1, "{ fn(): void; }"); 818AssertType(b1, "{ fn(): void; }"); 819 820let r6a2 = a2 != b2; 821AssertType(r6a2, "boolean"); 822AssertType(a2 != b2, "boolean"); 823AssertType(a2, "{ fn(number, string): void; }"); 824AssertType(b2, "{ fn(number, string): void; }"); 825 826let r6a3 = a3 != b3; 827AssertType(r6a3, "boolean"); 828AssertType(a3 != b3, "boolean"); 829AssertType(a3, "{ fn(number, string): void; }"); 830AssertType(b3, "{ fn(number): void; }"); 831 832let r6a4 = a4 != b4; 833AssertType(r6a4, "boolean"); 834AssertType(a4 != b4, "boolean"); 835AssertType(a4, "{ fn(number, string): void; }"); 836AssertType(b4, "{ fn(): void; }"); 837 838let r6a5 = a5 != b5; 839AssertType(r6a5, "boolean"); 840AssertType(a5 != b5, "boolean"); 841AssertType(a5, "{ fn(Base): void; }"); 842AssertType(b5, "{ fn(Derived): void; }"); 843 844let r6a6 = a6 != b6; 845AssertType(r6a6, "boolean"); 846AssertType(a6 != b6, "boolean"); 847AssertType(a6, "{ fn(Derived, Base): void; }"); 848AssertType(b6, "{ fn(Base, Derived): void; }"); 849 850let r6a7 = a7 != b7; 851AssertType(r6a7, "boolean"); 852AssertType(a7 != b7, "boolean"); 853AssertType(a7, "{ fn(): void; }"); 854AssertType(b7, "{ fn(): Base; }"); 855 856let r6a8 = a8 != b8; 857AssertType(r6a8, "boolean"); 858AssertType(a8 != b8, "boolean"); 859AssertType(a8, "{ fn(): Base; }"); 860AssertType(b8, "{ fn(): Base; }"); 861 862let r6a9 = a9 != b9; 863AssertType(r6a9, "boolean"); 864AssertType(a9 != b9, "boolean"); 865AssertType(a9, "{ fn(): Base; }"); 866AssertType(b9, "{ fn(): Derived; }"); 867 868let r6a10 = a10 != b10; 869AssertType(r6a10, "boolean"); 870AssertType(a10 != b10, "boolean"); 871AssertType(a10, "{ fn(?Base): void; }"); 872AssertType(b10, "{ fn(?Derived): void; }"); 873 874let r6a11 = a11 != b11; 875AssertType(r6a11, "boolean"); 876AssertType(a11 != b11, "boolean"); 877AssertType(a11, "{ fn(...Base[]): void; }"); 878AssertType(b11, "{ fn(...Derived[]): void; }"); 879 880//let r6a12 = a12 != b12; 881 882let r6b1 = b1 != a1; 883AssertType(r6b1, "boolean"); 884AssertType(b1 != a1, "boolean"); 885AssertType(b1, "{ fn(): void; }"); 886AssertType(a1, "{ fn(): void; }"); 887 888let r6b2 = b2 != a2; 889AssertType(r6b2, "boolean"); 890AssertType(b2 != a2, "boolean"); 891AssertType(b2, "{ fn(number, string): void; }"); 892AssertType(a2, "{ fn(number, string): void; }"); 893 894let r6b3 = b3 != a3; 895AssertType(r6b3, "boolean"); 896AssertType(b3 != a3, "boolean"); 897AssertType(b3, "{ fn(number): void; }"); 898AssertType(a3, "{ fn(number, string): void; }"); 899 900let r6b4 = b4 != a4; 901AssertType(r6b4, "boolean"); 902AssertType(b4 != a4, "boolean"); 903AssertType(b4, "{ fn(): void; }"); 904AssertType(a4, "{ fn(number, string): void; }"); 905 906let r6b5 = b5 != a5; 907AssertType(r6b5, "boolean"); 908AssertType(b5 != a5, "boolean"); 909AssertType(b5, "{ fn(Derived): void; }"); 910AssertType(a5, "{ fn(Base): void; }"); 911 912let r6b6 = b6 != a6; 913AssertType(r6b6, "boolean"); 914AssertType(b6 != a6, "boolean"); 915AssertType(b6, "{ fn(Base, Derived): void; }"); 916AssertType(a6, "{ fn(Derived, Base): void; }"); 917 918let r6b7 = b7 != a7; 919AssertType(r6b7, "boolean"); 920AssertType(b7 != a7, "boolean"); 921AssertType(b7, "{ fn(): Base; }"); 922AssertType(a7, "{ fn(): void; }"); 923 924let r6b8 = b8 != a8; 925AssertType(r6b8, "boolean"); 926AssertType(b8 != a8, "boolean"); 927AssertType(b8, "{ fn(): Base; }"); 928AssertType(a8, "{ fn(): Base; }"); 929 930let r6b9 = b9 != a9; 931AssertType(r6b9, "boolean"); 932AssertType(b9 != a9, "boolean"); 933AssertType(b9, "{ fn(): Derived; }"); 934AssertType(a9, "{ fn(): Base; }"); 935 936let r6b10 = b10 != a10; 937AssertType(r6b10, "boolean"); 938AssertType(b10 != a10, "boolean"); 939AssertType(b10, "{ fn(?Derived): void; }"); 940AssertType(a10, "{ fn(?Base): void; }"); 941 942let r6b11 = b11 != a11; 943AssertType(r6b11, "boolean"); 944AssertType(b11 != a11, "boolean"); 945AssertType(b11, "{ fn(...Derived[]): void; }"); 946AssertType(a11, "{ fn(...Base[]): void; }"); 947 948//let r6b12 = b12 != a12; 949 950// operator === 951let r7a1 = a1 === b1; 952AssertType(r7a1, "boolean"); 953AssertType(a1 === b1, "boolean"); 954AssertType(a1, "{ fn(): void; }"); 955AssertType(b1, "{ fn(): void; }"); 956 957let r7a2 = a2 === b2; 958AssertType(r7a2, "boolean"); 959AssertType(a2 === b2, "boolean"); 960AssertType(a2, "{ fn(number, string): void; }"); 961AssertType(b2, "{ fn(number, string): void; }"); 962 963let r7a3 = a3 === b3; 964AssertType(r7a3, "boolean"); 965AssertType(a3 === b3, "boolean"); 966AssertType(a3, "{ fn(number, string): void; }"); 967AssertType(b3, "{ fn(number): void; }"); 968 969let r7a4 = a4 === b4; 970AssertType(r7a4, "boolean"); 971AssertType(a4 === b4, "boolean"); 972AssertType(a4, "{ fn(number, string): void; }"); 973AssertType(b4, "{ fn(): void; }"); 974 975let r7a5 = a5 === b5; 976AssertType(r7a5, "boolean"); 977AssertType(a5 === b5, "boolean"); 978AssertType(a5, "{ fn(Base): void; }"); 979AssertType(b5, "{ fn(Derived): void; }"); 980 981let r7a6 = a6 === b6; 982AssertType(r7a6, "boolean"); 983AssertType(a6 === b6, "boolean"); 984AssertType(a6, "{ fn(Derived, Base): void; }"); 985AssertType(b6, "{ fn(Base, Derived): void; }"); 986 987let r7a7 = a7 === b7; 988AssertType(r7a7, "boolean"); 989AssertType(a7 === b7, "boolean"); 990AssertType(a7, "{ fn(): void; }"); 991AssertType(b7, "{ fn(): Base; }"); 992 993let r7a8 = a8 === b8; 994AssertType(r7a8, "boolean"); 995AssertType(a8 === b8, "boolean"); 996AssertType(a8, "{ fn(): Base; }"); 997AssertType(b8, "{ fn(): Base; }"); 998 999let r7a9 = a9 === b9; 1000AssertType(r7a9, "boolean"); 1001AssertType(a9 === b9, "boolean"); 1002AssertType(a9, "{ fn(): Base; }"); 1003AssertType(b9, "{ fn(): Derived; }"); 1004 1005let r7a10 = a10 === b10; 1006AssertType(r7a10, "boolean"); 1007AssertType(a10 === b10, "boolean"); 1008AssertType(a10, "{ fn(?Base): void; }"); 1009AssertType(b10, "{ fn(?Derived): void; }"); 1010 1011let r7a11 = a11 === b11; 1012AssertType(r7a11, "boolean"); 1013AssertType(a11 === b11, "boolean"); 1014AssertType(a11, "{ fn(...Base[]): void; }"); 1015AssertType(b11, "{ fn(...Derived[]): void; }"); 1016 1017//let r7a12 = a12 === b12; 1018 1019let r7b1 = b1 === a1; 1020AssertType(r7b1, "boolean"); 1021AssertType(b1 === a1, "boolean"); 1022AssertType(b1, "{ fn(): void; }"); 1023AssertType(a1, "{ fn(): void; }"); 1024 1025let r7b2 = b2 === a2; 1026AssertType(r7b2, "boolean"); 1027AssertType(b2 === a2, "boolean"); 1028AssertType(b2, "{ fn(number, string): void; }"); 1029AssertType(a2, "{ fn(number, string): void; }"); 1030 1031let r7b3 = b3 === a3; 1032AssertType(r7b3, "boolean"); 1033AssertType(b3 === a3, "boolean"); 1034AssertType(b3, "{ fn(number): void; }"); 1035AssertType(a3, "{ fn(number, string): void; }"); 1036 1037let r7b4 = b4 === a4; 1038AssertType(r7b4, "boolean"); 1039AssertType(b4 === a4, "boolean"); 1040AssertType(b4, "{ fn(): void; }"); 1041AssertType(a4, "{ fn(number, string): void; }"); 1042 1043let r7b5 = b5 === a5; 1044AssertType(r7b5, "boolean"); 1045AssertType(b5 === a5, "boolean"); 1046AssertType(b5, "{ fn(Derived): void; }"); 1047AssertType(a5, "{ fn(Base): void; }"); 1048 1049let r7b6 = b6 === a6; 1050AssertType(r7b6, "boolean"); 1051AssertType(b6 === a6, "boolean"); 1052AssertType(b6, "{ fn(Base, Derived): void; }"); 1053AssertType(a6, "{ fn(Derived, Base): void; }"); 1054 1055let r7b7 = b7 === a7; 1056AssertType(r7b7, "boolean"); 1057AssertType(b7 === a7, "boolean"); 1058AssertType(b7, "{ fn(): Base; }"); 1059AssertType(a7, "{ fn(): void; }"); 1060 1061let r7b8 = b8 === a8; 1062AssertType(r7b8, "boolean"); 1063AssertType(b8 === a8, "boolean"); 1064AssertType(b8, "{ fn(): Base; }"); 1065AssertType(a8, "{ fn(): Base; }"); 1066 1067let r7b9 = b9 === a9; 1068AssertType(r7b9, "boolean"); 1069AssertType(b9 === a9, "boolean"); 1070AssertType(b9, "{ fn(): Derived; }"); 1071AssertType(a9, "{ fn(): Base; }"); 1072 1073let r7b10 = b10 === a10; 1074AssertType(r7b10, "boolean"); 1075AssertType(b10 === a10, "boolean"); 1076AssertType(b10, "{ fn(?Derived): void; }"); 1077AssertType(a10, "{ fn(?Base): void; }"); 1078 1079let r7b11 = b11 === a11; 1080AssertType(r7b11, "boolean"); 1081AssertType(b11 === a11, "boolean"); 1082AssertType(b11, "{ fn(...Derived[]): void; }"); 1083AssertType(a11, "{ fn(...Base[]): void; }"); 1084 1085//let r7b12 = b12 === a12; 1086 1087// operator !== 1088let r8a1 = a1 !== b1; 1089AssertType(r8a1, "boolean"); 1090AssertType(a1 !== b1, "boolean"); 1091AssertType(a1, "{ fn(): void; }"); 1092AssertType(b1, "{ fn(): void; }"); 1093 1094let r8a2 = a2 !== b2; 1095AssertType(r8a2, "boolean"); 1096AssertType(a2 !== b2, "boolean"); 1097AssertType(a2, "{ fn(number, string): void; }"); 1098AssertType(b2, "{ fn(number, string): void; }"); 1099 1100let r8a3 = a3 !== b3; 1101AssertType(r8a3, "boolean"); 1102AssertType(a3 !== b3, "boolean"); 1103AssertType(a3, "{ fn(number, string): void; }"); 1104AssertType(b3, "{ fn(number): void; }"); 1105 1106let r8a4 = a4 !== b4; 1107AssertType(r8a4, "boolean"); 1108AssertType(a4 !== b4, "boolean"); 1109AssertType(a4, "{ fn(number, string): void; }"); 1110AssertType(b4, "{ fn(): void; }"); 1111 1112let r8a5 = a5 !== b5; 1113AssertType(r8a5, "boolean"); 1114AssertType(a5 !== b5, "boolean"); 1115AssertType(a5, "{ fn(Base): void; }"); 1116AssertType(b5, "{ fn(Derived): void; }"); 1117 1118let r8a6 = a6 !== b6; 1119AssertType(r8a6, "boolean"); 1120AssertType(a6 !== b6, "boolean"); 1121AssertType(a6, "{ fn(Derived, Base): void; }"); 1122AssertType(b6, "{ fn(Base, Derived): void; }"); 1123 1124let r8a7 = a7 !== b7; 1125AssertType(r8a7, "boolean"); 1126AssertType(a7 !== b7, "boolean"); 1127AssertType(a7, "{ fn(): void; }"); 1128AssertType(b7, "{ fn(): Base; }"); 1129 1130let r8a8 = a8 !== b8; 1131AssertType(r8a8, "boolean"); 1132AssertType(a8 !== b8, "boolean"); 1133AssertType(a8, "{ fn(): Base; }"); 1134AssertType(b8, "{ fn(): Base; }"); 1135 1136let r8a9 = a9 !== b9; 1137AssertType(r8a9, "boolean"); 1138AssertType(a9 !== b9, "boolean"); 1139AssertType(a9, "{ fn(): Base; }"); 1140AssertType(b9, "{ fn(): Derived; }"); 1141 1142let r8a10 = a10 !== b10; 1143AssertType(r8a10, "boolean"); 1144AssertType(a10 !== b10, "boolean"); 1145AssertType(a10, "{ fn(?Base): void; }"); 1146AssertType(b10, "{ fn(?Derived): void; }"); 1147 1148let r8a11 = a11 !== b11; 1149AssertType(r8a11, "boolean"); 1150AssertType(a11 !== b11, "boolean"); 1151AssertType(a11, "{ fn(...Base[]): void; }"); 1152AssertType(b11, "{ fn(...Derived[]): void; }"); 1153 1154//let r8a12 = a12 !== b12; 1155 1156let r8b1 = b1 !== a1; 1157AssertType(r8b1, "boolean"); 1158AssertType(b1 !== a1, "boolean"); 1159AssertType(b1, "{ fn(): void; }"); 1160AssertType(a1, "{ fn(): void; }"); 1161 1162let r8b2 = b2 !== a2; 1163AssertType(r8b2, "boolean"); 1164AssertType(b2 !== a2, "boolean"); 1165AssertType(b2, "{ fn(number, string): void; }"); 1166AssertType(a2, "{ fn(number, string): void; }"); 1167 1168let r8b3 = b3 !== a3; 1169AssertType(r8b3, "boolean"); 1170AssertType(b3 !== a3, "boolean"); 1171AssertType(b3, "{ fn(number): void; }"); 1172AssertType(a3, "{ fn(number, string): void; }"); 1173 1174let r8b4 = b4 !== a4; 1175AssertType(r8b4, "boolean"); 1176AssertType(b4 !== a4, "boolean"); 1177AssertType(b4, "{ fn(): void; }"); 1178AssertType(a4, "{ fn(number, string): void; }"); 1179 1180let r8b5 = b5 !== a5; 1181AssertType(r8b5, "boolean"); 1182AssertType(b5 !== a5, "boolean"); 1183AssertType(b5, "{ fn(Derived): void; }"); 1184AssertType(a5, "{ fn(Base): void; }"); 1185 1186let r8b6 = b6 !== a6; 1187AssertType(r8b6, "boolean"); 1188AssertType(b6 !== a6, "boolean"); 1189AssertType(b6, "{ fn(Base, Derived): void; }"); 1190AssertType(a6, "{ fn(Derived, Base): void; }"); 1191 1192let r8b7 = b7 !== a7; 1193AssertType(r8b7, "boolean"); 1194AssertType(b7 !== a7, "boolean"); 1195AssertType(b7, "{ fn(): Base; }"); 1196AssertType(a7, "{ fn(): void; }"); 1197 1198let r8b8 = b8 !== a8; 1199AssertType(r8b8, "boolean"); 1200AssertType(b8 !== a8, "boolean"); 1201AssertType(b8, "{ fn(): Base; }"); 1202AssertType(a8, "{ fn(): Base; }"); 1203 1204let r8b9 = b9 !== a9; 1205AssertType(r8b9, "boolean"); 1206AssertType(b9 !== a9, "boolean"); 1207AssertType(b9, "{ fn(): Derived; }"); 1208AssertType(a9, "{ fn(): Base; }"); 1209 1210let r8b10 = b10 !== a10; 1211AssertType(r8b10, "boolean"); 1212AssertType(b10 !== a10, "boolean"); 1213AssertType(b10, "{ fn(?Derived): void; }"); 1214AssertType(a10, "{ fn(?Base): void; }"); 1215 1216let r8b11 = b11 !== a11; 1217AssertType(r8b11, "boolean"); 1218AssertType(b11 !== a11, "boolean"); 1219AssertType(b11, "{ fn(...Derived[]): void; }"); 1220AssertType(a11, "{ fn(...Base[]): void; }"); 1221 1222//let r8b12 = b12 !== a12; 1223 1224