Fix some keyword suggestions

Author: AJenbo

docs/todo/completion.md

@@ -360,7 +360,50 @@ This is a small quality-of-life improvement: deprecated classes would
 show with a strikethrough in the completion menu across all sources,
 not just same-namespace ones.
 
-## C11. Smarter member ordering after `->` / `::`
+## C11. PSR-4 namespace completion
+
+**Impact: Medium · Effort: Low**
+
+When the user types `namespace ` at the top of a file, suggest the
+fully qualified namespace derived from the file's path and the
+project's PSR-4 autoload mapping. For example, typing `namespace T`
+in `tests/Unit/Reorder/SuspendScheduleTest.php` should offer
+`Tests\Unit\Reorder` as a completion item that inserts the full
+namespace followed by a semicolon.
+
+The classmap scanner already knows every PSR-4 prefix-to-directory
+mapping, and the class-declaration-name completion already infers a
+class name from the filename. The namespace case is the directory
+counterpart: strip the filename, walk the remaining path segments
+back to the PSR-4 root, and prepend the configured namespace prefix.
+
+**Implementation:**
+
+1. **Detect `namespace` context** — the keyword context already
+   identifies `ClassNameContext::NamespaceDeclaration`. The handler
+   currently delegates to `build_namespace_completions` which returns
+   existing namespace names from the index. Add a new code path (or
+   augment the existing one) that also computes the PSR-4-derived
+   namespace for the current file.
+
+2. **Compute the expected namespace** — given the current file's URI
+   and the project's PSR-4 map (`autoload_map`), find the matching
+   prefix, strip it from the file path, convert directory separators
+   to `\`, and drop the filename. This is essentially
+   `filename_class_name` but for directories.
+
+3. **Build the completion item** — offer the computed namespace with
+   high sort priority (above existing namespace names from the
+   index). Insert text should include the trailing `;`. If the
+   computed namespace matches what the user has already partially
+   typed, filter normally.
+
+Intelephense already does this, so users migrating from it will
+expect the behavior.
+
+---
+
+## C12. Smarter member ordering after `->` / `::`
 
 **Impact: Medium · Effort: needs planning**
 

src/completion/context/type_hint_completion.rs

@@ -160,12 +160,33 @@ pub(crate) fn detect_type_hint_context(
         if partial.is_empty() {
             return None;
         }
-        // Make sure the partial is NOT a keyword that forms part of a
-        // function declaration (e.g. `public function`).  If the user
-        // has typed `function` or `fn` we should not offer type hints.
-        let partial_lower = partial.to_lowercase();
-        if partial_lower == "function" || partial_lower == "fn" {
-            return None;
+        // If the partial starts with a lowercase letter and is a prefix
+        // of any member-declaration keyword, defer to keyword completion
+        // so that e.g. `public fu` offers `function` rather than type
+        // hints.  Partials starting with an uppercase letter (e.g. `Us`,
+        // `User`) are type names, not keywords, so they skip this check.
+        if partial.starts_with(|c: char| c.is_ascii_lowercase()) {
+            const MEMBER_DECLARATION_KEYWORDS: &[&str] = &[
+                "function",
+                "fn",
+                "const",
+                "static",
+                "final",
+                "abstract",
+                "readonly",
+                "public",
+                "protected",
+                "private",
+                "use",
+                "class",
+            ];
+            let partial_lower = partial.to_lowercase();
+            let is_keyword_prefix = MEMBER_DECLARATION_KEYWORDS
+                .iter()
+                .any(|kw| kw.starts_with(partial_lower.as_str()));
+            if is_keyword_prefix {
+                return None;
+            }
         }
         return Some(TypeHintContext {
             partial,

src/completion/context/type_hint_completion_tests.rs

@@ -276,6 +276,135 @@ fn partial_is_function_keyword_after_modifier() {
     assert!(ctx.is_none());
 }
 
+// ── Partial keyword prefixes after modifiers ────────────────────
+
+#[test]
+fn partial_fu_after_public_is_not_type_hint() {
+    // `public fu` — "fu" is a prefix of "function", should defer to keyword completion.
+    let src = "<?php\nclass Foo {\n    public fu\n}";
+    let ctx = detect(src, 2, 13);
+    assert!(
+        ctx.is_none(),
+        "partial 'fu' is a prefix of 'function' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_fun_after_public_is_not_type_hint() {
+    let src = "<?php\nclass Foo {\n    public fun\n}";
+    let ctx = detect(src, 2, 14);
+    assert!(
+        ctx.is_none(),
+        "partial 'fun' is a prefix of 'function' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_func_after_public_is_not_type_hint() {
+    let src = "<?php\nclass Foo {\n    public func\n}";
+    let ctx = detect(src, 2, 15);
+    assert!(
+        ctx.is_none(),
+        "partial 'func' is a prefix of 'function' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_con_after_public_is_not_type_hint() {
+    // `public con` — "con" is a prefix of "const", should defer to keyword completion.
+    let src = "<?php\nclass Foo {\n    public con\n}";
+    let ctx = detect(src, 2, 14);
+    assert!(
+        ctx.is_none(),
+        "partial 'con' is a prefix of 'const' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_st_after_public_is_not_type_hint() {
+    // `public st` — "st" is a prefix of "static", should defer to keyword completion.
+    let src = "<?php\nclass Foo {\n    public st\n}";
+    let ctx = detect(src, 2, 13);
+    assert!(
+        ctx.is_none(),
+        "partial 'st' is a prefix of 'static' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_f_after_public_is_not_type_hint() {
+    // `public f` — "f" is a prefix of "function", "fn", "final".
+    let src = "<?php\nclass Foo {\n    public f\n}";
+    let ctx = detect(src, 2, 12);
+    assert!(
+        ctx.is_none(),
+        "partial 'f' is a prefix of 'function'/'fn'/'final' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_cl_after_readonly_at_top_level_is_not_type_hint() {
+    // `readonly cl` — "cl" is a prefix of "class", should defer to keyword completion.
+    let src = "<?php\nreadonly cl";
+    let ctx = detect(src, 1, 12);
+    assert!(
+        ctx.is_none(),
+        "partial 'cl' is a prefix of 'class' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_ab_after_public_is_not_type_hint() {
+    // `public ab` — "ab" is a prefix of "abstract".
+    let src = "<?php\nclass Foo {\n    public ab\n}";
+    let ctx = detect(src, 2, 13);
+    assert!(
+        ctx.is_none(),
+        "partial 'ab' is a prefix of 'abstract' and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_str_after_public_is_type_hint() {
+    // `public str` — "str" is NOT a prefix of any declaration keyword,
+    // so it should trigger type hints (e.g. offering `string`).
+    let src = "<?php\nclass Foo {\n    public str\n}";
+    let ctx = detect(src, 2, 14).unwrap();
+    assert_eq!(ctx.partial, "str");
+}
+
+#[test]
+fn partial_us_after_public_is_type_hint() {
+    // `public Us` — "Us" is not a prefix of any declaration keyword,
+    // so it should trigger type hints (e.g. offering `UserService`).
+    let src = "<?php\nclass Foo {\n    public Us\n}";
+    let ctx = detect(src, 2, 13).unwrap();
+    assert_eq!(ctx.partial, "Us");
+}
+
+#[test]
+fn partial_fn_after_public_is_not_type_hint() {
+    // `public fn` — "fn" is an exact match for the keyword.
+    let src = "<?php\nclass Foo {\n    public fn\n}";
+    let ctx = detect(src, 2, 13);
+    assert!(
+        ctx.is_none(),
+        "partial 'fn' matches declaration keyword and should not trigger type hints"
+    );
+}
+
+#[test]
+fn partial_use_after_public_is_not_type_hint() {
+    // Inside a class, `public use` — "use" is a declaration keyword (trait import).
+    // Note: not valid PHP but the keyword check should still exclude it.
+    let src = "<?php\nclass Foo {\n    public use\n}";
+    let ctx = detect(src, 2, 14);
+    assert!(
+        ctx.is_none(),
+        "partial 'use' matches declaration keyword and should not trigger type hints"
+    );
+}
+
 // ── Native types constant ───────────────────────────────────────
 
 #[test]