fix: go-to-implementation with same-named interface and class

When an interface and its implementing class shared the same short
name (e.g. App\Contracts\HttpClient and App\Foo\HttpClient),
go-to-implementation returned no results or pointed to the interface
itself instead of the concrete class.

Two places in the implementation resolver compared by short name
instead of fully-qualified name, causing false matches when classes
in different namespaces shared a name:

- class_implements_or_extends excluded any candidate whose short name
  matched the target, even when the FQNs differed.  Now compares by
  FQN only.
- locate_class_declaration looked up the class file by short name, so
  it returned the first file containing that name rather than the
  correct namespace.  Now builds the FQN from the class's namespace
  before lookup.

Closes #279

Author: calebdw

AGENTS.md

@@ -31,10 +31,11 @@ full set of CI checks, testing conventions, and code style rules.
   introduce regressions in startup time or memory usage.
 - **Run the full lint pipeline.** `cargo clippy` and `cargo fmt` must
   pass with zero warnings before every commit. Do not skip this.
-- **Update the changelog.** When a change affects user-visible
-  behaviour, add an entry under `## [Unreleased]` in
-  `docs/CHANGELOG.md`. Write for end users, not developers. Include
-  `Contributed by @username` with the GitHub username of the author.
+- **Update the changelog.** Add an entry under `## [Unreleased]` in
+  `docs/CHANGELOG.md` for bug fixes and new features. Skip purely
+  internal refactors that don't change observable behaviour. Write
+  for end users, not developers. Include `Contributed by @username`
+  with the GitHub username of the author.
 - **Reference issues in commits.** When fixing a GitHub issue, include
   `Closes #123` in the commit message body.
 - **Prefer single tests.** Run individual tests (`cargo test test_name`)

docs/CHANGELOG.md

@@ -40,6 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **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.
 - **Facade static calls keep concrete method return types.** Static calls on Laravel-style facades now resolve missing methods through `getFacadeAccessor()` and facade `@mixin` targets before falling back to `__callStatic()`, so values like `Driver::details()` keep the concrete provider method return type instead of degrading to the facade's broad magic-call return. Contributed by @calebdw.
 - **`class-string<static>` parameters no longer reject sibling subclass constants.** Static helper calls from a shared base class that pass concrete `::class` constants for sibling subclasses no longer report false argument-type mismatches against `class-string<static>`. Contributed by @calebdw.

src/definition/implementation.rs

@@ -994,8 +994,10 @@ impl Backend {
         // Build the FQN of the candidate class for comparison.
         let cls_fqn = crate::util::build_fqn(&cls.name, cls.file_namespace.as_deref());
 
-        // Skip the target class itself.
-        if cls_fqn == target_fqn || cls.name == target_short {
+        // Skip the target class itself — compare by FQN so that
+        // classes in different namespaces that share the same short
+        // name are not incorrectly excluded.
+        if cls_fqn == target_fqn {
             return false;
         }
 
@@ -1231,8 +1233,9 @@ impl Backend {
         current_uri: &str,
         current_content: &str,
     ) -> Option<Location> {
+        let cls_fqn = crate::util::build_fqn(&cls.name, cls.file_namespace.as_deref());
         let (class_uri, class_content) =
-            self.find_class_file_content(&cls.name, current_uri, current_content)?;
+            self.find_class_file_content(&cls_fqn, current_uri, current_content)?;
 
         if cls.keyword_offset == 0 {
             return None;
@@ -1399,4 +1402,57 @@ mod tests {
         );
         assert_eq!(locations[0].uri, user_impl_uri);
     }
+
+    #[test]
+    fn same_short_name_interface_and_implementation_found() {
+        let dir = tempfile::tempdir().expect("temp dir");
+        let src = dir.path().join("src");
+        fs::create_dir_all(src.join("Contracts")).expect("contracts dir");
+        fs::create_dir_all(src.join("Foo")).expect("foo dir");
+
+        let interface_php = concat!(
+            "<?php\n",
+            "namespace App\\Contracts;\n",
+            "interface HttpClient {}\n",
+        );
+        let impl_php = concat!(
+            "<?php\n",
+            "namespace App\\Foo;\n",
+            "use App\\Contracts\\HttpClient as HttpClientInterface;\n",
+            "class HttpClient implements HttpClientInterface {}\n",
+        );
+
+        let interface_path = src.join("Contracts/HttpClient.php");
+        let impl_path = src.join("Foo/HttpClient.php");
+        fs::write(&interface_path, interface_php).expect("interface file");
+        fs::write(&impl_path, impl_php).expect("impl file");
+
+        let backend = Backend::new_test_with_workspace(dir.path().to_path_buf(), Vec::new());
+        let mut config = Config::default();
+        config.indexing.strategy = Some(IndexingStrategy::Full);
+        backend.set_config(config);
+
+        let interface_uri = Url::from_file_path(&interface_path).expect("interface uri");
+        let impl_uri = Url::from_file_path(&impl_path).expect("impl uri");
+        backend.update_ast(interface_uri.as_str(), interface_php);
+        backend.update_ast(impl_uri.as_str(), impl_php);
+
+        let locations = backend
+            .resolve_implementation(
+                interface_uri.as_str(),
+                interface_php,
+                Position {
+                    line: 2,
+                    character: 12,
+                },
+            )
+            .expect("implementation with same short name should be found");
+
+        assert_eq!(
+            locations.len(),
+            1,
+            "should find exactly one implementation: {locations:?}",
+        );
+        assert_eq!(locations[0].uri, impl_uri);
+    }
 }