Wired behavior with conditional checking on multiple conditions.

[zheeeng]

Bug Report

🔎 Search Terms

conditional type on tuple

🕗 Version & Regression Information

v4.5.2

⏯ Playground Link

Playground link with relevant code

💻 Code

type AA<T extends string> = T
type BB<T extends number> = T
type CC<T extends boolean> = T

// x
// Type 'A' does not satisfy the constraint 'string'.(2344)
// Type 'B' does not satisfy the constraint 'number'.(2344)
// Type 'C' does not satisfy the constraint 'boolean'.(2344)
type Test<A, B, C> = 
    [A, B, C] extends [string, number, boolean]
        ? AA<A> | BB<B> | CC<C>
        : never
// ??: type Result = string | number | boolean
type Result = Test<string, number, boolean>

// o
type Test2<A, B, C> = 
    [A] extends [string]
        ? [B] extends [number]
            ? [C] extends [boolean]
                ? AA<A> | BB<B> | CC<C>
                : never
            : never
        : never

// o
type Test3<A, B, C> = 
    A extends string
        ? B extends number
            ? C extends boolean
                ? AA<A> | BB<B> | CC<C>
                : never
            : never
        : never

🙁 Actual behavior

1. In Test1 A, B and C are incompatible with type constraints. As a comparison, Test2 is passed.
2. We still can get the Result type even the Test1 doesn't pass the validation by the type checker

🙂 Expected behavior

1. Don't sure about Test1 or Test2 which is valid.
2. Don't sure should we get the expected Result type when the advanced type doesn't pass the checker.

[RyanCavanaugh]

The error that we couldn't deduce that the type parameter met the constraint occurs and the type declaration is otherwise unaffected; you can see this in code like

type Foo<T extends 1> = T;
// M = 2
type M = Foo<2>;

What "should" happen here is effectively undefined behavior since the program contains a contradiction and thus any result will be "wrong" by some definition.

I'm not sure what causes [A] extends [T] to cause a narrowing of A -> T but not in the 3-tuple case. Seems fixable in principle