Code expected to be unreachable

[Zeckie]

Sometimes, code is expected to be unreachable.

eg.

class Foo:
    ...


class Bar:
    ...


something: Foo | Bar = some_function_call()

if isinstance(something, Foo):
    ...
elif isinstance(something, Bar):
    ...
else:
    raise TypeError(f"unexpected type: {something.__class__.__name__}")

Is there a good way to handle this, to tell basedmypy that that raise line should always be unreachable. It would be good to not just ignore it, but have some way of saying that if the line later becomes unreachable, it is an error.

A harder problem - is it possible to also check that the unreachable else block is otherwise valid. For example, if the case that some_function_call() could return a Baz at runtime, but had a stub to say it returned only Foo or Bar. Maybe then treat something as type Any?

[KotlinIsland]

Expect this feature in python 3.11(or in typing_extensions) with typing.assert_never python/typing/issues/735

If you are expecting a line to be unreachable all you have to do is annotate that line with # type: ignore[unreachable], this only applies to the first unreachable line of a branch. Note that there is an issue where this will not be reported on lines with raise statements, to work around this, just put a filler line, eg:

if False:
    message = "unreachable"  # type: ignore[unreachable]
    raise RuntimeError(message)

Also note that this is unrelated to basedmypy, all this functionality is in mypy.

There is an issue to create a dedicated function for this purpose #147 in basedmypy/basedtyping.

Original comment

Mypy treats unreachable lines that raise exceptions as reachable: playground link

There is a tracking issue here

if the case that some_function_call() could return a Baz at runtime, but had a stub to say it returned only Foo or Bar. Maybe then treat something as type Any?

The stub is the only source of truth, if it can return Baz then it should be defined so.

def some_function_call() -> Foo | Bar | Baz: ...

If you don't know explicitly what it could return, you could type it something like one of these:

def some_function_call() -> Foo | Bar | object: ...
def some_function_call() -> Foo | Bar | Any: ...

Or are you describing a different scenario?

some way of saying that if the line later becomes unreachable, it is an error.

Not sure what you mean, if the line is currently reachable and becomes unreachable later it will become an error.

[Zeckie]

It looks like just the raise statement is treated as reachable, not the branch.

https://mypy-play.net/?mypy=master&python=3.10&flags=strict%2Cwarn-unreachable&gist=9c76a6c0312f80581f7043c419030f2a

[Zeckie]

To clarify, i'm wanting to know how to annotate this correctly (is there some annotation to say that I expect that else block to be unreachable).

I'm thinking of 3 scenarios:

1. some_function_call() is correctly typed and returns Foo | Bar
2. some_function_call() is a third party function that was untyped, so I added a stub (Foo | Bar). I am 99% sure it returns only Foo or Bar. It actually also returns Baz in some rare cases.
3. some_function_call() later changes, and now returns `Foo | Bar | Baz'.

I want scenario 1 and 2 to pass (it believes the stub), and scenario 3 to fail type checking (to alert me that the else block is now reachable, and I now need to update my code to handle 'Baz').

[KotlinIsland]

If you want to indicate that a line should be unreachable annotate the line with # type: ignore[unreachable]

I believe this should address your scenarios.

[Zeckie]

That doesn't work if the block raises an error (gives error: Unused "type: ignore" comment)

https://mypy-play.net/?mypy=master&python=3.10&flags=strict%2Cwarn-unreachable&gist=38b4da8d25ba92e2a8fb6089cb07f63d

[KotlinIsland]

Yeah as I mentioned there's an issue here python#10916

just put a no-op before that line.

else:
    message = "😳"
    raise TypeError(message)