Implementing Type which resolves to generic emits an error, but still infers correctly

[MadaraUchiha]

TypeScript Version: 2.7.2

Search Terms:
typescript extend generic type
A class may only implement another class or interface.

Code

const actions = {
    foo(n: number) { },
    bar(s: string) { },
}

type Adaptor<T> = { [K in keyof T]: T[K] };

abstract class MobXAdaptor<T extends {}> implements Adaptor<T> {
    constructor(protected actions: T) { }
}

class MyMobxAdaptor2 extends MobXAdaptor<typeof actions> {
    foo(n: string) {
        return this.actions.foo(n);
    }

    bar() { }
}

Expected behavior:
One of:

• Emit an error for Adaptor<T> not being an interface, and don't understand that foo() is not implemented correctly
• Implement Adaptor<T> correctly, and emit an error for foo() not being implemented correctly.

Actual behavior:
Error is emitted for both Adaptor<T> not being an interface, and foo() not being implemented correctly.

This implies that even though TypeScript emits an error, it does manage to use the generic correctly.

Playground Link:
Click me

Related Issues:

• Suggestion: Interface extend generic type #2225

---

Funny thing is, if I don't use <T> and instead use a realized type like {foo: string}, it doesn't complain about "A class may only implement another class or interface.", and still infers the type correctly in the extending class.

There's an inconsistency here, and I'm not sure which of the conflicting errors is the semantically correct one.

[ghost]

I think this is working as intended. You can't implement a type parameter, so foo is just seen as a new method, not as an implementation of an interface. You can, however, have a property that is a type parameter, so we will still correctly give an error when using the actions property incorrectly. We're giving you the error on the call to actions.foo, not the foo in MyMobxAdaptor2 -- and as far as the compiler is concerned, these are two completely unrelated methods that happen to share a name.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.