Fix a couple of bugs with type resolving

Author: AJenbo

docs/CHANGELOG.md

@@ -55,6 +55,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Generic shape substitution.** Template parameters inside array shapes (`array{data: T}`) and object shapes (`object{name: T}`) are now correctly substituted when inherited through `@extends`. Previously only template parameters inside angle brackets were resolved, leaving bare references like `T` unsubstituted in shape bodies.
+- **Array shape bracket access.** Variables assigned from string-key bracket access on array shapes (`$name = $data['name']`) now resolve to the correct value type. Chained access (`$first = $result['items'][0]`) walks through shape keys and generic element types in sequence. This fixes completion, hover, and go-to-definition for variables derived from array shape fields. Previously only direct `$data['key']->` subjects resolved; intermediate variable assignments lost the type.
+- **Hover on array shape types.** Hovering over a variable whose type is an array shape (e.g. `array{data: User}`) no longer produces a corrupted `namespace array{...` line in the popup.
+- **Eloquent `morphedByMany` relationships.** The inverse side of polymorphic many-to-many relationships (`$this->morphedByMany(...)`) is now recognised. Virtual properties and `_count` properties are synthesized for models using this relationship type.
 - **Hover.** Hovering over unresolved function calls, unknown constants, or unresolvable `self`/`static`/`parent`/`$this` keywords no longer shows a bare placeholder. If the symbol cannot be found, no hover is shown.
 - **Add @throws.** The code action no longer double-indents the closing `*/` when inserting a `@throws` tag into an existing multi-line docblock.
 - **PHPStan stale-diagnostic clearing.** The `@throws`-based staleness check now scopes to the enclosing function's docblock instead of searching the entire file. A `@throws` tag on a different function no longer causes an unrelated diagnostic to be incorrectly cleared.

docs/todo.md

@@ -19,12 +19,6 @@ within the same impact tier.
 
 # Scheduled Sprints
 
-## Sprint 3 — Bug fixes
-
-| #   | Item                                                                                                              | Impact | Effort |
-| --- | ----------------------------------------------------------------------------------------------------------------- | ------ | ------ |
-|     | **Release 0.6.0**                                                                                                 |        |        |
-
 ## Sprint 4 — Refactoring toolkit
 
 | #   | Item                                                                               | Impact | Effort |
@@ -144,7 +138,6 @@ unlikely to move the needle for most users.
 | S5  | Language construct signature help and hover                                                                                                                  | Low        | Low         |
 |     | **[Laravel](todo/laravel.md)**                                                                                                                               |            |             |
 | L4  | Custom Eloquent builders (`HasBuilder` / `#[UseEloquentBuilder]`)                                                                                            | Medium     | Medium      |
-| L2  | `morphedByMany` missing from relationship method map                                                                                                         | Low-Medium | Low         |
 | L3  | `$dates` array (deprecated)                                                                                                                                  | Low-Medium | Low         |
 | L6  | Factory `has*`/`for*` relationship methods                                                                                                                   | Low-Medium | Medium      |
 | L7  | `$pivot` property on BelongsToMany                                                                                                                           | Medium     | Medium-High |

docs/todo/bugs.md

@@ -13,6 +13,4 @@ within the same impact tier.
 | **Impact** | **Critical**, **High**, **Medium-High**, **Medium**, **Low-Medium**, **Low**                                           |
 | **Effort** | **Low** (≤ 1 day), **Medium** (2-5 days), **Medium-High** (1-2 weeks), **High** (2-4 weeks), **Very High** (> 1 month) |
 
----
-
-No outstanding items.
+---

docs/todo/laravel.md

@@ -312,9 +312,21 @@ synthesizing `create()`/`make()`, load the associated model class.
 For each relationship method on the model, push a `has{Relationship}`
 and `for{Relationship}` virtual method (PascalCase of the method
 name) that returns `static` (i.e. the factory class itself).
-The `has*` variant should accept optional `int $count` and
-`array|callable $state` parameters; `for*` should accept
-`array|callable $state`.
+
+Larastan's `ModelFactoryMethodsClassReflectionExtension` reveals the
+exact parameter signatures to synthesize:
+
+- **`has{Rel}()`** — four overloads: no args, `int $count`,
+  `array|callable $state`, or `int $count, array|callable $state`.
+- **`for{Rel}()`** — two overloads: no args, or
+  `array|callable $state`.
+- **`trashed()`** — only synthesized when the model uses
+  `SoftDeletes`. No parameters, returns `static`.
+
+The strip-and-match algorithm: strip the `has`/`for` prefix, convert
+the remainder to camelCase, and check whether the model has a
+relationship method with that name. If not, the dynamic method is
+not offered.
 
 #### L7. `$pivot` property on BelongsToMany related models
 

docs/todo/mago.md

@@ -440,7 +440,12 @@ No existing code changes behaviour.
    - `Callable { params: Vec<CallableParam>, return_type: Option<Box<PhpType>> }`
    - `Conditional { param: String, condition: ParamCondition, then: Box<PhpType>, otherwise: Box<PhpType> }`
    - `Slice(Box<PhpType>)` — `T[]`
-   - `Variable(String)` — `$this`, template variables
+   - `Variable { name: String, scope: TemplateScope }` — `$this`,
+     template variables. The scope distinguishes class-level `T` from
+     method-level `T` on the same class. PHPStan identifies template
+     types by name + scope (`TemplateTypeScope`); without this,
+     a method declaring its own `@template T` that shadows the
+     class's `T` would produce incorrect substitutions.
    - `ClassString(Option<Box<PhpType>>)` — `class-string<T>`
    - `KeyOf(Box<PhpType>)`, `ValueOf(Box<PhpType>)`
    - `Static`, `Self_`, `Parent`

docs/todo/type-inference.md

@@ -67,6 +67,13 @@ check compares the richness of the return type.
    `native_type_hint`. Also inherit `description` and
    `return_description` when the child lacks them.
 
+   **Parameter name remapping.** When propagating `@param` types,
+   match by position, not by name. A child may rename `$userId` to
+   `$id`; the parent's `@param int $userId` at position 0 should
+   still flow to the child's position 0. PHPStan's
+   `PhpDocInheritanceResolver` builds an explicit positional mapping
+   for this.
+
 2. **During interface merging** (`resolve_class_fully_inner`): same
    logic — when an interface method is skipped because the class
    already defines it, enrich the existing method with the

example.php

@@ -1003,6 +1003,25 @@ public function demo(): void
 }
 
 
+// ── Generic Shape Substitution ──────────────────────────────────────────────
+
+class GenericShapeDemo
+{
+    public function demo(): void
+    {
+        $src = new ScaffoldingGenericShape();
+
+        // Template params inside array shape bodies are substituted through inheritance
+        $result = $src->getResult();
+        $result['data']->open();          // array{data: T} with T=Gift → Gift
+
+        // Chained bracket access walks shape key then list element
+        $first = $result['items'][0];
+        $first->open();                   // list<T> with T=Gift → Gift
+    }
+}
+
+
 // ── Foreach, Key Types, and Destructuring ───────────────────────────────────
 
 class IterationDemo
@@ -2837,6 +2856,21 @@ public function __construct()
     }
 }
 
+// ScaffoldingGenericShape — used by GenericShapeDemo
+/**
+ * @template T
+ */
+class ScaffoldingGenericShapeBase
+{
+    /** @return array{data: T, items: list<T>} */
+    public function getResult(): array { return []; }
+}
+
+/**
+ * @extends ScaffoldingGenericShapeBase<Gift>
+ */
+class ScaffoldingGenericShape extends ScaffoldingGenericShapeBase {}
+
 class ScaffoldingCollectionForeach
 {
     public UserEloquentCollection $members;

src/completion/variable/raw_type_inference.rs

@@ -806,6 +806,12 @@ fn resolve_rhs_raw_type<'b>(rhs: &'b Expression<'b>, ctx: &VarResolutionCtx<'_>)
             Expression::Static(_) => Some(ctx.current_class.name.clone()),
             _ => None,
         },
+        // ── Array access: `$arr['key']` or `$arr[0]` ──
+        // Walk through nested ArrayAccess nodes to collect bracket
+        // segments, resolve the base variable's type, then narrow
+        // through each segment (shape key → value type, element
+        // access → generic value type).
+        Expression::ArrayAccess(_) => resolve_rhs_array_access_raw_type(rhs, ctx),
         // ── Parenthesized: unwrap ──
         Expression::Parenthesized(p) => resolve_rhs_raw_type(p.expression, ctx),
         // ── Ternary / elvis: `$a ? $b : $c` or `$a ?: $c` ──
@@ -855,6 +861,99 @@ fn resolve_rhs_raw_type<'b>(rhs: &'b Expression<'b>, ctx: &VarResolutionCtx<'_>)
     }
 }
 
+/// Resolve an array access expression to a raw type string.
+///
+/// Walks through nested `ArrayAccess` nodes to collect bracket segments
+/// (string key vs element access), resolves the innermost base
+/// variable's type, then narrows through each segment:
+///   - String key → `extract_array_shape_value_type`
+///   - Element access → `extract_generic_value_type` (including scalar results)
+fn resolve_rhs_array_access_raw_type<'b>(
+    expr: &'b Expression<'b>,
+    ctx: &VarResolutionCtx<'_>,
+) -> Option<String> {
+    // Collect bracket segments innermost-last.
+    let mut segments: Vec<bool> = Vec::new(); // true = string key
+    let mut keys: Vec<String> = Vec::new();
+    let mut current: &Expression<'_> = expr;
+
+    while let Expression::ArrayAccess(access) = current {
+        if let Expression::Literal(Literal::String(s)) = access.index {
+            let key = s.value.map(|v| v.to_string()).unwrap_or_else(|| {
+                let raw = s.raw;
+                raw.strip_prefix('\'')
+                    .and_then(|r| r.strip_suffix('\''))
+                    .or_else(|| raw.strip_prefix('"').and_then(|r| r.strip_suffix('"')))
+                    .unwrap_or(raw)
+                    .to_string()
+            });
+            segments.push(true);
+            keys.push(key);
+        } else {
+            segments.push(false);
+            keys.push(String::new());
+        }
+        current = access.array;
+    }
+
+    // Reverse to left-to-right order.
+    segments.reverse();
+    keys.reverse();
+
+    // The base must be a variable.
+    let Expression::Variable(Variable::Direct(dv)) = current else {
+        return None;
+    };
+    let base_var = dv.name.to_string();
+    let access_offset = expr.span().start.offset;
+
+    // Resolve the base variable's raw type.
+    let mut current_type =
+        docblock::find_iterable_raw_type_in_source(ctx.content, access_offset as usize, &base_var)
+            .or_else(|| {
+                resolve_variable_assignment_raw_type(
+                    &base_var,
+                    ctx.content,
+                    access_offset,
+                    Some(ctx.current_class),
+                    ctx.all_classes,
+                    ctx.class_loader,
+                    ctx.function_loader,
+                )
+            })?;
+
+    // Expand type aliases.
+    if let Some(expanded) = crate::completion::type_resolution::resolve_type_alias(
+        &current_type,
+        &ctx.current_class.name,
+        ctx.all_classes,
+        ctx.class_loader,
+    ) {
+        current_type = expanded;
+    }
+
+    // Walk each segment.
+    for (i, is_string_key) in segments.iter().enumerate() {
+        if *is_string_key {
+            if let Some(vt) =
+                docblock::types::extract_array_shape_value_type(&current_type, &keys[i])
+            {
+                current_type = vt;
+            } else if let Some(et) = docblock::types::extract_iterable_element_type(&current_type) {
+                current_type = et;
+            } else {
+                return None;
+            }
+        } else if let Some(et) = docblock::types::extract_iterable_element_type(&current_type) {
+            current_type = et;
+        } else {
+            return None;
+        }
+    }
+
+    Some(current_type)
+}
+
 /// Combine two optional raw type strings into a union.
 ///
 /// When both sides resolve to the same type string, returns a single