Refactor throws analysis to use PhpType for exception types

Author: AJenbo

src/code_actions/update_docblock.rs

@@ -675,7 +675,8 @@ fn check_needs_update(
         .map(|t| short_name(t).to_lowercase())
         .collect();
     for exc in &uncaught {
-        let short = short_name(exc);
+        let exc_str = exc.to_string();
+        let short = short_name(&exc_str);
         if !existing_lower.contains(&short.to_lowercase()) {
             return true;
         }
@@ -883,7 +884,8 @@ fn build_updated_docblock(
 
     let mut new_throws: Vec<String> = Vec::new();
     for exc in &uncaught {
-        let short = short_name(exc);
+        let exc_str = exc.to_string();
+        let short = short_name(&exc_str);
         if !existing_throws_lower.contains(&short.to_lowercase()) {
             new_throws.push(short.to_string());
         }

src/completion/context/catch_completion.rs

@@ -98,12 +98,12 @@ pub(crate) fn detect_catch_context(content: &str, position: Position) -> Option<
     // 1. Direct `throw new ExceptionType(…)` statements
     let throws = throws_analysis::find_throw_statements(&try_body);
     for throw in &throws {
-        let short_name = throw
-            .type_name
+        let raw = throw.type_name.to_string();
+        let short_name = raw
             .trim_start_matches('\\')
             .rsplit('\\')
             .next()
-            .unwrap_or(&throw.type_name);
+            .unwrap_or(&raw);
         if !short_name.is_empty() && seen.insert(short_name.to_lowercase()) {
             suggested_types.push(short_name.to_string());
         }
@@ -112,20 +112,20 @@ pub(crate) fn detect_catch_context(content: &str, position: Position) -> Option<
     // 2. Inline `/** @throws ExceptionType */` annotations
     let inline_throws = throws_analysis::find_inline_throws_annotations(&try_body);
     for info in &inline_throws {
-        let short_name = info
-            .type_name
+        let raw = info.type_name.to_string();
+        let short_name = raw
             .trim_start_matches('\\')
             .rsplit('\\')
             .next()
-            .unwrap_or(&info.type_name);
+            .unwrap_or(&raw);
         if !short_name.is_empty() && seen.insert(short_name.to_lowercase()) {
             suggested_types.push(short_name.to_string());
         }
     }
 
     // 3. Propagated @throws from called methods
     let propagated = throws_analysis::find_propagated_throws(&try_body, content);
-    let propagated: Vec<String> = propagated.iter().map(|t| t.type_name.clone()).collect();
+    let propagated: Vec<String> = propagated.iter().map(|t| t.type_name.to_string()).collect();
     for exc_type in &propagated {
         let short_name = exc_type
             .trim_start_matches('\\')
@@ -141,7 +141,7 @@ pub(crate) fn detect_catch_context(content: &str, position: Position) -> Option<
     let throw_expr_types = throws_analysis::find_throw_expression_types(&try_body, content);
     let throw_expr_types: Vec<String> = throw_expr_types
         .iter()
-        .map(|t| t.type_name.clone())
+        .map(|t| t.type_name.to_string())
         .collect();
     for exc_type in &throw_expr_types {
         let short_name = exc_type

src/completion/context/catch_completion_tests.rs

@@ -11,8 +11,9 @@ fn test_find_method_throws_tags_with_private() {
         "}\n",
     );
     let result = throws_analysis::find_method_throws_tags(content, "riskyOperation");
+    let names: Vec<String> = result.iter().map(|t| t.to_string()).collect();
     assert_eq!(
-        result,
+        names,
         vec!["ValidationException"],
         "Should find @throws through 'private' modifier"
     );
@@ -28,8 +29,9 @@ fn test_find_method_throws_tags_with_protected_static() {
         "}\n",
     );
     let result = throws_analysis::find_method_throws_tags(content, "dangerousCall");
+    let names: Vec<String> = result.iter().map(|t| t.to_string()).collect();
     assert_eq!(
-        result,
+        names,
         vec!["RuntimeException"],
         "Should find @throws through 'protected static' modifiers"
     );
@@ -43,8 +45,9 @@ fn test_find_method_throws_tags_without_modifier() {
         "function standalone(): void {}\n",
     );
     let result = throws_analysis::find_method_throws_tags(content, "standalone");
+    let names: Vec<String> = result.iter().map(|t| t.to_string()).collect();
     assert_eq!(
-        result,
+        names,
         vec!["LogicException"],
         "Should find @throws on a standalone function (no modifier)"
     );
@@ -136,7 +139,7 @@ fn test_find_inline_throws_annotations_in_catch() {
     "#;
     let result = throws_analysis::find_inline_throws_annotations(body);
     // Raw names are returned; short-name extraction happens in detect_catch_context
-    let names: Vec<&str> = result.iter().map(|t| t.type_name.as_str()).collect();
+    let names: Vec<String> = result.iter().map(|t| t.type_name.to_string()).collect();
     assert_eq!(
         names,
         vec!["ModelNotFoundException", "App\\Exceptions\\AuthException"]
@@ -152,7 +155,7 @@ fn test_find_inline_throws_multiline_docblock_in_catch() {
         doStuff();
     "#;
     let result = throws_analysis::find_inline_throws_annotations(body);
-    let names: Vec<&str> = result.iter().map(|t| t.type_name.as_str()).collect();
+    let names: Vec<String> = result.iter().map(|t| t.type_name.to_string()).collect();
     assert_eq!(names, vec!["RuntimeException"]);
 }
 

src/completion/handler.rs

@@ -327,8 +327,7 @@ impl Backend {
             // Named arg items are always valid alongside normal
             // completions, so collect them here and merge them into
             // whatever strategy wins below.
-            let named_arg_items =
-                self.collect_named_arg_items(&uri, &content, position, &ctx);
+            let named_arg_items = self.collect_named_arg_items(&uri, &content, position, &ctx);
 
             // ── String context detection ────────────────────────────
             // Classify once and use throughout the remaining pipeline.
@@ -397,7 +396,10 @@ impl Backend {
 
             // ── Smart catch clause completion ───────────────────────
             if let Some(response) = self.try_catch_completion(&content, position, &ctx, &uri) {
-                return Ok(Some(merge_named_args_into_response(response, named_arg_items)));
+                return Ok(Some(merge_named_args_into_response(
+                    response,
+                    named_arg_items,
+                )));
             }
 
             // ── `throw new` completion ──────────────────────────────
@@ -417,7 +419,10 @@ impl Backend {
             if let Some(response) =
                 self.try_class_constant_function_completion(&content, position, &ctx, &uri)
             {
-                return Ok(Some(merge_named_args_into_response(response, named_arg_items)));
+                return Ok(Some(merge_named_args_into_response(
+                    response,
+                    named_arg_items,
+                )));
             }
 
             // No strategy matched, but we may still have named arg items.
@@ -726,9 +731,8 @@ impl Backend {
         // from incomplete code).
         let na_ctx = match self
             .detect_named_arg_from_symbol_map(uri, content, position)
-            .or_else(|| {
-                crate::completion::named_args::detect_named_arg_context(content, position)
-            }) {
+            .or_else(|| crate::completion::named_args::detect_named_arg_context(content, position))
+        {
             Some(ctx) => ctx,
             None => return Vec::new(),
         };
@@ -784,8 +788,11 @@ impl Backend {
         // expression that is itself an argument, named-arg completion
         // for the outer call must not fire — the user wants normal
         // value completion, not parameter names.
-        if cursor_inside_nested_bracket(content, cs.args_start as usize, cursor_byte_offset as usize)
-        {
+        if cursor_inside_nested_bracket(
+            content,
+            cs.args_start as usize,
+            cursor_byte_offset as usize,
+        ) {
             return None;
         }
 

src/completion/phpdoc/generation.rs

@@ -1820,7 +1820,8 @@ fn build_throws_import_edits(
     let mut edits = Vec::new();
 
     for exc in &uncaught {
-        if let Some(fqn) = throws_analysis::resolve_exception_fqn(exc, use_map, file_namespace)
+        let exc_str = exc.to_string();
+        if let Some(fqn) = throws_analysis::resolve_exception_fqn(&exc_str, use_map, file_namespace)
             && !throws_analysis::has_use_import(content, &fqn)
             && let Some(edit) = build_use_edit(&fqn, &use_block, file_namespace)
         {

src/completion/phpdoc/mod.rs

@@ -577,8 +577,9 @@ pub fn build_phpdoc_completions(
                 let existing_throws = find_existing_throws_tags(content, position);
 
                 // Filter out already-documented throws
-                let missing: Vec<&String> = uncaught
+                let missing: Vec<String> = uncaught
                     .iter()
+                    .map(|t| t.to_string())
                     .filter(|t| {
                         !existing_throws
                             .iter()
@@ -596,7 +597,7 @@ pub fn build_phpdoc_completions(
                         // Build an auto-import edit if the exception type
                         // isn't already imported.
                         let additional_edits = throws_analysis::resolve_exception_fqn(
-                            exc_type,
+                            exc_type.as_str(),
                             use_map,
                             file_namespace,
                         )

src/completion/resolver.rs

@@ -1047,7 +1047,7 @@ pub(crate) enum SubjectOutcome {
     /// (e.g. `int`, `string`, `bool|int`) with null stripped.
     Scalar(PhpType),
     /// Subject resolved to a class name that couldn't be loaded.
-    UnresolvableClass(String),
+    UnresolvableClass(PhpType),
     /// Subject type could not be resolved — no class information
     /// available.
     Untyped,
@@ -1272,7 +1272,7 @@ fn resolve_call_scalar_return(
 fn check_unresolvable_class_name(
     raw_type: &PhpType,
     class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
-) -> Option<String> {
+) -> Option<PhpType> {
     if raw_type.all_members_scalar() {
         return None;
     }
@@ -1281,7 +1281,7 @@ fn check_unresolvable_class_name(
     let base = effective.base_name()?;
 
     if class_loader(base).is_none() {
-        Some(base.to_string())
+        Some(PhpType::Named(base.to_string()))
     } else {
         None
     }