BCT candidates=25

// Best Common Type (BCT) O(N²) stress test
// Targets: infer.rs best_common_type() — N candidates × N subtype checks
//
// Each class in the hierarchy is a distinct type candidate. When the compiler
// infers the type of an array literal or multi-return function, it must find
// the "best common type" by checking every candidate against every other.

class Base { base: string = ''; }
class Derived0 extends Base { prop0: number = 0; }
class Derived1 extends Base { prop1: number = 1; }
class Derived2 extends Base { prop2: number = 2; }
class Derived3 extends Base { prop3: number = 3; }
class Derived4 extends Base { prop4: number = 4; }
class Derived5 extends Base { prop5: number = 5; }
class Derived6 extends Base { prop6: number = 6; }
class Derived7 extends Base { prop7: number = 7; }
class Derived8 extends Base { prop8: number = 8; }
class Derived9 extends Base { prop9: number = 9; }
class Derived10 extends Base { prop10: number = 10; }
class Derived11 extends Base { prop11: number = 11; }
class Derived12 extends Base { prop12: number = 12; }
class Derived13 extends Base { prop13: number = 13; }
class Derived14 extends Base { prop14: number = 14; }
class Derived15 extends Base { prop15: number = 15; }
class Derived16 extends Base { prop16: number = 16; }
class Derived17 extends Base { prop17: number = 17; }
class Derived18 extends Base { prop18: number = 18; }
class Derived19 extends Base { prop19: number = 19; }
class Derived20 extends Base { prop20: number = 20; }
class Derived21 extends Base { prop21: number = 21; }
class Derived22 extends Base { prop22: number = 22; }
class Derived23 extends Base { prop23: number = 23; }
class Derived24 extends Base { prop24: number = 24; }

// Array literal: BCT must find common type among 25 candidates
const items = [new Derived0(), new Derived1(), new Derived2(), new Derived3(), new Derived4(), new Derived5(), new Derived6(), new Derived7(), new Derived8(), new Derived9(), new Derived10(), new Derived11(), new Derived12(), new Derived13(), new Derived14(), new Derived15(), new Derived16(), new Derived17(), new Derived18(), new Derived19(), new Derived20(), new Derived21(), new Derived22(), new Derived23(), new Derived24()];

// Function with 25 return branches — BCT on return type inference
function pickOne(index: number) {
    if (index === 0) return new Derived0();
    if (index === 1) return new Derived1();
    if (index === 2) return new Derived2();
    if (index === 3) return new Derived3();
    if (index === 4) return new Derived4();
    if (index === 5) return new Derived5();
    if (index === 6) return new Derived6();
    if (index === 7) return new Derived7();
    if (index === 8) return new Derived8();
    if (index === 9) return new Derived9();
    if (index === 10) return new Derived10();
    if (index === 11) return new Derived11();
    if (index === 12) return new Derived12();
    if (index === 13) return new Derived13();
    if (index === 14) return new Derived14();
    if (index === 15) return new Derived15();
    if (index === 16) return new Derived16();
    if (index === 17) return new Derived17();
    if (index === 18) return new Derived18();
    if (index === 19) return new Derived19();
    if (index === 20) return new Derived20();
    if (index === 21) return new Derived21();
    if (index === 22) return new Derived22();
    if (index === 23) return new Derived23();
    if (index === 24) return new Derived24();
    return new Base();
}

// Generic calls accumulating 25 candidates
function identity<T>(x: T): T { return x; }
const mixed = [identity(new Derived0()), identity(new Derived1()), identity(new Derived2()), identity(new Derived3()), identity(new Derived4()), identity(new Derived5()), identity(new Derived6()), identity(new Derived7()), identity(new Derived8()), identity(new Derived9()), identity(new Derived10()), identity(new Derived11()), identity(new Derived12()), identity(new Derived13()), identity(new Derived14()), identity(new Derived15()), identity(new Derived16()), identity(new Derived17()), identity(new Derived18()), identity(new Derived19()), identity(new Derived20()), identity(new Derived21()), identity(new Derived22()), identity(new Derived23()), identity(new Derived24())];

// Ternary chain: 25 candidates for common type
declare const flag: number;
const chosen = flag === 0 ? new Derived0() : flag === 1 ? new Derived1() : flag === 2 ? new Derived2() : flag === 3 ? new Derived3() : flag === 4 ? new Derived4() : flag === 5 ? new Derived5() : flag === 6 ? new Derived6() : flag === 7 ? new Derived7() : flag === 8 ? new Derived8() : flag === 9 ? new Derived9() : flag === 10 ? new Derived10() : flag === 11 ? new Derived11() : flag === 12 ? new Derived12() : flag === 13 ? new Derived13() : flag === 14 ? new Derived14() : flag === 15 ? new Derived15() : flag === 16 ? new Derived16() : flag === 17 ? new Derived17() : flag === 18 ? new Derived18() : flag === 19 ? new Derived19() : flag === 20 ? new Derived20() : flag === 21 ? new Derived21() : flag === 22 ? new Derived22() : flag === 23 ? new Derived23() : flag === 24 ? new Derived24() : new Base();

const _base: Base = items[0];
const _picked: Base = pickOne(0);
const _chosen: Base = chosen;