Fix diagnostics, import actions, and references for global classes

Author: AJenbo

docs/CHANGELOG.md

@@ -38,6 +38,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Missing diagnostics and import actions in files without a namespace.** When a namespaced class (e.g. `Carbon\Carbon`) had already been parsed, using its short name (`Carbon`) in a file without a `namespace` declaration incorrectly resolved against the namespaced class. This suppressed both the "class not found" diagnostic and the "Import" code action. Bare-name lookups now only match classes that are themselves in the global namespace.
+- **Find-references false positives for global classes.** Searching for references to a global-scope class (e.g. `Helper` with no namespace) could include references to unrelated namespaced classes with the same short name (e.g. `App\Helper`). Short-name fallback matching now only applies when the resolved name is unqualified.
 - **Fluent chains only flag the first broken link.** In a chain where the first method does not exist, only that method is flagged instead of every subsequent call receiving its own warning.
 - **Null narrowing from `!== null` checks.** Null-initialized variables guarded by `$var !== null`, `!is_null()`, or bare truthy checks now have `null` narrowed away inside the then-body and in subsequent `&&` operands. Works in chained conditions, ternary expressions, and return statements.
 - **Variables assigned inside `if`/`while` conditions now resolve in the body.** `if ($admin = AdminUser::first())` and `while ($row = nextRow())` register the assignment so the variable has a type inside the branch or loop body.

src/code_actions/import_class.rs

@@ -727,4 +727,292 @@ mod tests {
             "should not offer conflicting import"
         );
     }
+
+    // ── No-namespace file tests ─────────────────────────────────────────
+
+    #[test]
+    fn import_action_offered_in_no_namespace_file_for_new_expression() {
+        let backend = crate::Backend::new_test();
+        let uri = "file:///test.php";
+        // File has NO namespace declaration.
+        let content = "<?php\n\nnew Request();\n";
+
+        backend.update_ast(uri, content);
+
+        {
+            let mut cmap = backend.classmap.write();
+            cmap.insert(
+                "Illuminate\\Http\\Request".to_string(),
+                "/vendor/laravel/framework/src/Illuminate/Http/Request.php".into(),
+            );
+        }
+
+        // Range covering "Request" on line 2.
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier {
+                uri: uri.parse().unwrap(),
+            },
+            range: Range {
+                start: Position::new(2, 4),
+                end: Position::new(2, 11),
+            },
+            context: CodeActionContext {
+                diagnostics: vec![],
+                only: None,
+                trigger_kind: None,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let actions = backend.handle_code_action(uri, content, &params);
+        assert!(
+            actions.iter().any(|a| {
+                if let CodeActionOrCommand::CodeAction(ca) = a {
+                    ca.title.contains("Illuminate\\Http\\Request")
+                } else {
+                    false
+                }
+            }),
+            "expected an import action for Illuminate\\Http\\Request in no-namespace file, got: {:?}",
+            actions
+                .iter()
+                .map(|a| match a {
+                    CodeActionOrCommand::CodeAction(ca) => ca.title.clone(),
+                    CodeActionOrCommand::Command(c) => c.title.clone(),
+                })
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn import_action_offered_in_no_namespace_file_for_static_call() {
+        let backend = crate::Backend::new_test();
+        let uri = "file:///test.php";
+        // File has NO namespace — reproduces issue #59.
+        let content = "<?php\n\nfunction () {\n    return Carbon::now();\n};\n";
+
+        backend.update_ast(uri, content);
+
+        {
+            let mut cmap = backend.classmap.write();
+            cmap.insert(
+                "Carbon\\Carbon".to_string(),
+                "/vendor/nesbot/carbon/src/Carbon/Carbon.php".into(),
+            );
+        }
+
+        // Range covering "Carbon" on line 3 (the class name in Carbon::now()).
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier {
+                uri: uri.parse().unwrap(),
+            },
+            range: Range {
+                start: Position::new(3, 11),
+                end: Position::new(3, 17),
+            },
+            context: CodeActionContext {
+                diagnostics: vec![],
+                only: None,
+                trigger_kind: None,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let actions = backend.handle_code_action(uri, content, &params);
+        assert!(
+            actions.iter().any(|a| {
+                if let CodeActionOrCommand::CodeAction(ca) = a {
+                    ca.title.contains("Carbon\\Carbon")
+                } else {
+                    false
+                }
+            }),
+            "expected an import action for Carbon\\Carbon in no-namespace file, got: {:?}",
+            actions
+                .iter()
+                .map(|a| match a {
+                    CodeActionOrCommand::CodeAction(ca) => ca.title.clone(),
+                    CodeActionOrCommand::Command(c) => c.title.clone(),
+                })
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn import_action_inserts_use_after_php_open_in_no_namespace_file() {
+        let backend = crate::Backend::new_test();
+        let uri = "file:///test.php";
+        let content = "<?php\n\nnew Request();\n";
+
+        backend.update_ast(uri, content);
+
+        {
+            let mut cmap = backend.classmap.write();
+            cmap.insert(
+                "Illuminate\\Http\\Request".to_string(),
+                "/vendor/laravel/framework/src/Illuminate/Http/Request.php".into(),
+            );
+        }
+
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier {
+                uri: uri.parse().unwrap(),
+            },
+            range: Range {
+                start: Position::new(2, 4),
+                end: Position::new(2, 11),
+            },
+            context: CodeActionContext {
+                diagnostics: vec![],
+                only: None,
+                trigger_kind: None,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let actions = backend.handle_code_action(uri, content, &params);
+        let action = actions
+            .iter()
+            .find_map(|a| match a {
+                CodeActionOrCommand::CodeAction(ca)
+                    if ca.title.contains("Illuminate\\Http\\Request") =>
+                {
+                    Some(ca)
+                }
+                _ => None,
+            })
+            .expect("expected import action");
+
+        let edit = action.edit.as_ref().expect("expected workspace edit");
+        let changes = edit.changes.as_ref().expect("expected changes");
+        let file_edits = changes
+            .get(&uri.parse::<Url>().unwrap())
+            .expect("expected edits for the file");
+        assert_eq!(file_edits.len(), 1);
+        assert_eq!(file_edits[0].new_text, "use Illuminate\\Http\\Request;\n");
+        // Should insert after `<?php` (line 1), not line 0.
+        assert_eq!(file_edits[0].range.start.line, 1);
+    }
+
+    #[test]
+    fn no_import_action_for_known_global_class_in_no_namespace_file() {
+        let backend = crate::Backend::new_test();
+        let uri_dep = "file:///dep.php";
+        let content_dep = "<?php\nclass Helper {}\n";
+        backend.update_ast(uri_dep, content_dep);
+
+        {
+            let mut idx = backend.class_index.write();
+            idx.insert("Helper".to_string(), uri_dep.to_string());
+        }
+
+        let uri = "file:///test.php";
+        let content = "<?php\n\nnew Helper();\n";
+        backend.update_ast(uri, content);
+
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier {
+                uri: uri.parse().unwrap(),
+            },
+            range: Range {
+                start: Position::new(2, 4),
+                end: Position::new(2, 10),
+            },
+            context: CodeActionContext {
+                diagnostics: vec![],
+                only: None,
+                trigger_kind: None,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let actions = backend.handle_code_action(uri, content, &params);
+        let import_actions: Vec<_> = actions
+            .iter()
+            .filter(|a| match a {
+                CodeActionOrCommand::CodeAction(ca) => ca.title.starts_with("Import"),
+                _ => false,
+            })
+            .collect();
+        assert!(
+            import_actions.is_empty(),
+            "should not offer import for a known global class in no-namespace file, got: {:?}",
+            import_actions
+                .iter()
+                .map(|a| match a {
+                    CodeActionOrCommand::CodeAction(ca) => ca.title.clone(),
+                    _ => String::new(),
+                })
+                .collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn import_action_offered_when_namespaced_class_in_ast_map() {
+        // Reproduces issue #59: when a namespaced class like `Carbon\Carbon`
+        // is already parsed and in the ast_map, `find_or_load_class("Carbon")`
+        // must NOT match it — the bare name `"Carbon"` is a global-scope
+        // lookup and should not resolve to `Carbon\Carbon`.
+        //
+        // Without the fix, `find_class_in_ast_map("Carbon")` ignores the
+        // namespace filter when `expected_ns` is `None`, so ANY class with
+        // short name `Carbon` matches.  The import action then skips it
+        // thinking "this class resolves in global scope".
+        let backend = crate::Backend::new_test();
+
+        // Parse the dependency file so Carbon\Carbon is in the ast_map.
+        let uri_dep = "file:///vendor/carbon.php";
+        let content_dep = "<?php\nnamespace Carbon;\n\nclass Carbon {}\n";
+        backend.update_ast(uri_dep, content_dep);
+        {
+            let mut idx = backend.class_index.write();
+            idx.insert("Carbon\\Carbon".to_string(), uri_dep.to_string());
+        }
+
+        // The file under edit has NO namespace.
+        let uri = "file:///test.php";
+        let content = "<?php\n\nfunction () {\n    return Carbon::now();\n};\n";
+        backend.update_ast(uri, content);
+
+        // Range covering "Carbon" on line 3.
+        let params = CodeActionParams {
+            text_document: TextDocumentIdentifier {
+                uri: uri.parse().unwrap(),
+            },
+            range: Range {
+                start: Position::new(3, 11),
+                end: Position::new(3, 17),
+            },
+            context: CodeActionContext {
+                diagnostics: vec![],
+                only: None,
+                trigger_kind: None,
+            },
+            work_done_progress_params: Default::default(),
+            partial_result_params: Default::default(),
+        };
+
+        let actions = backend.handle_code_action(uri, content, &params);
+        assert!(
+            actions.iter().any(|a| {
+                if let CodeActionOrCommand::CodeAction(ca) = a {
+                    ca.title.contains("Carbon\\Carbon")
+                } else {
+                    false
+                }
+            }),
+            "expected an import action for Carbon\\Carbon when the namespaced class is in ast_map, got: {:?}",
+            actions
+                .iter()
+                .map(|a| match a {
+                    CodeActionOrCommand::CodeAction(ca) => ca.title.clone(),
+                    CodeActionOrCommand::Command(c) => c.title.clone(),
+                })
+                .collect::<Vec<_>>()
+        );
+    }
 }

src/diagnostics/unknown_classes.rs

@@ -1015,4 +1015,94 @@ mod tests {
             diags.iter().map(|d| &d.message).collect::<Vec<_>>()
         );
     }
+
+    // ── No-namespace file tests ─────────────────────────────────────────
+
+    #[test]
+    fn diagnostic_when_namespaced_class_in_ast_map() {
+        // Reproduces issue #59: when `Carbon\Carbon` is already parsed
+        // and in the ast_map, `find_or_load_class("Carbon")` must NOT
+        // match it — the bare name is a global-scope lookup.  Without
+        // the fix the no-namespace fallback at step 3 resolves the bare
+        // name to the namespaced class, suppressing the diagnostic.
+        let backend = Backend::new_test();
+
+        // Parse the dependency so Carbon\Carbon is in the ast_map.
+        let uri_dep = "file:///vendor/carbon.php";
+        let content_dep = "<?php\nnamespace Carbon;\n\nclass Carbon {}\n";
+        backend.update_ast(uri_dep, content_dep);
+        {
+            let mut idx = backend.class_index.write();
+            idx.insert("Carbon\\Carbon".to_string(), uri_dep.to_string());
+        }
+
+        let uri = "file:///test.php";
+        let content = "<?php\n\nfunction () {\n    return Carbon::now();\n};\n";
+
+        let diags = collect(&backend, uri, content);
+        assert!(
+            diags.iter().any(|d| d.message.contains("Carbon")),
+            "expected unknown-class diagnostic for Carbon even when Carbon\\Carbon is in ast_map, got: {:?}",
+            diags.iter().map(|d| &d.message).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn diagnostic_for_unknown_class_in_no_namespace_file() {
+        // In a file without a namespace, an unresolved class name should
+        // still produce a diagnostic.
+        let backend = Backend::new_test();
+        let uri = "file:///test.php";
+        let content = "<?php\n\nnew Request();\n";
+
+        let diags = collect(&backend, uri, content);
+        assert!(
+            diags.iter().any(|d| d.message.contains("Request")),
+            "expected unknown-class diagnostic for Request in no-namespace file, got: {:?}",
+            diags.iter().map(|d| &d.message).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn diagnostic_for_unknown_static_class_in_no_namespace_file() {
+        // Reproduces issue #59: `Carbon::now()` in a file without a
+        // namespace should emit a diagnostic for unresolved `Carbon`.
+        let backend = Backend::new_test();
+        let uri = "file:///test.php";
+        let content = "<?php\n\nfunction () {\n    return Carbon::now();\n};\n";
+
+        let diags = collect(&backend, uri, content);
+        assert!(
+            diags.iter().any(|d| d.message.contains("Carbon")),
+            "expected unknown-class diagnostic for Carbon in no-namespace file, got: {:?}",
+            diags.iter().map(|d| &d.message).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_imported_class_in_no_namespace_file() {
+        // A `use` statement in a no-namespace file should suppress the
+        // diagnostic, just like in a namespaced file.
+        let backend = Backend::new_test();
+
+        // Register the class so it can be found.
+        let uri_dep = "file:///carbon.php";
+        let content_dep = "<?php\nnamespace Carbon;\n\nclass Carbon {}\n";
+        backend.update_ast(uri_dep, content_dep);
+        {
+            let mut idx = backend.class_index.write();
+            idx.insert("Carbon\\Carbon".to_string(), uri_dep.to_string());
+        }
+
+        let uri = "file:///test.php";
+        let content =
+            "<?php\n\nuse Carbon\\Carbon;\n\nfunction () {\n    return Carbon::now();\n};\n";
+
+        let diags = collect(&backend, uri, content);
+        assert!(
+            !diags.iter().any(|d| d.message.contains("Carbon")),
+            "should not flag imported Carbon class, got: {:?}",
+            diags.iter().map(|d| &d.message).collect::<Vec<_>>()
+        );
+    }
 }