Closure parameter inference

Author: AJenbo

docs/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Closure parameter inference.** When a closure or arrow function is passed to a method or function whose parameter is typed as `callable(T): R` or `Closure(T): R`, untyped closure parameters are now inferred from the callable signature. For example, `$users->map(fn($u) => $u->name)` infers `$u` as `User` when `map` declares `@param callable(TValue): TMapValue` and generic substitution has resolved `TValue` to `User`. Works with instance methods, static methods, null-safe calls, standalone functions, `$this->method()` receivers, and closures at any argument position. Explicit type hints on closure parameters always take precedence. Template parameters inside callable signatures (e.g. `callable(TValue): void`) are substituted during generic resolution so the inferred types are concrete.
 - **Factory support.** `User::factory()->create()` and `->make()` now resolve to the model class. When a model uses the `HasFactory` trait with an explicit `@use HasFactory<UserFactory>` annotation, the generics system handles resolution. When the annotation is absent, the naming convention is used as a fallback: `App\Models\User` maps to `Database\Factories\UserFactory`, and subdirectories are preserved (`App\Models\Admin\SuperUser` maps to `Database\Factories\Admin\SuperUserFactory`). Factory chain methods that return `static` (e.g. `count()`, `state()`) continue the chain on the factory, while `create()` and `make()` return the model. The convention also works in reverse: a factory class extending `Factory` without `@extends Factory<Model>` resolves `TModel` from its own class name. Both directions are implemented as fallbacks that defer to explicit generics when present.
 - **`newCollection()` override detection.** Eloquent models that override the `newCollection()` method now resolve to the custom collection class declared in the method's return type. This is the third detection mechanism alongside `#[CollectedBy]` and `@use HasCollection<X>`. Priority order: attribute, trait, method override. Works with short names resolved via `use` imports and fully-qualified return types. The standard `Collection` return type is correctly ignored. Custom collection methods appear after `->get()`, on relationship properties, and in builder chains.
 - **Body-inferred relationship properties.** Eloquent relationship methods that lack `@return` annotations now produce virtual properties by scanning the method body for patterns like `$this->hasMany(Post::class)`. The relationship type is inferred from the method name (`hasMany` to `HasMany`, `belongsTo` to `BelongsTo`, etc.) and the related model class is extracted from the first `::class` argument. Supports all 10 relationship types including `HasOneThrough`. Fully-qualified class names, extra foreign key arguments, and chained builder calls (e.g. `->latest()`) are handled. When both a `@return` annotation and a body pattern are present, the annotation takes priority. Projects that don't use Larastan no longer need to add annotations for basic relationship completion.
@@ -45,6 +46,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Arrow function parameter go-to-definition.** Go-to-definition on a variable used in an arrow function body (e.g. `$o` in `fn(Order $o) => $o->getItems()`) now jumps to the parameter on the same line. Previously the backward scan excluded the cursor line, so it would skip the arrow function parameter and jump to an unrelated earlier variable with the same name. The fix includes the cursor line in the scan but only accepts non-assignment definitions (parameters, foreach, catch, static/global) to preserve the existing behavior for reassignments like `$value = $value->value`. Go-to-definition on the parameter itself (the LHS `$o`) correctly resolves the type hint and jumps to the `Order` class.
+
 - **Relationship property collection type uses the related model's custom collection.** When a model like `Product` had a `HasMany<Review, $this>` relationship, the virtual property `$product->reviews` incorrectly used the owning model's custom collection (`ProductCollection`) instead of the related model's (`ReviewCollection`). The provider now loads the related model via `class_loader` and reads its `custom_collection` field. The integration test was updated to use distinct collections per model so the bug is no longer masked.
 
 - **UTF-8 boundary panic in `find_enclosing_return_type`.** Files containing multi-byte UTF-8 characters (such as `─` in comment banners) could cause a panic when `extract_method_return_from_body_brace` sliced the content at a byte offset that landed inside a multi-byte character. This broke variable type resolution for any method whose body brace fell within 2000 bytes of such a character, causing `$model->` completions to silently return empty results while `$this->` (which uses a different code path) continued to work. The slice offset is now adjusted to a valid char boundary.

docs/todo-laravel.md

@@ -1,6 +1,6 @@
 # PHPantom — Laravel Support: Remaining Work
 
-> Last updated: 2025-07-21
+> Last updated: 2026-02-26
 
 This document tracks bugs, known gaps, and missing features in
 PHPantom's Laravel Eloquent support. For the general architecture and
@@ -10,18 +10,6 @@ virtual member provider design, see `ARCHITECTURE.md`.
 
 ## Missing features
 
-### 1. Variable assignment from builder-forwarded static method in GTD
-
-`$q = User::where(...)` then `$q->orderBy()` does not fully resolve for
-go-to-definition because the variable resolution path
-(`resolve_rhs_static_call`) finds `where()` on the raw `Task` class via
-`resolve_method_return_types_with_args`, which calls
-`resolve_class_fully` internally. The issue is that the returned Builder
-type's methods are resolved, but go-to-definition then cannot trace back
-to the declaring class in a Builder loaded through the chain. This
-works for completion (which only needs the type) but not for GTD (which
-needs the source location).
-
 ### 2. Closure parameter inference in collection pipelines
 
 `$users->map(fn($u) => $u->...)` does not infer `$u` as the
@@ -44,21 +32,24 @@ Builder at resolution time without preserving the original declaration
 site. The GTD fallback `find_scope_on_builder_model` may not be
 triggering for the `with()` return path.
 
-### 4. Multi-line chain after `with()` breaks completion and GTD
+### 4. Blank line inside a method chain breaks collapse logic
 
-When the chain after `with()` is split across lines, neither completion
-nor go-to-definition works:
+When a blank line separates parts of a fluent chain,
+`collapse_continuation_lines` stops walking backwards at the empty line
+and never reaches the base expression:
 
 ```php
 Brand::with('english')
+
     ->paginate(); // neither GTD nor completion works
 ```
 
-The single-line equivalent resolves fine. This is a variant of the
-multi-line closure argument issue (now fixed): `collapse_continuation_lines`
-joins lines that start with `->`, but the base line `Brand::with('english')`
-is not being found when the chain spans lines in this specific pattern.
-Likely a cursor-position or line-counting edge case in the collapse logic.
+The same chain without the blank line works fine. The backward walk in
+`collapse_continuation_lines` treats any line that does not start with
+`->` or `?->` as the base. An empty line matches that condition, so the
+collapsed result is just `->paginate()` with no subject. Fixing this
+requires skipping blank (whitespace-only) lines during the backward
+walk.
 
 ---
 

example.php

@@ -1746,6 +1746,35 @@ public function intermediateVariable(): void
 }
 
 
+// ── Closure Parameter Inference ─────────────────────────────────────────────
+
+class ClosureParamInferenceDemo
+{
+    /** @var FluentCollection<int, User> */
+    public FluentCollection $users;
+
+    public function mapArrowFunction(): void
+    {
+        // $u is inferred as User from map's callable(TValue, TKey) signature.
+        $this->users->map(fn($u) => $u->getEmail());
+    }
+
+    public function eachClosure(): void
+    {
+        // $user is inferred as User from each's callable(TValue, TKey) signature.
+        $this->users->each(function ($user) {
+            $user->getEmail();            // resolves to User
+        });
+    }
+
+    public function explicitTypeWins(): void
+    {
+        // Explicit type hint takes precedence over inference.
+        $this->users->map(fn(Order $o) => $o->getItems());
+    }
+}
+
+
 // ═══════════════════════════════════════════════════════════════════════════
 // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 // ┃  SCAFFOLDING — Supporting definitions below this line.              ┃
@@ -2550,6 +2579,14 @@ public function map(callable $callback)
     {
     }
 
+    /**
+     * @param  callable(TValue, TKey): void  $callback
+     * @return static<TKey, TValue>
+     */
+    public function each(callable $callback)
+    {
+    }
+
     /**
      * Multi-line @return with nested generics spanning lines.
      *