[ty] Use TDD-based narrowing constraints and support NoReturn narrowing

crates/ty_python_semantic/resources/mdtest/narrow/match.md

@@ -252,7 +252,7 @@ def _(x: Literal["foo", b"bar"] | int):
             pass
         case b"bar" if reveal_type(x):  # revealed: Literal[b"bar"] | int
             pass
-        case _ if reveal_type(x):  # revealed: Literal["foo", b"bar"] | int
+        case _ if reveal_type(x):  # revealed: int | Literal["foo", b"bar"]
             pass
 ```
 
@@ -350,6 +350,45 @@ except ValueError:
     pass
 ```
 
+## Narrowing is preserved when a terminal branch prevents a path from flowing through
+
+When one branch of a `match` statement is terminal (e.g. contains `raise`), narrowing from the
+non-terminal branches is preserved after the merge point.
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def _(x: A | B | C):
+    match x:
+        case A():
+            pass
+        case B():
+            pass
+        case _:
+            raise ValueError()
+
+    reveal_type(x)  # revealed: B | (A & ~B)
+```
+
+Reassignment in non-terminal branches is also preserved when the default branch is terminal:
+
+```py
+def _(number_of_periods: int | None, interval: str):
+    match interval:
+        case "monthly":
+            if number_of_periods is None:
+                number_of_periods = 1
+        case "daily":
+            if number_of_periods is None:
+                number_of_periods = 30
+        case _:
+            raise ValueError("unsupported interval")
+
+    reveal_type(number_of_periods)  # revealed: int
+```
+
 ## Narrowing tagged unions of tuples
 
 Narrow unions of tuples based on literal tag elements in `match` statements:

crates/ty_python_semantic/resources/mdtest/narrow/post_if_statement.md

@@ -49,3 +49,196 @@ def _(x: int | None):
 
     reveal_type(x)  # revealed: int
 ```
+
+## Narrowing is preserved when a terminal branch prevents a path from flowing through
+
+When one branch of an if/elif/else is terminal (e.g. contains `return`), narrowing from the
+non-terminal branches is preserved after the merge point.
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def _(x: A | B | C):
+    if isinstance(x, A):
+        pass
+    elif isinstance(x, B):
+        pass
+    else:
+        return
+
+    # Only the if-branch (A) and elif-branch (B) flow through.
+    # The else-branch returned, so its narrowing doesn't participate.
+    reveal_type(x)  # revealed: B | (A & ~B)
+```
+
+## Narrowing is preserved with multiple terminal branches
+
+```py
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+def _(x: A | B | C | D):
+    if isinstance(x, A):
+        return
+    elif isinstance(x, B):
+        pass
+    elif isinstance(x, C):
+        pass
+    else:
+        return
+
+    # Only the elif-B and elif-C branches flow through.
+    reveal_type(x)  # revealed: (C & ~A) | (B & ~A & ~C)
+```
+
+## Multiple sequential if-statements don't leak narrowing
+
+After a complete if/else where both branches flow through (no terminal), narrowing should be
+cancelled out at the merge point.
+
+```py
+class A: ...
+class B: ...
+class C: ...
+
+def _(x: A | B | C):
+    if isinstance(x, A):
+        pass
+    else:
+        pass
+
+    # Narrowing cancels out: both paths flow, so type is unchanged.
+    reveal_type(x)  # revealed: A | B | C
+
+    if isinstance(x, B):
+        pass
+    else:
+        pass
+
+    # Second if-statement's narrowing also cancels out.
+    reveal_type(x)  # revealed: A | B | C
+```
+
+## Narrowing after a `NoReturn` call in one branch
+
+When a branch calls a function that returns `NoReturn`/`Never`, we know that branch terminates and
+doesn't contribute to the type after the if statement.
+
+```py
+import sys
+
+def _(val: int | None):
+    if val is None:
+        sys.exit()
+    reveal_type(val)  # revealed: int
+```
+
+This also works when the `NoReturn` function is called in the else branch:
+
+```py
+import sys
+
+def _(val: int | None):
+    if val is not None:
+        pass
+    else:
+        sys.exit()
+    reveal_type(val)  # revealed: int
+```
+
+And for elif branches:
+
+```py
+import sys
+
+def _(val: int | str | None):
+    if val is None:
+        sys.exit()
+    elif isinstance(val, int):
+        pass
+    else:
+        sys.exit()
+    reveal_type(val)  # revealed: int
+```
+
+## Narrowing through always-true branches
+
+When a terminal (`return`) is inside an always-true branch, narrowing propagates through because the
+else-branch is unreachable and contributes `Never` to the union.
+
+```py
+def _(x: int | None):
+    if True:
+        if x is None:
+            return
+        reveal_type(x)  # revealed: int
+    reveal_type(x)  # revealed: int
+```
+
+```py
+def _(x: int | None):
+    if 1 + 1 == 2:
+        if x is None:
+            return
+        reveal_type(x)  # revealed: int
+
+    # TODO: should be `int` (the else-branch of `1 + 1 == 2` is unreachable)
+    reveal_type(x)  # revealed: int | None
+```
+
+This also works when the always-true condition is nested inside a narrowing branch:
+
+```py
+def _(x: int | None):
+    if x is None:
+        if 1 + 1 == 2:
+            return
+
+    # TODO: should be `int` (the inner always-true branch makes the outer
+    # if-branch terminal)
+    reveal_type(x)  # revealed: int | None
+```
+
+## Narrowing from `assert` should not affect reassigned variables
+
+When a variable is reassigned after an `assert`, the narrowing from the assert should not apply to
+the new value.
+
+```py
+def foo(arg: int) -> int | None:
+    return None
+
+def bar() -> None:
+    v = foo(1)
+    assert v is None
+
+    v = foo(2)
+    # v was reassigned, so the assert narrowing shouldn't apply
+    reveal_type(v)  # revealed: int | None
+```
+
+## Narrowing from `NoReturn` should not affect reassigned variables
+
+When a variable is narrowed due to a `NoReturn` call in one branch and then reassigned, the
+narrowing should only apply before the reassignment, not after.
+
+```py
+import sys
+
+def foo() -> int | None:
+    return 3
+
+def bar():
+    v = foo()
+    if v is None:
+        sys.exit()
+    reveal_type(v)  # revealed: int
+
+    v = foo()
+    # v was reassigned, so any narrowing shouldn't apply
+    reveal_type(v)  # revealed: int | None
+```

crates/ty_python_semantic/resources/mdtest/terminal_statements.md

@@ -618,9 +618,7 @@ def g(x: int | None):
     if x is None:
         sys.exit(1)
 
-    # TODO: should be just `int`, not `int | None`
-    # See https://github.com/astral-sh/ty/issues/685
-    reveal_type(x)  # revealed: int | None
+    reveal_type(x)  # revealed: int
 ```
 
 ### Possibly unresolved diagnostics

crates/ty_python_semantic/src/lib.rs

@@ -36,7 +36,6 @@ pub mod ast_node_ref;
 mod db;
 mod dunder_all;
 pub mod lint;
-pub(crate) mod list;
 mod node_key;
 pub(crate) mod place;
 mod program;