Fix false unused import diagnostic for aliased namespace used in

attributes

Author: AJenbo

docs/CHANGELOG.md

@@ -79,6 +79,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Types with `covariant` or `contravariant` variance annotations in generic args now parse correctly.** Annotations like `BelongsTo<Category, covariant $this>` no longer cause the entire type to become unresolvable.
 - **Diagnostics now work for vendor files open in the editor.** Projects using `--prefer-source` or monorepo setups no longer have diagnostics suppressed in vendor files.
 - **PHPStan diagnostics no longer hidden by unrelated native diagnostics on the same line.** Deduplication now only suppresses a full-line diagnostic when the precise diagnostic on the same line reports a related issue.
+- **Aliased namespace imports used in attributes no longer flagged as unused.** `use Symfony\Component\Validator\Constraints as Assert;` with `#[Assert\Uuid(...)]` no longer produces a false "Unused import" diagnostic.
 - **`DB::select()` return type.** `DB::select()` and related methods now return `array<int, stdClass>` instead of bare `array`, and `DB::selectOne()` returns `?stdClass`.
 - **Redis `Connection` method resolution.** Redis commands on `Illuminate\Redis\Connections\Connection` now resolve through the phpredis stubs.
 - **Array shape tracking from keyed assignments inside conditional branches.** Shape types built incrementally with variable keys inside loops with if/else branching are now preserved through foreach iteration.

src/diagnostics/unused_imports.rs

@@ -251,7 +251,14 @@ fn alias_is_referenced_in_content(
             None => break,
         };
 
-        // Check word boundaries
+        // Check word boundaries.
+        //
+        // A backslash *after* the alias is a valid boundary: `Assert\Uuid`
+        // means the file uses `Assert` as a namespace-alias prefix, which
+        // counts as a real usage of the `use … as Assert` import.
+        //
+        // A backslash *before* the alias is NOT a valid boundary:
+        // `Foo\Assert` does not reference a top-level `Assert` alias.
         let before_ok = if pos == 0 {
             true
         } else {
@@ -261,7 +268,8 @@ fn alias_is_referenced_in_content(
         let after_ok = if pos + alias_len >= content_bytes.len() {
             true
         } else {
-            !is_ident_char(content_bytes[pos + alias_len])
+            let next_byte = content_bytes[pos + alias_len];
+            next_byte == b'\\' || !is_ident_char(next_byte)
         };
 
         if before_ok && after_ok {
@@ -484,3 +492,81 @@ fn find_group_member_range(
 
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Helper: no use-statement or declaration ranges to exclude.
+    fn referenced(content: &str, alias: &str) -> bool {
+        alias_is_referenced_in_content(content, alias, "", &[], &[])
+    }
+
+    #[test]
+    fn backslash_after_alias_counts_as_reference() {
+        // `Assert\Uuid` uses the `Assert` alias as a namespace prefix.
+        let content = r#"<?php
+use Symfony\Component\Validator\Constraints as Assert;
+
+class Dto {
+    public function __construct(
+        #[Assert\Uuid(message: 'bad')]
+        public string $id,
+    ) {}
+}
+"#;
+        let use_ranges = compute_use_line_ranges(content);
+        assert!(
+            alias_is_referenced_in_content(content, "Assert", "", &use_ranges, &[]),
+            "Assert\\Uuid should count as a usage of the Assert alias"
+        );
+    }
+
+    #[test]
+    fn backslash_before_alias_does_not_count() {
+        // `Foo\Assert` does NOT reference a top-level `Assert` alias.
+        assert!(!referenced(r#"Foo\Assert"#, "Assert"));
+    }
+
+    #[test]
+    fn standalone_alias_still_detected() {
+        assert!(referenced("new Assert();", "Assert"));
+    }
+
+    #[test]
+    fn alias_inside_longer_word_not_detected() {
+        // `Assertion` contains `Assert` but is a different identifier.
+        assert!(!referenced("new Assertion();", "Assert"));
+    }
+
+    #[test]
+    fn alias_with_static_access_through_namespace() {
+        // `Assert\Uuid::V7_MONOTONIC` — the alias `Assert` is used.
+        assert!(referenced("Assert\\Uuid::V7_MONOTONIC", "Assert"));
+    }
+
+    #[test]
+    fn alias_on_use_line_not_counted() {
+        let content = "use Foo\\Bar as Assert;\n";
+        let use_ranges = compute_use_line_ranges(content);
+        assert!(
+            !alias_is_referenced_in_content(content, "Assert", "", &use_ranges, &[]),
+            "Alias on a use-statement line should not count as a reference"
+        );
+    }
+
+    #[test]
+    fn alias_in_comment_not_counted() {
+        assert!(!referenced("// Assert is great\n", "Assert"));
+    }
+
+    #[test]
+    fn alias_in_docblock_prose_not_counted() {
+        assert!(!referenced(" * Assert something here\n", "Assert"));
+    }
+
+    #[test]
+    fn alias_in_docblock_type_tag_counted() {
+        assert!(referenced(" * @param Assert $x\n", "Assert"));
+    }
+}

tests/integration/diagnostics_deprecated.rs

@@ -2884,3 +2884,101 @@ class Beta {
         deprecated[0].message
     );
 }
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Aliased imports used in attributes (bug #64)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// An aliased namespace import used in an attribute (`#[Assert\Uuid(...)]`)
+/// must not be flagged as unused.
+#[test]
+fn aliased_import_used_in_attribute_not_flagged() {
+    let backend = create_test_backend();
+    let uri = "file:///test_aliased_attr.php";
+    let text = r#"<?php
+namespace App\Dto\In;
+
+use Symfony\Component\Validator\Constraints as Assert;
+
+final readonly class SomeKindOfInDto
+{
+    public function __construct(
+        #[Assert\Uuid(
+            message: 'Not valid UUID::v7',
+        )]
+        public string $id,
+    ) {}
+}
+"#;
+
+    let diags = unused_import_diagnostics(&backend, uri, text);
+    let unnecessary: Vec<_> = diags.iter().filter(|d| has_unnecessary_tag(d)).collect();
+
+    assert!(
+        unnecessary.is_empty(),
+        "Aliased import used in attribute should NOT be flagged as unused, got: {:?}",
+        unnecessary
+    );
+}
+
+/// An aliased namespace import used in a nested static constant access
+/// inside an attribute argument (`Assert\Uuid::V7_MONOTONIC`) must not
+/// be flagged as unused.
+#[test]
+fn aliased_import_used_in_attribute_static_constant_not_flagged() {
+    let backend = create_test_backend();
+    let uri = "file:///test_aliased_attr_const.php";
+    let text = r#"<?php
+namespace App\Dto\In;
+
+use Symfony\Component\Validator\Constraints as Assert;
+
+final readonly class SomeKindOfInDto
+{
+    public function __construct(
+        #[Assert\Uuid(
+            message: 'Not valid UUID::v7',
+            versions: [Assert\Uuid::V7_MONOTONIC],
+        )]
+        public string $id,
+    ) {}
+}
+"#;
+
+    let diags = unused_import_diagnostics(&backend, uri, text);
+    let unnecessary: Vec<_> = diags.iter().filter(|d| has_unnecessary_tag(d)).collect();
+
+    assert!(
+        unnecessary.is_empty(),
+        "Aliased import used in attribute with static constant should NOT be flagged as unused, got: {:?}",
+        unnecessary
+    );
+}
+
+/// A non-aliased import used in an attribute should also work correctly.
+#[test]
+fn non_aliased_import_used_in_attribute_not_flagged() {
+    let backend = create_test_backend();
+    let uri = "file:///test_non_aliased_attr.php";
+    let text = r#"<?php
+namespace App;
+
+use Symfony\Component\Serializer\Attribute\SerializedName;
+
+class Dto {
+    public function __construct(
+        #[SerializedName('product')]
+        public string $id,
+    ) {}
+}
+"#;
+
+    let diags = unused_import_diagnostics(&backend, uri, text);
+    let unnecessary: Vec<_> = diags.iter().filter(|d| has_unnecessary_tag(d)).collect();
+
+    assert!(
+        unnecessary.is_empty(),
+        "Import used in attribute should NOT be flagged as unused, got: {:?}",
+        unnecessary
+    );
+}