Type inference of generic method arguments, in the body of the child class.

[qwabra]

Bug Report

🔎 Search Terms

Type inference of generic method arguments, in the body of the child class.

⏯ Playground Link

namespace Base {
    export interface EventsList {
        [k: string]: (...args: any) => void
    }
}
declare class Base<T extends Base.EventsList> {
    emit<E extends keyof T, A extends Parameters<T[E]>>(event: E, ...args: A): boolean
}
// -,-
namespace A {
    export interface EventsList extends Base.EventsList {
        event1(n: number): void
    }
}
class A<T extends A.EventsList> extends Base<T> { }
// -,-
namespace B {
    export interface EventsList extends A.EventsList {
        event2(str: string): void
    }
}
class B<T extends B.EventsList> extends A<T> {
    t() {
        // -,-
        type event1 = T["event1"] // (method) A<T extends A.EventsList>.EventsList.event1(n: number): void
        // type event1 = (n: number) => void // OK <-------------------
        type parameters = Parameters<event1>
        const params: parameters = [1] // Type '[number]' is not assignable to type 'parameters'.(2322)
        // const params: Parameters<T["event1"]> = [1] // Type '[number]' is not assignable to type 'Parameters<T["event1"]>'.(2322)
        // -,-
        this.emit('event1', 1) // FAIl
    }
}
// -,-
{//test
    const instance = new B
    instance.emit('event1', 1)
    instance.emit('event2', 'q')
    // instance.emit('qwqwqwq', 'qwqwqwq') // ?
    // instance.emit('') // No suggestions
}

Workbench Repro

🙁 Actual behavior

    t() {
        // -,-
        type event1 = T["event1"] // (method) A<T extends A.EventsList>.EventsList.event1(n: number): void
        // type event1 = (n: number) => void // OK <-------------------
        type parameters = Parameters<event1>
        const params: parameters = [1] // Type '[number]' is not assignable to type 'parameters'.(2322)
        // const params: Parameters<T["event1"]> = [1] // Type '[number]' is not assignable to type 'Parameters<T["event1"]>'.(2322)
        // -,-
        this.emit('event1', 1) // FAIl
    }

🙂 Expected behavior

    t() {
        this.emit('event1', 1)
    }

        // type event1 = T["event1"] // should work like
        type event1 = (n: number) => void 

2. suggestions in instance.emit('')

[qwabra]

"Bug Workbench" page is broken

[andrewbranch]

This is essentially the same issue, and same explanation as #43621, just with a regular type parameter instead of a this type. Parameters is a conditional type, and the type you’re passing into it is a type parameter. We can’t predict what Parameters<T['event1']> will be for every valid T. In fact, if you make a “valid” instantiation new B<{ event1: never, event2: never }>(), then Parameters<T['event1']> will be never, and so assigning [1] to it would be an error. Even though that’s a contrived example, it’s due to that potential non-linear nature of conditional types that we don’t just evaluate them with the constraints of type parameters.