Add invalid class-like kind diagnostics and fix bulk unused import

action in braced namespaces

Author: AJenbo

docs/CHANGELOG.md

@@ -9,10 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Invalid class-like kind diagnostics.** Flags class-like names used in positions where their kind is guaranteed to fail at runtime: `new` on abstract classes, interfaces, traits, or enums; `extends` on a final class, interface, or trait; `implements` with a non-interface; trait `use` with a non-trait; `instanceof` with a trait (always false); `catch` with a non-Throwable type or trait; and traits in native type-hint positions. Severity follows PHP semantics: unconditional fatal errors are Error, runtime-conditional failures are Warning.
 - **Nested array shape inference from multi-level key assignments.** Assignments like `$b['a']['b'] = 'x'` now produce a nested array shape type (`array{a: array{b: string}}`), enabling array key completion and hover for arrays built incrementally with nested keys. Previously only single-level key assignments were tracked.
 
 ### Fixed
 
+- **"Remove all unused imports" missing in braced namespaces.** The bulk action now appears when the cursor is on a `use` line inside a `namespace Foo { … }` block. Previously the brace-depth heuristic treated these as trait-use statements inside a class body.
 - **False-positive undefined variable on nested array access assignment.** `$b['a']['a'] = 'a'` no longer flags `$b` as undefined. The scope collector now correctly propagates write context through nested `ArrayAccess` and `ArrayAppend` expressions, so the base variable is recognized as defined.
 
 ## [0.7.0] - 2026-04-08

docs/todo.md

@@ -33,8 +33,6 @@ within the same impact tier.
 
 | #   | Item                                                                                                                         | Impact      | Effort |
 | --- | ---------------------------------------------------------------------------------------------------------------------------- | ----------- | ------ |
-|     | Clear [refactoring gate](todo/refactor.md)                                                                                   | —           | —      |
-| D11 | [Invalid class-like kind in context](todo/diagnostics.md#d11-invalid-class-like-kind-in-context)                             | Medium      | Low    |
 | F10 | [Linked editing ranges](todo/lsp-features.md#f10-linked-editing-ranges)                                                      | Medium      | Low    |
 | A36 | [Import all missing classes](todo/actions.md#a36-import-all-missing-classes) (bulk import)                                    | Medium      | Low    |
 | F6  | [Machine-readable CLI output formats](todo/lsp-features.md#f6-machine-readable-cli-output-formats) (`--format github\|json`) | Medium      | Low    |

docs/todo/diagnostics.md

@@ -230,84 +230,6 @@ with `command`, `timeout`, and tool-specific options mirroring the
 
 ---
 
-## D11. Invalid class-like kind in context
-
-**Impact: Medium · Effort: Low**
-
-PHP accepts certain class-like names syntactically in positions where
-they are guaranteed to fail at runtime or be silently useless. These
-are not parse errors, so `php -l` does not catch them. PHPStan catches
-some of these (e.g. `new` on an abstract class) but not all. A
-dedicated diagnostic rule can flag them all consistently using the
-same context knowledge that the completion system already applies
-(the `ClassNameContext` enum and `TypeHint` variant).
-
-The rule table:
-
-| Position                   | What to flag                                  | Severity | Runtime behavior                          |
-| -------------------------- | --------------------------------------------- | -------- | ----------------------------------------- |
-| `new X`                    | Abstract class, interface, trait, enum        | Error    | Fatal error: Cannot instantiate           |
-| `throw new X`              | Non-Throwable class                           | Error    | Fatal error: Cannot throw                 |
-| `throw new X`              | Abstract class, interface, trait, enum        | Error    | Fatal error: Cannot instantiate           |
-| `$x instanceof X`          | Trait                                         | Warning  | Always evaluates to `false`               |
-| `catch (X $e)`             | Trait                                         | Warning  | Never catches anything                    |
-| `catch (X $e)`             | Non-Throwable class or interface              | Error    | Never catches, uncaught exception crashes |
-| `class A extends X`        | Final class                                   | Error    | Fatal error: Cannot extend final class    |
-| `class A implements X`     | Class, trait, enum                            | Error    | Fatal error: Not an interface             |
-| `interface A extends X`    | Class, trait, enum                            | Error    | Fatal error: Not an interface             |
-| `class A { use X; }`       | Class, interface, enum                        | Error    | Fatal error: Not a trait                  |
-| `function f(X $p)`, `): X` | Trait                                         | Warning  | Type check always fails                   |
-| `public X $prop`           | Trait                                         | Warning  | Type check always fails                   |
-| `@param X`, `@return X`    | Trait                                         | Hint     | Documents unsatisfiable constraint        |
-| `@throws X`                | Non-Throwable class or interface, trait, enum | Hint     | Documents impossible throw                |
-
-**Why Warning for traits in type positions (not Error).** PHP does not
-reject the code at parse time or class loading time. The fatal
-`TypeError` only occurs at the specific call site when a value actually
-reaches the type check. Code paths that are never executed with a
-mismatched value will run without error. This is different from `class
-extends final` which crashes unconditionally when the class is loaded.
-
-**Why Hint for PHPDoc.** PHPDoc has no runtime enforcement at all. A
-trait in `@param` is useless documentation but does not crash anything.
-This aligns with the severity philosophy: hints are for code quality
-issues that static analysis enthusiasts care about.
-
-**Implementation:**
-
-1. During AST extraction (or as a post-parse diagnostic pass), walk
-   class declarations and check `extends`, `implements`, and `use`
-   references against loaded `ClassInfo` entries. If the referenced
-   class is loaded and its kind does not match the position, emit
-   a diagnostic.
-
-2. For `new X`, `throw new X`, `instanceof X`, and `catch (X)`, scan
-   expression nodes in method bodies. Resolve `X` to a `ClassInfo`
-   (if loaded) and check kind/modifier compatibility.
-
-3. For native type hints, scan parameter types, return types, and
-   property types. Resolve each class-like reference and check for
-   trait kind.
-
-4. For PHPDoc types, scan `@param`, `@return`, `@var`, and `@throws`
-   tags. Resolve each class-like reference. Flag traits in type
-   positions and non-Throwable types in `@throws`.
-
-5. Only flag references where the target class is loaded (in
-   `ast_map` or stubs). Unknown classes should not be flagged here
-   (that is D4's job). This avoids false positives from unloaded
-   classmap entries where the kind is unknown.
-
-**Relationship to completion filtering.** The completion context
-detector (`ClassNameContext` enum in `class_completion.rs`) and this
-diagnostic rule use the same underlying knowledge (which kinds are
-valid in which positions). The completion system already prevents the
-user from inserting a wrong kind; this diagnostic catches wrong kinds
-that are already in the code. Both should share the same rule table
-to stay in sync.
-
----
-
 ## D12. Mago linter integration (optional diagnostics)
 
 **Impact: Medium · Effort: Medium**

example.php

@@ -19,17 +19,10 @@
 namespace Demo {
 
 use Attribute;
-use Bug10298\PropAttr;
-use Bug5607\Cl;
 use Closure;
 use Demo\ValidationException;
 use Demo\NotFoundException;
 use Exception;
-use Override;
-use PHPStan\DependencyInjection\GenerateFactory;
-use PHPStan\Reflection\ClassReflection;
-use ReadonlyPropertyAssignPhpDoc\C;
-use Stringable;
 use Demo\UserProfile as Profile;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -3332,6 +3325,44 @@ public function demo(array $pens): void
 }
 
 
+// ── Invalid Class-Like Kind Diagnostics ─────────────────────────────────────
+// PHPantom flags class-like names used in positions where their kind is
+// guaranteed to fail at runtime.  Open demo() and look for Error/Warning
+// squiggles on the class names.
+
+class InvalidClassKindDemo
+{
+    public function demo(): void
+    {
+        // Error: cannot instantiate abstract class
+        $a = new ScaffoldingAbstractShape();
+
+        // Error: cannot instantiate enum
+        $b = new Status();
+
+        // Warning: instanceof with a trait always evaluates to false
+        $x = new Pen('test');
+        $result = $x instanceof JsonSerializer;
+
+        // Warning: trait in a type hint will always fail type checking
+        $this->acceptTrait(new Pen('test'));
+    }
+
+    private function acceptTrait(JsonSerializer $x): JsonSerializer
+    {
+        return $x;
+    }
+
+    // These also produce diagnostics but would crash at class-load time,
+    // so they are shown as comments only:
+    //
+    //   class Bad1 extends ScaffoldingDrawable {}     // Error: interface in extends
+    //   class Bad2 implements Pen {}                   // Error: class in implements
+    //   class Bad3 { use ScaffoldingDrawable; }        // Error: interface in trait use
+    //   class Bad4 extends ScaffoldingAbstractShape {} // OK: abstract classes CAN be extended
+}
+
+
 // ═══════════════════════════════════════════════════════════════════════════
 // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 // ┃  SCAFFOLDING — Supporting definitions below this line.              ┃

src/code_actions/import_class.rs

@@ -68,7 +68,7 @@ impl Backend {
             }
 
             let (ref_name, is_fqn) = match &span.kind {
-                SymbolKind::ClassReference { name, is_fqn } => (name.as_str(), *is_fqn),
+                SymbolKind::ClassReference { name, is_fqn, .. } => (name.as_str(), *is_fqn),
                 _ => continue,
             };
 

src/code_actions/remove_unused_import.rs

@@ -199,20 +199,37 @@ fn cursor_on_use_import_line(content: &str, line: u32) -> bool {
         return false;
     }
 
-    // Heuristic: if we're inside a class/trait/enum body (brace depth > 0
-    // at this line), this is a trait `use`, not a namespace import.
-    let mut depth: i32 = 0;
+    // Heuristic: if we're inside a class/trait/enum body, this is a
+    // trait `use`, not a namespace import.  We track brace depth and
+    // account for braced `namespace Foo { … }` blocks (where depth 1
+    // is still "top level" for import purposes).
+    let mut depth: usize = 0;
+    let mut namespace_brace_depth: Option<usize> = None;
     for l in &lines[..idx] {
-        for ch in l.chars() {
+        let code = l.split("//").next().unwrap_or(l);
+        let code = code.split('#').next().unwrap_or(code);
+        let ltrimmed = l.trim_start();
+
+        if ltrimmed.starts_with("namespace ") && code.contains('{') {
+            namespace_brace_depth = Some(depth);
+        }
+
+        for ch in code.chars() {
             match ch {
                 '{' => depth += 1,
-                '}' => depth -= 1,
+                '}' => {
+                    depth = depth.saturating_sub(1);
+                    if namespace_brace_depth == Some(depth) {
+                        namespace_brace_depth = None;
+                    }
+                }
                 _ => {}
             }
         }
     }
 
-    depth <= 0
+    let top_level_depth = namespace_brace_depth.map_or(0, |d| d + 1);
+    depth <= top_level_depth
 }
 
 /// Build a `TextEdit` that deletes the full line(s) covered by `range`,
@@ -847,14 +864,10 @@ mod tests {
     #[test]
     fn cursor_on_use_in_braced_namespace_returns_true() {
         let content = "<?php\nnamespace App {\n    use Foo\\Bar;\n}\n";
-        // Brace depth at line 2 is 1 (opened by namespace), but namespace
-        // braces are different from class braces.  In practice, the
-        // heuristic counts all braces equally.  For braced namespaces the
-        // depth is 1 which means the check `depth <= 0` fails.
-        // This is a known limitation — braced namespaces are rare in
-        // modern PHP.  The test documents the current behavior.
-        // If we later improve the heuristic, flip this assertion.
-        assert!(!cursor_on_use_import_line(content, 2));
+        // Brace depth at line 2 is 1 (opened by namespace), but
+        // namespace braces are tracked separately so depth 1 inside a
+        // braced namespace is still "top level" for import purposes.
+        assert!(cursor_on_use_import_line(content, 2));
     }
 
     #[test]

src/definition/resolve.rs

@@ -239,7 +239,7 @@ impl Backend {
                 self.resolve_self_static_parent(uri, content, position, *ssp_kind)
             }
 
-            SymbolKind::ClassReference { name, is_fqn } => {
+            SymbolKind::ClassReference { name, is_fqn, .. } => {
                 self.resolve_class_reference(uri, content, name, *is_fqn, cursor_offset)
             }
 

src/diagnostics/deprecated.rs

@@ -76,7 +76,7 @@ impl Backend {
         for span in &symbol_map.spans {
             match &span.kind {
                 // ── Class references (type hints, new Foo, extends, etc.) ─
-                SymbolKind::ClassReference { name, is_fqn } => {
+                SymbolKind::ClassReference { name, is_fqn, .. } => {
                     // Prefer mago-names byte-offset lookup when available —
                     // it applies PHP's full name resolution rules.  Fall
                     // back to the legacy resolve_to_fqn helper otherwise.