Fix narrowing in comprehensions when the intersection is impossible

[apoorvdarshan]

Fixes #21635

Problem

When a comprehension condition narrows the index variable to an impossible type — e.g. issubclass(cls, M) where mypy determines a subclass of both classes cannot exist (the dataclass case from the issue, classes with incompatible method signatures, or @final classes) — the narrowing was silently discarded:

alist: list[type[A]] = [B, C]
mlist: list[type[M]] = [cls for cls in alist if issubclass(cls, M)]
# error: List comprehension has incompatible type List[type[A]]; expected List[type[M]]

Root cause

check_for_comp() pushes the condition's true_map via push_type_map(). For an impossible narrowing the map contains an UninhabitedType, so push_type_map() takes the is_unreachable_map() branch and only calls binder.unreachable() — no narrowing is recorded. That's fine for statements, where the checker skips unreachable blocks, but the comprehension's left expression is still type checked, so it was checked with the unnarrowed type (type[A]), producing the false positive.

(The equivalent for/if statement version "works" only because the if body is skipped as unreachable; with --warn-unreachable it reports the impossible subclass instead.)

Fix

In check_for_comp(), when the condition's true_map is an unreachable map, apply the impossible narrowing to the binder instead of marking the frame unreachable. The left expression then checks against Never — matching the narrowing an equivalent if statement would produce — and the example above typechecks (the item type is Never, which is compatible with any expected item type).

This also covers generator expressions and dict comprehensions (all go through check_for_comp()), and mirrors what analyze_cond_branch() already does for conditional expressions (it types the unreachable branch as UninhabitedType).

Verification

• New test cases in check-isinstance.test (testComprehensionIsInstanceImpossibleIntersection, testComprehensionIsSubclassImpossibleIntersectionFinal) — both fail on master and pass with this change.
• Full testcheck suite: 8189 passed, 33 skipped, 7 xfailed.
• Self check and ruff check/ruff format clean on the changed file.

LLM disclosure

Per the CONTRIBUTING note on LLM-assisted contributions: this fix was developed with the assistance of an AI tool (Claude Code). I've reviewed the change and the investigation behind it, take full responsibility for it, and will respond to review feedback personally.

[github-actions]

Diff from mypy_primer, showing the effect of this PR on open source code:

strawberry (https://github.com/strawberry-graphql/strawberry)
+ strawberry/relay/fields.py:189: error: Need type annotation for "nodes"  [var-annotated]
+ strawberry/relay/fields.py:190: error: Unused "type: ignore" comment  [unused-ignore]

[apoorvdarshan]

Analysis of the mypy_primer diff — the new strawberry errors are the fix working as intended, not a regression:

strawberry/relay/fields.py builds asyncgen_nodes = {node_t: nodes for node_t, nodes in resolved_nodes.items() if inspect.isasyncgen(nodes)}, where resolve_nodes() is declared to return AwaitableOrValue[Iterable[Self]]. inspect.isasyncgen narrows to AsyncGeneratorType[Any, Any], which is @final in typeshed and neither Awaitable nor Iterable — so mypy concludes the narrowing is impossible for every member of the declared union.

Previously that impossible narrowing was silently discarded (the comp value kept the full union type), which also meant the pre-existing # type: ignore on the asyncgen_to_list(nodes) line was needed. With this PR the comp value is precisely Never — the same conclusion the equivalent for/if statement already produces (visible under --warn-unreachable) — so downstream nodes becomes ambiguous (var-annotated) and the old ignore is now unused.

Runtime-wise strawberry does handle async generators there, so the surfaced issue is real on their side: the declared return type of resolve_nodes doesn't include an async-iterable member. The fix is surfacing a previously-swallowed inconsistency rather than introducing one.