[ty] Fix panic on incomplete except handlers

crates/ty_ide/src/completion.rs

@@ -5334,6 +5334,43 @@ except Type<CURSOR>:
         );
     }
 
+    // Ref: https://github.com/astral-sh/ty/issues/2401
+    #[test]
+    fn no_panic_incomplete_except_handler() {
+        let builder = completion_test_builder(
+            "\
+try:
+    print()
+except <CURSOR># Trigger completion/hover here
+",
+        );
+
+        assert_snapshot!(
+            builder.skip_keywords().skip_builtins().skip_auto_import().build().snapshot(),
+            @"<No completions found after filtering out completions>",
+        );
+    }
+
+    // Ref: https://github.com/astral-sh/ty/issues/2401
+    #[test]
+    fn incomplete_except_handler_uses_enclosing_scope() {
+        completion_test_builder(
+            "\
+def f():
+    sentinel = 1
+    try:
+        print()
+    except <CURSOR>as err:
+        pass
+",
+        )
+        .skip_keywords()
+        .skip_builtins()
+        .skip_auto_import()
+        .build()
+        .contains("sentinel");
+    }
+
     // Ref: https://github.com/astral-sh/ty/issues/572
     #[test]
     fn scope_id_missing_global1() {

crates/ty_ide/src/goto.rs

@@ -331,7 +331,7 @@ impl GotoTarget<'_> {
             GotoTarget::ImportSymbolAlias { alias, .. }
             | GotoTarget::ImportModuleAlias { alias, .. }
             | GotoTarget::ImportExportedName { alias, .. } => alias.inferred_type(model),
-            GotoTarget::ExceptVariable(except) => except.inferred_type(model),
+            GotoTarget::ExceptVariable(except) => model.except_handler_type(except),
             GotoTarget::KeywordArgument { keyword, .. } => keyword.value.inferred_type(model),
             // When asking the type of a callable, usually you want the callable itself?
             // (i.e. the type of `MyClass` in `MyClass()` is `<class MyClass>` and not `() -> MyClass`)
@@ -515,11 +515,9 @@ impl GotoTarget<'_> {
             )),
 
             // For exception variables, they are their own definitions (like parameters)
-            GotoTarget::ExceptVariable(except_handler) => {
-                Some(vec![ResolvedDefinition::Definition(
-                    except_handler.definition(model),
-                )])
-            }
+            GotoTarget::ExceptVariable(except_handler) => model
+                .except_handler_definition(except_handler)
+                .map(|definition| vec![ResolvedDefinition::Definition(definition)]),
 
             // Patterns are glorified assignments but we have to look them up by ident
             // because they're not expressions
@@ -949,9 +947,10 @@ impl GotoTarget<'_> {
 
                     None
                 }
-                Some(AnyNodeRef::ExceptHandlerExceptHandler(handler)) => {
-                    Some(GotoTarget::ExceptVariable(handler))
-                }
+                Some(AnyNodeRef::ExceptHandlerExceptHandler(handler)) => handler
+                    .name
+                    .is_some()
+                    .then_some(GotoTarget::ExceptVariable(handler)),
                 Some(AnyNodeRef::Keyword(keyword)) => {
                     // Find the containing call expression from the ancestor chain
                     let call_expression = covering_node
@@ -1139,7 +1138,10 @@ impl Ranged for GotoTarget<'_> {
             } => *component_range,
             GotoTarget::StringAnnotationSubexpr { subrange, .. } => *subrange,
             GotoTarget::ImportModuleAlias { asname, .. } => asname.range,
-            GotoTarget::ExceptVariable(except) => except.name.as_ref().unwrap().range,
+            GotoTarget::ExceptVariable(except) => except
+                .name
+                .as_ref()
+                .map_or(except.range(), |name| name.range),
             GotoTarget::KeywordArgument { keyword, .. } => keyword.arg.as_ref().unwrap().range,
             GotoTarget::PatternMatchRest(rest) => rest.rest.as_ref().unwrap().range,
             GotoTarget::PatternKeywordArgument(keyword) => keyword.attr.range,

crates/ty_ide/src/hover.rs

@@ -4952,6 +4952,20 @@ def function():
         ");
     }
 
+    // Ref: https://github.com/astral-sh/ty/issues/2401
+    #[test]
+    fn hover_incomplete_except_handler() {
+        let test = cursor_test(
+            "\
+try:
+    print()
+except <CURSOR># Trigger completion/hover here
+",
+        );
+
+        assert_snapshot!(test.hover(), @"Hover provided no content");
+    }
+
     impl CursorTest {
         fn hover(&self) -> String {
             use std::fmt::Write;

crates/ty_python_semantic/src/semantic_model.rs

@@ -304,12 +304,15 @@ impl<'db> SemanticModel<'db> {
                     .scope(self.db)
                     .file_scope_id(self.db),
             ),
-            ast::AnyNodeRef::ExceptHandlerExceptHandler(handler) => Some(
-                handler
-                    .definition(self)
-                    .scope(self.db)
-                    .file_scope_id(self.db),
-            ),
+            ast::AnyNodeRef::ExceptHandlerExceptHandler(handler) => self
+                .except_handler_definition(handler)
+                .map(|definition| definition.scope(self.db).file_scope_id(self.db))
+                .or_else(|| {
+                    handler.type_.as_deref().and_then(|handled_exceptions| {
+                        index.try_expression_scope_id(handled_exceptions)
+                    })
+                })
+                .or(Some(FileScopeId::global())),
             ast::AnyNodeRef::TypeParamTypeVar(var) => {
                 Some(var.definition(self).scope(self.db).file_scope_id(self.db))
             }
@@ -325,6 +328,29 @@ impl<'db> SemanticModel<'db> {
         }
     }
 
+    /// Returns the definition for an exception-handler variable.
+    ///
+    /// Exception handlers only have a definition when they bind a name (`except E as name:`).
+    pub fn except_handler_definition(
+        &self,
+        handler: &ast::ExceptHandlerExceptHandler,
+    ) -> Option<Definition<'db>> {
+        handler.name.as_ref()?;
+        let index = semantic_index(self.db, self.file);
+        Some(index.expect_single_definition(handler))
+    }
+
+    /// Returns the inferred type of an exception-handler variable.
+    ///
+    /// Exception handlers only bind a variable when they have a name (`except E as name:`).
+    pub fn except_handler_type(
+        &self,
+        handler: &ast::ExceptHandlerExceptHandler,
+    ) -> Option<Type<'db>> {
+        let definition = self.except_handler_definition(handler)?;
+        Some(binding_type(self.db, definition))
+    }
+
     /// Get a "safe" [`ast::AnyNodeRef`] to use for referring to the given (sub-)AST node.
     ///
     /// If we're analyzing a string annotation, it will return the string literal's node.
@@ -641,7 +667,6 @@ impl_binding_has_ty_def!(ast::StmtFunctionDef);
 impl_binding_has_ty_def!(ast::StmtClassDef);
 impl_binding_has_ty_def!(ast::Parameter);
 impl_binding_has_ty_def!(ast::ParameterWithDefault);
-impl_binding_has_ty_def!(ast::ExceptHandlerExceptHandler);
 impl_binding_has_ty_def!(ast::TypeParamTypeVar);
 
 impl HasType for ast::Alias {