feat: add reference count inlay hints

Show reference counts for classes, enums, interfaces, traits, methods,
properties, and constants as inlay hints instead of non-actionable code
lenses. Interface and abstract class declarations also show implementation
counts. Code lenses remain reserved for actionable prototype navigation.

The hints omit private members, magic methods, and overridden members to
avoid noisy or misleading counts, while still showing zero-reference hints
so users can distinguish unused symbols from missing data.

Go-to-definition on overridden declarations now follows methods,
properties, and constants to the nearest parent, trait, or interface
prototype where applicable.

Use a single all-targets Clippy invocation in CI and let agent docs prefer
clippy --fix so automated changes apply safe lint suggestions before
formatting.

Closes #140

Author: calebdw

.github/workflows/ci.yml

@@ -34,8 +34,7 @@ jobs:
           mkdir -p .cargo
           printf '[target.%s]\nrustflags = ["-C", "link-arg=-fuse-ld=mold"]\n' "$CARGO_BUILD_TARGET" >> .cargo/config.toml
       - run: cargo fmt --check
-      - run: cargo clippy -- -D warnings
-      - run: cargo clippy --tests -- -D warnings
+      - run: cargo clippy --all-targets -- -D warnings
 
   test:
     name: Test

AGENTS.md

@@ -53,13 +53,11 @@ round it out.
 Always run these checks before considering any change complete:
 
 ```bash
-cargo clippy -- -D warnings
-cargo clippy --tests -- -D warnings
+cargo clippy --fix --allow-dirty -- -D warnings
 cargo fmt
 ```
 
-Clippy runs twice: once for library code, once including tests. Run
-`cargo fmt` after clippy, not before -- clippy fixes can affect
+Run `cargo fmt` after clippy, not before -- clippy fixes can affect
 formatting.
 
 ## Contributing Guidelines

docs/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **`@phpstan-ignore` identifiers are highlighted and completed.** PHPStan ignore comments now highlight the `@phpstan-ignore` tag and each listed error identifier in both docblocks and ordinary `//` comments. Identifier completion works inside the comma-separated ignore list, using PHPStan diagnostic codes already seen in the current file while staying out of per-code parenthesized reasons. Contributed by @calebdw.
 - **Parent member override completion.** Typing a method name after `function` in a class body (for example `protected function get`) now suggests public and protected methods from parent classes and interfaces that can still be overridden or implemented, inserting a full signature snippet. The same flow suggests parent properties after `$` (for example `protected $tit`) and parent constants after `const`. Snippets insert `#[\Override]` above methods on PHP 8.3+, properties on PHP 8.5+, and constants on PHP 8.6+ (from `composer.json` / `config.platform.php`). Private members and ones already defined on the class are omitted. Contributed by @calebdw.
+- **Reference and implementation count inlay hints.** Classes, interfaces, traits, enums, methods, properties, and constants now show reference counts (e.g. "3 references") as inlay hints. Interfaces and abstract classes additionally show implementation counts (e.g. "2 implementations"). Counts are derived from the cross-file reference index and the go-to-implementation reverse inheritance index, so they are fast even on large codebases. Private members, magic methods, and overridden members are omitted to keep the annotations focused. Contributed by @calebdw.
 - **Trait member override completion.** Typing a method or property name after `function` or `$` in a class that uses a trait now suggests the trait's public and protected members as override candidates. Unlike parent/interface overrides, trait method replacements do not insert `#[\Override]` (which would be a compile error for trait-only methods). Classes that only use traits without extending a parent or implementing an interface also receive suggestions. Contributed by @calebdw.
 - **Laravel schema dumps power Eloquent model properties.** PHPantom now scans Laravel database schema dumps from `database/schema` by default, reads `config/database.php` for connection drivers/defaults, and uses the parsed columns to synthesize Eloquent model properties with database types, nullability, and defaults in hover. Schema lookup respects model `$connection`, `$table`, Laravel `Connection`/`Table` attributes, dynamic table/connection overrides, and reloads when schema files or related config change. Contributed by @calebdw.
 - **Laravel migration scanning for Eloquent model properties.** PHPantom now parses Laravel migration files to infer database columns when schema dumps are not available or to overlay changes on top of dumps. Migrations are discovered from any non-vendor `database/migrations` directory (including nested modules like `modules/billing/database/migrations`), applied in global filename order, and support named and anonymous migration classes, `$connection` properties, `Schema::connection()` calls, `Blueprint::after()` nested closures, `virtualAs`/`storedAs` generated columns, and custom Blueprint macros registered via the existing macro scanner. Migration scanning is incremental: editing a single migration re-reads only that file and replays the cached plan over the base schema without re-reading other files. Configure with `[laravel.migrations] enabled` and `paths` in `.phpantom.toml`. Contributed by @calebdw.
@@ -42,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - **Go-to-definition on overriding methods jumps to the parent declaration.** When the cursor is on a method definition that overrides a parent or implements an interface method, go-to-definition now navigates to the prototype declaration instead of returning call-site references. Similarly, go-to-definition on a class name jumps to the parent class when one exists. Methods and classes that don't override anything still show usages as before. Contributed by @calebdw.
+- **Go-to-definition on overridden properties and constants jumps to the prototype declaration.** Declaration-site navigation now follows overridden properties and constants to the nearest parent or trait declaration, matching the override behavior for methods. Contributed by @calebdw.
 - **Code lens navigation works on Cursor, VSCodium, Neovim, and other editors.** Clicking a code lens annotation (e.g. "overrides Parent::method") now uses the standard `window/showDocument` LSP request instead of editor-specific commands (`vscode.open`, `editor.action.showReferences`) that only worked on VS Code. Contributed by @calebdw.
 - **Go-to-implementation works when interface and class share the same short name.** An interface and its implementing class in different namespaces but with the same class name (e.g. `App\Contracts\HttpClient` and `App\Foo\HttpClient`) now resolves correctly instead of returning no results. Contributed by @calebdw.
 - **Static method calls resolve return types as accurately as instance calls.** `Foo::bar()` previously missed inference that `$foo->bar()` already had: return types behind a `@phpstan-type` alias, inherited return types substituted through a generic interface or trait, and the `__callStatic()` magic-method fallback. These now resolve the same way for both call styles.

docs/CONTRIBUTING.md

@@ -14,8 +14,7 @@ All six CI checks must pass with zero warnings and zero failures:
 
 ```bash
 cargo test
-cargo clippy -- -D warnings
-cargo clippy --tests -- -D warnings
+cargo clippy --all-targets -- -D warnings
 cargo fmt --check
 php -l examples/demo.php
 php -d zend.assertions=1 examples/demo.php

src/definition/resolve.rs

@@ -18,17 +18,25 @@ use std::sync::Arc;
 use crate::symbol_map::VarDefKind;
 use tower_lsp::lsp_types::*;
 
-use super::member::{MemberAccessHint, MemberDefinitionCtx};
+use super::member::{MemberAccessHint, MemberDefinitionCtx, MemberKind};
 use super::point_location;
 use crate::Backend;
 use crate::class_lookup::find_class_at_offset;
 use crate::composer;
 use crate::symbol_map::{SelfStaticParentKind, SymbolKind};
 use crate::text_position::position_to_offset;
-use crate::types::{AccessKind, ClassInfo};
+use crate::types::{AccessKind, ClassInfo, MAX_INHERITANCE_DEPTH};
 use crate::util::short_name;
 use crate::virtual_members::laravel;
 
+struct MemberPrototypeSearch<'a> {
+    member_name: &'a str,
+    kind: MemberKind,
+    uri: &'a str,
+    content: &'a str,
+    class_loader: &'a dyn Fn(&str) -> Option<Arc<ClassInfo>>,
+}
+
 impl Backend {
     /// Handle a "go to definition" request.
     ///
@@ -266,13 +274,27 @@ impl Backend {
                 .resolve_class_reference(uri, content, name, *is_fqn, cursor_offset)
                 .map(|loc| vec![loc]),
 
-            SymbolKind::MemberDeclaration { name, .. } => {
+            SymbolKind::MemberDeclaration { name, is_static } => {
                 // If this method/property overrides a parent or implements
                 // an interface member, jump to the prototype declaration.
                 let ctx = self.file_context(uri);
                 let class_loader = self.class_loader(&ctx);
                 let current_class =
                     crate::class_lookup::find_class_at_offset(&ctx.classes, cursor_offset);
+                if let Some(cls) = current_class
+                    && let Some(kind) = self.infer_member_declaration_kind(cls, name, *is_static)
+                    && let Some(loc) = self.resolve_member_declaration_prototype(
+                        uri,
+                        content,
+                        cls,
+                        name,
+                        kind,
+                        &class_loader,
+                    )
+                {
+                    return Some(vec![loc]);
+                }
+
                 if let Some(cls) = current_class
                     && let Some(locs) =
                         self.resolve_reverse_implementation(uri, content, cls, name, &class_loader)
@@ -355,6 +377,210 @@ impl Backend {
         }
     }
 
+    fn infer_member_declaration_kind(
+        &self,
+        class: &ClassInfo,
+        member_name: &str,
+        is_static: bool,
+    ) -> Option<MemberKind> {
+        if is_static
+            && class
+                .constants
+                .iter()
+                .any(|c| c.name == member_name && c.visibility != crate::types::Visibility::Private)
+        {
+            return Some(MemberKind::Constant);
+        }
+
+        if class.methods.iter().any(|m| {
+            m.name == member_name
+                && m.is_static == is_static
+                && !m.is_virtual
+                && m.visibility != crate::types::Visibility::Private
+        }) {
+            return Some(MemberKind::Method);
+        }
+
+        if class.properties.iter().any(|p| {
+            p.name == member_name
+                && p.is_static == is_static
+                && !p.is_virtual
+                && p.visibility != crate::types::Visibility::Private
+        }) {
+            return Some(MemberKind::Property);
+        }
+
+        None
+    }
+
+    fn resolve_member_declaration_prototype(
+        &self,
+        uri: &str,
+        content: &str,
+        class: &ClassInfo,
+        member_name: &str,
+        kind: MemberKind,
+        class_loader: &dyn Fn(&str) -> Option<Arc<ClassInfo>>,
+    ) -> Option<Location> {
+        let search = MemberPrototypeSearch {
+            member_name,
+            kind,
+            uri,
+            content,
+            class_loader,
+        };
+
+        if let Some(loc) = self.find_member_prototype_in_traits(&class.used_traits, &search, 0) {
+            return Some(loc);
+        }
+
+        let mut current = class.clone();
+        for _ in 0..MAX_INHERITANCE_DEPTH {
+            let Some(parent_name) = current.parent_class else {
+                break;
+            };
+            let Some(parent) = class_loader(&parent_name).map(Arc::unwrap_or_clone) else {
+                break;
+            };
+
+            if self.class_declares_member(&parent, &search)
+                && let Some(loc) = self.member_location(&parent_name, &parent, &search)
+            {
+                return Some(loc);
+            }
+
+            if let Some(loc) = self.find_member_prototype_in_traits(&parent.used_traits, &search, 0)
+            {
+                return Some(loc);
+            }
+
+            current = parent;
+        }
+
+        if matches!(search.kind, MemberKind::Method | MemberKind::Constant) {
+            return self.find_member_prototype_in_interfaces(class, &search);
+        }
+
+        None
+    }
+
+    fn find_member_prototype_in_traits(
+        &self,
+        trait_names: &[crate::atom::Atom],
+        search: &MemberPrototypeSearch<'_>,
+        depth: usize,
+    ) -> Option<Location> {
+        if depth > MAX_INHERITANCE_DEPTH as usize {
+            return None;
+        }
+
+        for trait_name in trait_names {
+            let Some(trait_info) = (search.class_loader)(trait_name).map(Arc::unwrap_or_clone)
+            else {
+                continue;
+            };
+            if self.class_declares_member(&trait_info, search)
+                && let Some(loc) = self.member_location(trait_name, &trait_info, search)
+            {
+                return Some(loc);
+            }
+            if let Some(loc) =
+                self.find_member_prototype_in_traits(&trait_info.used_traits, search, depth + 1)
+            {
+                return Some(loc);
+            }
+        }
+
+        None
+    }
+
+    fn find_member_prototype_in_interfaces(
+        &self,
+        class: &ClassInfo,
+        search: &MemberPrototypeSearch<'_>,
+    ) -> Option<Location> {
+        let mut current = Some(class.clone());
+        for _ in 0..MAX_INHERITANCE_DEPTH {
+            let cls = current?;
+            for iface_name in &cls.interfaces {
+                if let Some(loc) = self.find_member_prototype_in_interface(iface_name, search, 0) {
+                    return Some(loc);
+                }
+            }
+            current = cls
+                .parent_class
+                .as_deref()
+                .and_then(|parent| (search.class_loader)(parent).map(Arc::unwrap_or_clone));
+        }
+
+        None
+    }
+
+    fn find_member_prototype_in_interface(
+        &self,
+        iface_name: &str,
+        search: &MemberPrototypeSearch<'_>,
+        depth: usize,
+    ) -> Option<Location> {
+        if depth > MAX_INHERITANCE_DEPTH as usize {
+            return None;
+        }
+        let iface = (search.class_loader)(iface_name).map(Arc::unwrap_or_clone)?;
+        if self.class_declares_member(&iface, search)
+            && let Some(loc) = self.member_location(iface_name, &iface, search)
+        {
+            return Some(loc);
+        }
+
+        for parent in &iface.interfaces {
+            if let Some(loc) = self.find_member_prototype_in_interface(parent, search, depth + 1) {
+                return Some(loc);
+            }
+        }
+
+        if let Some(parent) = iface.parent_class
+            && let Some(loc) = self.find_member_prototype_in_interface(&parent, search, depth + 1)
+        {
+            return Some(loc);
+        }
+
+        None
+    }
+
+    fn class_declares_member(&self, class: &ClassInfo, search: &MemberPrototypeSearch<'_>) -> bool {
+        match search.kind {
+            MemberKind::Method => class.methods.iter().any(|m| {
+                m.name == search.member_name
+                    && !m.is_virtual
+                    && m.visibility != crate::types::Visibility::Private
+            }),
+            MemberKind::Property => class.properties.iter().any(|p| {
+                p.name == search.member_name
+                    && !p.is_virtual
+                    && p.visibility != crate::types::Visibility::Private
+            }),
+            MemberKind::Constant => class.constants.iter().any(|c| {
+                c.name == search.member_name && c.visibility != crate::types::Visibility::Private
+            }),
+        }
+    }
+
+    fn member_location(
+        &self,
+        class_name: &str,
+        class: &ClassInfo,
+        search: &MemberPrototypeSearch<'_>,
+    ) -> Option<Location> {
+        let offset = class.member_name_offset(search.member_name, search.kind.as_str())?;
+        let (target_uri, target_content) =
+            self.find_class_file_content(class_name, search.uri, search.content)?;
+        let parsed_uri = Url::parse(&target_uri).ok()?;
+        Some(point_location(
+            parsed_uri,
+            crate::text_position::offset_to_position(&target_content, offset as usize),
+        ))
+    }
+
     /// Resolve a `ClassReference` symbol to its definition.
     ///
     /// Tries same-file lookup (uri_classes_index), then cross-file via PSR-4.

src/diagnostics/workspace.rs

@@ -331,7 +331,6 @@ impl Backend {
                 last_delivery = Instant::now();
             }
         }
-
         done
     }