Infer never type for getters that don't return (e.g. by throwing an error in all codepaths)

Search Terms

getter infer
getter never

Suggestion

Consider this code:

const foo = () => {
  throw new Error('Not implemented');
};

type Foo = typeof foo;

Foo will be inferred as () => never.

What if I want to use this function as a getter in an object:

const bar = {
  get bar() {
    throw new Error('Not implemented');
  }
};

type Bar = typeof bar.bar;

Here, Bar is inferred as void. I don't see why it should be void as opposed to never.

As a workaround, it's currently possible to hint TypeScript correct type:

const bar = {
  get bar(): never {
    throw new Error('Not implemented');
  }
};

type Bar = typeof bar.bar;

Here Bar is never.

From what I currently understand, this change won't break existing code, but it will make previously invalid code valid.

Use Cases

This has been discovered while trying to implement a React context with default value that throws when used without a context provider. Here I want it become obvious for developers when context provider is not defined, without sacrificing on type safety by making context properties optional, or populating them with default values (which would not make it obvious that provider is absent).

The workaround I have provided above works, but it would be nice for the compiler to figure that out.

Examples

To follow up with a React context example:

interface SystemStatus {
  isOnline: boolean;
}

const SystemStatusContext = createContext<SystemStatus>({
  get isOnline() {
    throw new Error('Used outside of SystemStatusContext');
  }
});

Currently this code doesn't compile.

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

The issue names no files, tests, or entry points. Reproduce the two getter examples and compare their inferred types with the function example; done means getters that throw on every path infer as never without changing runtime behavior or breaking existing code.