fix some

Author: asukaminato0721

pyrefly/lib/binding/bindings.rs

@@ -893,19 +893,31 @@ impl<'a> BindingsBuilder<'a> {
         idx: Idx<Key>,
         style: FlowStyle,
     ) -> Option<Idx<KeyAnnotation>> {
-        let name = Hashed::new(name);
-        let write_info = self
+        let mut hashed_name = Hashed::new(name);
+        let mut write_info = self
             .scopes
-            .define_in_current_flow(name, idx, style)
-            .unwrap_or_else(|| {
-                panic!(
-                    "Name `{name}` not found in static scope of module `{}`.",
-                    self.module_info.name(),
-                )
-            });
+            .define_in_current_flow(hashed_name.clone(), idx, style.clone());
+        if write_info.is_none()
+            && self.errors_suppressed()
+            && self.should_bind_unreachable_branches()
+        {
+            let key_range = self.table.types.0.idx_to_key(idx).range();
+            self.scopes.add_synthetic_definition(name, key_range);
+            // Recreate the hash since it borrows `name` by reference and we just mutated state
+            hashed_name = Hashed::new(name);
+            write_info = self
+                .scopes
+                .define_in_current_flow(hashed_name.clone(), idx, style);
+        }
+        let write_info = write_info.unwrap_or_else(|| {
+            panic!(
+                "Name `{name}` not found in static scope of module `{}`.",
+                self.module_info.name(),
+            )
+        });
         if let Some(range) = write_info.anywhere_range {
             self.table
-                .record_bind_in_anywhere(name.into_key().clone(), range, idx);
+                .record_bind_in_anywhere(hashed_name.into_key().clone(), range, idx);
         }
         write_info.annotation
     }

pyrefly/lib/binding/scope.rs

@@ -1511,6 +1511,22 @@ impl Scopes {
         self.current_mut().stat.expr_lvalue(x);
     }
 
+    /// Synthesize a static definition entry for `name` in the current scope if it
+    /// is missing. This is used when we deliberately analyze unreachable code for
+    /// IDE metadata; those code paths may not have been included in the up-front
+    /// static scan, so we add a lightweight placeholder on demand.
+    pub fn add_synthetic_definition(&mut self, name: &Name, range: TextRange) {
+        let hashed_ref = Hashed::new(name);
+        if self.current().stat.0.get_hashed(hashed_ref).is_some() {
+            return;
+        }
+        self.current_mut().stat.upsert(
+            Hashed::new(name.clone()),
+            range,
+            StaticStyle::SingleDef(None),
+        );
+    }
+
     /// Add a loop exit point to the current innermost loop with the current flow.
     ///
     /// Return a bool indicating whether we were in a loop (if we weren't, we do nothing).

pyrefly/lib/test/lsp/definition.rs

@@ -95,11 +95,15 @@ if not TYPE_CHECKING:
 # main.py
 5 |     x = 1
         ^
-Definition Result: None
+Definition Result:
+5 |     x = 1
+        ^
 
 7 |     y = x
             ^
-Definition Result: None
+Definition Result:
+5 |     x = 1
+        ^
 "#
         .trim(),
         report.trim(),

pyrefly/lib/test/lsp/hover_type.rs

@@ -289,35 +289,35 @@ if False:
 # main.py
 3 |   def f():
           ^
-Hover Result: None
+Hover Result: `() -> None`
 
 7 |   x = 3
       ^
-Hover Result: None
+Hover Result: `Literal[3]`
 
 9 |   x
       ^
-Hover Result: None
+Hover Result: `Literal[3]`
 
 11 |   f
        ^
-Hover Result: None
+Hover Result: `() -> None`
 
 14 |   def f():
            ^
 Hover Result: None
 
 18 |   x = 3
        ^
-Hover Result: None
+Hover Result: `Literal[3]`
 
 20 |   x
        ^
-Hover Result: None
+Hover Result: `Literal[3]`
 
 22 |   f
        ^
-Hover Result: None
+Hover Result: `() -> None`
 "#
         .trim(),
         report.trim(),