Code after `yield from` a generator that cannot end should be unreachable

[A5rocks]

Bug Report

Split off from #7374 (comment)

To Reproduce

from typing import Generator, NoReturn, Union

def inf() -> Generator[str, None, NoReturn]:
    while True:
        yield "xyz"


def generate(x: Union[str, int]) -> Generator[str, None, int]:
    if isinstance(x, str):
        yield from inf()  # `yield from` will never return, because the generator never returns 

    return x  # error: Incompatible return value type (got "Union[str, int]", expected "int")

Expected Behavior

No error

Actual Behavior

An error.

Your Environment

Reproduced in mypy-play.

• Mypy version used: 1.16.1
• Mypy command-line flags: N/A
• Mypy configuration options from mypy.ini (and other config files): N/A
• Python version used: 3.12

[sterliakov]

We need a major overhaul of yield from anyway, current implementation is... interesting (see #17449 and a few others). This would be a neat addition.

mypy/mypy/checker.py

Lines 1028 to 1061 in 6886b7a

	def get_generator_yield_type(self, return_type: Type, is_coroutine: bool) -> Type:
	"""Given the declared return type of a generator (t), return the type it yields (ty)."""
	return_type = get_proper_type(return_type)
	if isinstance(return_type, AnyType):
	return AnyType(TypeOfAny.from_another_any, source_any=return_type)
	elif isinstance(return_type, UnionType):
	return make_simplified_union(
	[self.get_generator_yield_type(item, is_coroutine) for item in return_type.items]
	)
	elif not self.is_generator_return_type(
	return_type, is_coroutine
	) and not self.is_async_generator_return_type(return_type):
	# If the function doesn't have a proper Generator (or
	# Awaitable) return type, anything is permissible.
	return AnyType(TypeOfAny.from_error)
	elif not isinstance(return_type, Instance):
	# Same as above, but written as a separate branch so the typechecker can understand.
	return AnyType(TypeOfAny.from_error)
	elif return_type.type.fullname == "typing.Awaitable":
	# Awaitable: ty is Any.
	return AnyType(TypeOfAny.special_form)
	elif return_type.args:
	# AwaitableGenerator, Generator, AsyncGenerator, Iterator, or Iterable; ty is args[0].
	ret_type = return_type.args[0]
	# TODO not best fix, better have dedicated yield token
	return ret_type
	else:
	# If the function's declared supertype of Generator has no type
	# parameters (i.e. is `object`), then the yielded values can't
	# be accessed so any type is acceptable. IOW, ty is Any.
	# (However, see https://github.com/python/mypy/issues/1933)
	return AnyType(TypeOfAny.special_form)

send and return types are handled in similar fashion.