Incorrect type-error with interface and throws

[thedrlambda]

Bug Report

🔎 Search Terms

interface, throw

🕗 Version & Regression Information

My version is 4.8.2

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about throw and type-error

⏯ Playground Link

Playground link with relevant code

💻 Code

interface SomeInterface {
  foo(): string | undefined;
}
class SomeInterfaceDummy implements SomeInterface {
  foo() /* : never */ {
    throw "Should not be called";
    // return "";
  }
}
class SomeInterfaceStub extends SomeInterfaceDummy {
  foo() {
    return "stub";
  }
}

🙁 Actual behavior

There is no way to type-check the code above. The return type is inferred as void (I expected never). Adding the out-commented return gives the correct return type but errors with "unreachable code." Putting the return type : never explicitly means the inheriting method doesn't compile.

🙂 Expected behavior

Body that throws is inferred to have type never and never <: any so there should be no errors.

[thedrlambda]

For now, I am using this ugly workaround:

  foo(): ReturnType<SomeInterface["foo"]> {
    throw "Should not be called";
  }

[RyanCavanaugh]

A function consisting only of a throw statement is given type void for exactly the scenario of a psuedo-abstract base class method. If we did what you propose

Body that throws is inferred to have type never and never <: any so there should be no errors.

then SomeInterfaceStub would have an error, because string is not a subtype of never.

[thedrlambda]

But surely the function, being inherited from an interface, should preserve the inherited type. I'm not saying you should give the function return type never, I'm suggesting that the body is inferred to have type never, and the function keeps its inherited type, which should type check because never is a subtype of anything.

[fatcerberus]

But surely the function, being inherited from an interface, should preserve the inherited type.

Method argument and return types are not inferred through inheritance. See #32082 for that.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[RyanCavanaugh]

and the function keeps its inherited type, which should type check because never is a subtype of anything.

It's not legal to return a value from a function that's supposed to be of typed never

[fatcerberus]

@RyanCavanaugh I think they meant the inherited method should be inferred as returning string | undefined (its return type in the base interface), for which a lone throw would be a valid implementation.

[RyanCavanaugh]

Ah, right. Of course, that just creates a different problem:

interface Foo { bar(): string | undefined }
class MyFoo() implements Foo {
  bar() {
    return "hello, world";
  }
}
const m = new MyFoo();
// m.bar() is possibly undefined -- no it isn't??
const s: string = m.bar();

[thedrlambda]

I don't see the problem in your last comment. m.bar() is possibly undefined. Particularly if you use another implementing class than MyFoo. In my original code, I expect:

SomeInterface.foo: string | undefined
SomeInterfaceDummy.foo: string | undefined
SomeInterfaceDummy.foo.body: never (<: string | undefined)
SomeInterfaceStub.foo: string | undefined
SomeInterfaceDummy.foo.body: string (<: string | undefined)

Thus it should all type check.

[RyanCavanaugh]

I don't see the problem in your last comment. m.bar() is possibly undefined

No, it isn't. Because m has type MyFoo, and MyFoo.bar never returns undefined.