Add test for except handler narrowing and unreachability regression

Summary:
This diff adds a few more tests to make sure we don't regress on an unreachability case that was reported, in addition to a bug in the except handler narrowing that caused the invalid unreachability error to fire

___

Differential Revision: D122859658

fbshipit-source-id: 267141ec1f97ad1d20a46a41f4ed56e1c3ae5fe9

Author: connernilsen

pyrefly/lib/test/flow_branching.rs

@@ -3475,6 +3475,15 @@ def f() -> None:
 // A test's value settles its branch only when declarations fix it. Each test below is typed
 // `Literal[False]`, `None`, or `Never` only by inference from an unannotated assignment or by
 // flow narrowing, and each is live at runtime.
+//
+// `flag_raised_in_try` is the case that reached us from the field, and it is the sharpest of
+// them: its narrowed value is not merely imprecise but wrong. An `except` handler is given
+// the state from before the `try` body, so `created` reads as `Literal[False]` even though
+// the exception can only have come from after it was set — see
+// `test_except_handler_narrows_to_state_before_try` in `narrow.rs`. Correcting that
+// narrowing will not make this case redundant. It stands for a branch whose test the flow
+// believes is settled while it is live at runtime, which this check must respect however
+// the value was arrived at.
 testcase!(
     test_no_report_for_test_values_only_inference_settles,
     r#"
@@ -3542,6 +3551,21 @@ class Dtype:
 def chained_equality(d: Dtype) -> None:
     if d == "int" and d != "int64":
         print(6)
+
+def may_raise() -> None:
+    raise RuntimeError
+
+def cleanup() -> None:
+    pass
+
+def flag_raised_in_try() -> None:
+    created = False
+    try:
+        created = True
+        may_raise()
+    except RuntimeError:
+        if created:
+            cleanup()
 "#,
 );
 

pyrefly/lib/test/narrow.rs

@@ -4560,3 +4560,34 @@ class Env:
             self.domains = Container()  # E: Assigning to attribute `domains` on an object with type `Never`
     "#,
 );
+
+// An exception can be raised anywhere in a `try` body, including after an assignment, so a
+// handler has to account for every state the body passes through. We give it only the state
+// the body started from, which reports a variable as whatever it held on entry even where
+// that value is impossible. The `assert_type` below records what we say today, not what is
+// correct: `created` is `True` whenever `may_raise` is what raised, so the answer is `bool`.
+//
+// This reached us as a false `unreachable` on cleanup code guarded by such a flag. The
+// `flag_raised_in_try` case of `test_no_report_for_test_values_only_inference_settles` in
+// `flow_branching.rs` holds that symptom, which no longer reports, because a branch is
+// settled only by declarations. This is the cause, and it is still here: the annotated
+// assignment below is impossible at runtime and we accept it.
+testcase!(
+    bug = "An `except` handler narrows to the state before the `try`, not across it",
+    test_except_handler_narrows_to_state_before_try,
+    r#"
+from typing import Literal, assert_type
+
+def may_raise() -> None:
+    raise RuntimeError
+
+def f() -> None:
+    created = False
+    try:
+        created = True
+        may_raise()
+    except RuntimeError:
+        assert_type(created, Literal[False])
+        narrowed: Literal[False] = created
+    "#,
+);