Fix false unknown-name error for Literal imported via try/except

Summary:
When `Literal` is imported via a `try/except` block (e.g. `from typing import Literal` in try, `from typing_extensions import Literal` in except), the flow merge produces `FlowStyle::Other` because the two imports come from different modules. This caused `as_special_export()` to fail to recognize `Literal` as a special form, so strings inside `Literal["test"]` were treated as forward references, producing spurious `unknown-name` errors.

The fix adds handling for `Binding::Import` and `Binding::Phi` in `special_export_from_binding_idx`. For Phi nodes (merged try/except branches), all branches are checked recursively and the result is returned if they agree on the same `SpecialExport`.

fixes #2407

Reviewed By: stroxler

Differential Revision: D93287592

fbshipit-source-id: 86ccc87f40155860870a2132a6a41cd9d8a550d0

Author: kinto0

pyrefly/lib/binding/bindings.rs

@@ -983,6 +983,28 @@ impl<'a> BindingsBuilder<'a> {
                 Binding::NameAssign { expr: value, .. } => {
                     return self.as_special_export_inner(value, visited_names, visited_keys);
                 }
+                Binding::Import(module_name, name, _) => {
+                    return self.lookup.is_special_export(*module_name, name);
+                }
+                Binding::Phi(_, branches) => {
+                    // Check all branches for a consistent special export (e.g. try/except
+                    // importing Literal from typing vs typing_extensions).
+                    let mut result = None;
+                    for branch in branches {
+                        let branch_result = self.special_export_from_binding_idx(
+                            branch.value_key,
+                            visited_names,
+                            visited_keys,
+                        );
+                        match (&result, &branch_result) {
+                            (None, _) => result = branch_result,
+                            (_, None) => {}
+                            (Some(a), Some(b)) if a == b => {}
+                            _ => return None,
+                        }
+                    }
+                    return result;
+                }
                 _ => return None,
             }
         }

pyrefly/lib/test/literal.rs

@@ -403,3 +403,21 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 assert_type(x, LiteralString)
     "#,
 );
+
+testcase!(
+    test_literal_try_except_import,
+    r#"
+from typing import assert_type
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal
+
+def fun(param: Literal["test"] = "test"):
+    assert_type(param, Literal["test"])
+
+x: Literal["a", "b"] = "a"
+assert_type(x, Literal["a", "b"])
+"#,
+);