Fix 8 bugs

Author: AJenbo

docs/CHANGELOG.md

@@ -68,6 +68,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **First-open performance.** Diagnostics on `did_open` now run asynchronously instead of blocking the LSP response.
 - **Variadic `@param` template bindings.** `@param class-string<T> ...$items` now correctly binds the template parameter.
 - **Laravel relationship classification.** Relationship return types fully-qualified to a non-Eloquent namespace are no longer misclassified as Eloquent relationships.
+- **Trait `use` no longer triggers false-positive unused import.** When a class uses a trait via `use TraitName;` inside the class body, the corresponding namespace import is no longer flagged as unused.
+- **PHPDoc types on constructor-promoted properties now recognised.** Classes referenced in `/** @var list<Foo> */` annotations on promoted constructor parameters are no longer flagged as unused imports, and hover/go-to-definition works on those type references.
+- **PHPDoc type tags no longer skipped by unused-import safety net.** Docblock lines containing type-bearing tags (`@var`, `@param`, `@return`, `@throws`, `@template`, etc.) are now checked for class references instead of being blanket-skipped as comments.
 - **`@phpstan-type` aliases in foreach.** Type aliases now resolve correctly when iterated in a `foreach` loop, destructured with `list()`/`[]`, or used as a foreach key type.
 - **Mixed `->` then `::` accessor chains.** Expressions like `$obj->prop::$staticProp` now resolve through the full chain.
 - **Inline `(new Foo)->method()` chaining.** Parenthesized `new` expressions used as the root of a method chain now resolve for completion.
@@ -86,6 +89,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Double-negated `instanceof` narrowing.** `if (!!$x instanceof Foo)` now correctly narrows `$x` to `Foo`.
 - **Accessor on new line with whitespace.** Completion now works when `->` is on a new line with extra whitespace before the cursor.
 - **Partial static property completion.** Typing `$obj::$f` now returns static property completions.
+- **Hover respects `instanceof` and `assert` narrowing.** Hovering a variable after `assert($var instanceof Foo)` now shows the narrowed type instead of the original assignment type. Inline `/** @var Type */` annotations on assignments are also respected by the hover type-string path. Previously these narrowing patterns only affected completion, not hover.
+- **`instanceof` narrowing with same-named classes in different namespaces.** When two classes share the same short name (e.g. `Contracts\Provider` and `Concrete\Provider`), `instanceof` narrowing no longer incorrectly treats them as subtypes of each other.
+- **Self-referential array key assignments no longer crash the LSP.** Patterns like `$numbers['price'] = $numbers['price']->add(...)` caused infinite recursion in the raw-type inference path, producing a stack overflow that killed the server process. The resolver now reduces the cursor offset before evaluating the right-hand side, matching the protection already present for simple variable assignments.
+- **Cross-file `@property` and `@method` type resolution.** When a class declares `@property Carbon $created` using a short class name imported via `use`, accessing that property from a different file now resolves the type correctly. Previously the short name was resolved against the consuming file's imports instead of the declaring file's imports, causing completion and hover to fail.
+- **Editing a `@property` docblock now invalidates hover in other files.** Changing a class-level `@property` (or `@method`) type was not reflected when hovering on a child class that inherits the virtual member. The resolved-class cache now transitively evicts dependent classes (children, trait users, implementors, mixin consumers) when an ancestor's signature changes.
 
 ## [0.4.0] - 2026-03-01
 

example.php

@@ -4556,7 +4556,7 @@ public function first($columns = ['*']) { return null; }
          * @param  callable(\Illuminate\Support\Collection<int, TValue>, int): mixed  $callback
          * @return bool
          */
-        public function chunk(int $count, callable $callback): bool { return true; }
+        public function chunk($count, callable $callback) { return true; }
     }
 }
 
@@ -4590,8 +4590,9 @@ public function get($columns = ['*']) {}
     /**
      * @template TKey of array-key
      * @template TValue
+     * @implements \IteratorAggregate<TKey, TValue>
      */
-    class Collection {
+    class Collection implements \IteratorAggregate {
         /** @return int */
         public function count(): int { return 0; }
         /** @return TValue|null */
@@ -4603,6 +4604,7 @@ public function all(): array { return []; }
          * @return static
          */
         public function each(callable $callback): static { return $this; }
+        public function getIterator(): \ArrayIterator { return new \ArrayIterator([]); }
     }
 }
 

src/completion/types/narrowing.rs

@@ -226,7 +226,7 @@ pub(in crate::completion) fn apply_instanceof_inclusion(
             .filter(|r| {
                 narrowed
                     .iter()
-                    .any(|n| is_subtype_of(r, &n.name, ctx.class_loader))
+                    .any(|n| is_subtype_of(r, &n.fqn(), ctx.class_loader))
             })
             .cloned()
             .collect();
@@ -267,18 +267,37 @@ fn is_subtype_of(
 ) -> bool {
     let ancestor_short = ancestor_name.rsplit('\\').next().unwrap_or(ancestor_name);
 
-    // Same class?
-    if class.name == ancestor_name || class.name == ancestor_short {
+    // Same class?  When the ancestor is a FQN, compare against the
+    // class's own FQN to avoid false positives when two classes share
+    // the same short name (e.g. `Contracts\Provider` vs
+    // `Concrete\Provider`).
+    if ancestor_name.contains('\\') {
+        if class.fqn() == ancestor_name {
+            return true;
+        }
+    } else if class.name == ancestor_name {
         return true;
     }
 
+    // When the ancestor is qualified, only match against normalised
+    // FQNs — never fall back to short-name comparison, which would
+    // produce false positives when two different classes share the
+    // same short name (e.g. `Contracts\Provider` vs
+    // `Concrete\Provider`).
+    let fqn_mode = ancestor_name.contains('\\');
+
     // Check interfaces on the class itself.
     for iface in &class.interfaces {
         let iface_norm = iface.strip_prefix('\\').unwrap_or(iface);
-        let iface_short = iface_norm.rsplit('\\').next().unwrap_or(iface_norm);
-        if iface_norm == ancestor_name || iface_short == ancestor_short {
+        if iface_norm == ancestor_name {
             return true;
         }
+        if !fqn_mode {
+            let iface_short = iface_norm.rsplit('\\').next().unwrap_or(iface_norm);
+            if iface_short == ancestor_short {
+                return true;
+            }
+        }
     }
 
     // Walk the parent chain.
@@ -290,18 +309,28 @@ fn is_subtype_of(
             break;
         }
         let normalized = name.strip_prefix('\\').unwrap_or(name);
-        let short = normalized.rsplit('\\').next().unwrap_or(normalized);
-        if normalized == ancestor_name || short == ancestor_short {
+        if normalized == ancestor_name {
             return true;
         }
+        if !fqn_mode {
+            let short = normalized.rsplit('\\').next().unwrap_or(normalized);
+            if short == ancestor_short {
+                return true;
+            }
+        }
         // Load the parent to check its interfaces and continue the chain.
         if let Some(parent_info) = class_loader(name) {
             for iface in &parent_info.interfaces {
                 let iface_norm = iface.strip_prefix('\\').unwrap_or(iface);
-                let iface_short = iface_norm.rsplit('\\').next().unwrap_or(iface_norm);
-                if iface_norm == ancestor_name || iface_short == ancestor_short {
+                if iface_norm == ancestor_name {
                     return true;
                 }
+                if !fqn_mode {
+                    let iface_short = iface_norm.rsplit('\\').next().unwrap_or(iface_norm);
+                    if iface_short == ancestor_short {
+                        return true;
+                    }
+                }
             }
             current_parent = parent_info.parent_class.clone();
         } else {

src/completion/variable/raw_type_inference.rs

@@ -9,6 +9,8 @@
 ///   - Array literals with element type inference
 ///   - Known array functions (array_filter, array_map, array_pop, etc.)
 ///   - Generator yield reverse-inference
+///   - `assert($var instanceof ClassName)` narrowing
+///   - Inline `/** @var Type */` docblock overrides on assignments
 ///
 /// The primary entry point is [`resolve_variable_assignment_raw_type`],
 /// which re-parses the file and returns a PHPStan-style type string
@@ -404,7 +406,26 @@ fn accumulate_assignment_raw_types<'b>(
                 }
             }
             Statement::Expression(expr_stmt) => {
+                // Check for inline `/** @var Type */` override before
+                // the assignment.  This mirrors the logic in
+                // `walk_statements_for_assignments` so that the raw
+                // type path also respects @var overrides.
+                if try_inline_var_override_raw(
+                    expr_stmt.expression,
+                    stmt.span().start.offset as usize,
+                    ctx,
+                    &mut acc,
+                ) {
+                    continue;
+                }
+
                 check_expression_for_raw_type(expr_stmt.expression, ctx, &mut acc);
+
+                // Check for `assert($var instanceof ClassName)` after
+                // the assignment.  When found, override the base type
+                // with the instanceof class name so that hover shows
+                // the narrowed type.
+                check_assert_instanceof_for_raw_type(expr_stmt.expression, ctx, &mut acc);
             }
             _ => {}
         }
@@ -413,6 +434,109 @@ fn accumulate_assignment_raw_types<'b>(
     acc
 }
 
+/// Check for `assert($var instanceof ClassName)` and override the
+/// accumulator's base type with the class name when found.
+///
+/// This enables the raw type path (used by hover) to respect
+/// instanceof narrowing via assert statements.
+fn check_assert_instanceof_for_raw_type<'b>(
+    expr: &'b Expression<'b>,
+    ctx: &VarResolutionCtx<'_>,
+    acc: &mut AssignmentAccumulator,
+) {
+    // Unwrap parenthesised wrapper on the whole expression.
+    let expr = match expr {
+        Expression::Parenthesized(inner) => inner.expression,
+        other => other,
+    };
+
+    if let Expression::Call(Call::Function(func_call)) = expr
+        && let Expression::Identifier(ident) = func_call.function
+        && ident.value() == "assert"
+        && let Some(first_arg) = func_call.argument_list.arguments.iter().next()
+    {
+        let arg_expr = match first_arg {
+            Argument::Positional(pos) => pos.value,
+            Argument::Named(named) => named.value,
+        };
+
+        // Extract `$var instanceof ClassName` from the argument.
+        if let Some(cls_name) = try_extract_instanceof_class(arg_expr, ctx.var_name) {
+            acc.set_base(cls_name);
+        }
+    }
+}
+
+/// Try to extract the class name from `$var instanceof ClassName`,
+/// handling parenthesisation.  Returns `None` when the expression
+/// is not an instanceof check for the given variable.
+fn try_extract_instanceof_class<'b>(expr: &'b Expression<'b>, var_name: &str) -> Option<String> {
+    match expr {
+        Expression::Parenthesized(inner) => {
+            try_extract_instanceof_class(inner.expression, var_name)
+        }
+        Expression::Binary(bin) if bin.operator.is_instanceof() => {
+            // LHS must be our variable.
+            let lhs_name = match bin.lhs {
+                Expression::Variable(Variable::Direct(dv)) => dv.name.to_string(),
+                _ => return None,
+            };
+            if lhs_name != var_name {
+                return None;
+            }
+            // RHS is the class name.
+            match bin.rhs {
+                Expression::Identifier(ident) => Some(ident.value().to_string()),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Try to resolve a variable's type from an inline `/** @var Type */`
+/// docblock that immediately precedes an assignment statement.
+///
+/// Returns `true` when the override was applied (and the caller should
+/// skip normal assignment resolution for this statement).
+fn try_inline_var_override_raw<'b>(
+    expr: &'b Expression<'b>,
+    stmt_start: usize,
+    ctx: &VarResolutionCtx<'_>,
+    acc: &mut AssignmentAccumulator,
+) -> bool {
+    // Must be an assignment to our target variable.
+    let assignment = match expr {
+        Expression::Assignment(a) if a.operator.is_assign() => a,
+        _ => return false,
+    };
+    let lhs_name = match assignment.lhs {
+        Expression::Variable(Variable::Direct(dv)) => dv.name.to_string(),
+        _ => return false,
+    };
+    if lhs_name != ctx.var_name {
+        return false;
+    }
+
+    // Look for a `/** @var Type [$var] */` docblock right before this
+    // statement.
+    let (var_type, var_name_opt) = match docblock::find_inline_var_docblock(ctx.content, stmt_start)
+    {
+        Some(pair) => pair,
+        None => return false,
+    };
+
+    // If the annotation includes a variable name, it must match.
+    if let Some(ref vn) = var_name_opt
+        && vn != ctx.var_name
+    {
+        return false;
+    }
+
+    acc.set_base(var_type);
+    true
+}
+
 /// Check a single expression for base, incremental key, or push
 /// assignments to the target variable, updating the accumulator.
 fn check_expression_for_raw_type<'b>(
@@ -425,10 +549,22 @@ fn check_expression_for_raw_type<'b>(
         _ => return,
     };
 
+    // Use the assignment's own start offset as cursor_offset so that
+    // any recursive variable resolution only considers assignments
+    // *before* this one.  Without this, a self-referential assignment
+    // like `$numbers['sub_price'] = $numbers['sub_price']->add(…)`
+    // would infinitely recurse: resolving the RHS `$numbers['sub_price']`
+    // triggers resolution of `$numbers`, which re-discovers the same
+    // assignment, resolves its RHS again, and so on until a stack
+    // overflow crashes the process.
+    //
+    // This mirrors the protection in `check_expression_for_assignment`.
+    let rhs_ctx = ctx.with_cursor_offset(assignment.span().start.offset);
+
     match assignment.lhs {
         // ── Base assignment: `$var = expr;` ──
         Expression::Variable(Variable::Direct(dv)) if dv.name == ctx.var_name => {
-            if let Some(raw) = resolve_rhs_raw_type(assignment.rhs, ctx) {
+            if let Some(raw) = resolve_rhs_raw_type(assignment.rhs, &rhs_ctx) {
                 acc.set_base(raw);
             }
         }
@@ -440,7 +576,7 @@ fn check_expression_for_raw_type<'b>(
                 let key = extract_array_key_text(array_access.index);
                 // Skip numeric-only keys — they are not string-keyed shape entries.
                 if key != "mixed" && !key.chars().all(|c| c.is_ascii_digit()) {
-                    let value_type = infer_expression_type_string(assignment.rhs, ctx);
+                    let value_type = infer_expression_type_string(assignment.rhs, &rhs_ctx);
                     acc.add_incremental_key(key, value_type);
                 }
             }
@@ -450,7 +586,7 @@ fn check_expression_for_raw_type<'b>(
             if let Expression::Variable(Variable::Direct(dv)) = array_append.array
                 && dv.name == ctx.var_name
             {
-                let value_type = infer_expression_type_string(assignment.rhs, ctx);
+                let value_type = infer_expression_type_string(assignment.rhs, &rhs_ctx);
                 acc.add_push_type(value_type);
             }
         }