Laravel factory support

Author: AJenbo

docs/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **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.
 - **Laravel accessor and mutator virtual properties.** Eloquent models with legacy accessors (`getFullNameAttribute()`) or modern Laravel 9+ accessors (methods returning `Illuminate\Database\Eloquent\Casts\Attribute`) now produce virtual properties. The property name is derived by converting the method name to snake_case: `getFullNameAttribute` produces `$full_name`, and `avatarUrl()` produces `$avatar_url`. Legacy accessors use the method's declared return type; modern accessors use `mixed`. Works alongside relationship properties, scope methods, and builder forwarding. `getAttribute()` (a real Eloquent method) is correctly excluded.

docs/todo-laravel.md

@@ -8,7 +8,7 @@ virtual member provider design, see `ARCHITECTURE.md`.
 
 ---
 
-## Known gaps (documented in tests)
+## Missing features
 
 ### 1. Variable assignment from builder-forwarded static method in GTD
 
@@ -22,32 +22,18 @@ 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).
 
----
-
-## Missing features
-
-### 2. Factory support
-
-`User::factory()->create()` is ubiquitous in Laravel test code. The
-`factory()` static method returns a `HasFactory` trait method that
-produces a factory instance. Resolving the chain requires:
-
-1. Detecting the `HasFactory` trait on the model.
-2. Resolving `factory()` to the model's corresponding Factory class
-   (convention: `App\Models\User` → `Database\Factories\UserFactory`).
-3. Resolving `create()` / `make()` on the factory to return the model.
-
-This is medium complexity because it involves a naming convention
-(model name → factory name) and cross-file resolution.
-
-### 3. Closure parameter inference in collection pipelines
+### 2. Closure parameter inference in collection pipelines
 
 `$users->map(fn($u) => $u->...)` does not infer `$u` as the
 collection's element type. This is a general generics/callable
 inference problem, not Laravel-specific, but Laravel collection
 pipelines are the most common place users encounter it.
+Other cases:
+- MyModel::whereIn()->chunk(self::CHUNK_SIZE, function (Collection $orders) {})
+- MyModel::whereHas('order', function (Builder $q) {})
+- MyModel::with(['translations' => function (Relation $query) {}]) // translations is the name of the relation on MyModel, Relation will become the return type of that relation
 
-### 4. Query scope chaining on Builder instances
+### 3. Query scope chaining on Builder instances
 
 Inside a scope method body, `$query->verified()` (calling another
 scope) does not offer scope method completions. Scope methods are
@@ -61,6 +47,11 @@ scope methods as instance methods on the resolved Builder. This
 requires extending the virtual member system to also apply to
 Builder instances, not just Model classes.
 
+### 4. Scopes on queries
+
+Copes are missing from complation of a query after other query
+opertions for example Brand::where('id', $id)->isActive(); // Brand has a method called scopeIsActive()
+
 ---
 
 ## Out of scope (and why)
@@ -87,4 +78,4 @@ Builder instances, not just Model classes.
   are best-effort.
 - **Facades fall back to `@method`.** Facades whose `getFacadeAccessor()`
   returns a string alias cannot be resolved. `@method` tags on facade
-  classes provide completion without template intelligence.
+  classes provide completion without template intelligence.

example.php

@@ -364,7 +364,8 @@ function handleIntersection(User&Loggable $entity): void {
 // ── Trait Generic Substitution ──────────────────────────────────────────────
 
 Product::factory()->create();             // @use HasFactory<UserFactory> → UserFactory
-Product::factory()->count(5);
+Product::factory()->count(5)->make();     // count() returns static, make() returns Product
+Product::factory()->state([])->create();  // state() returns static, create() returns Product
 
 $idx = new UserIndex();                   // @use Indexable<int, User>
 $idx->get()->getEmail();                  // TValue → User
@@ -2407,6 +2408,7 @@ class UserFactory
 {
     public function create(): User { return new User('', ''); }
     public function count(int $n): static { return $this; }
+    public function state(array $state): static { return $this; }
     public function make(): User { return new User('', ''); }
 }
 

src/completion/handler.rs

@@ -661,7 +661,6 @@ impl Backend {
                 };
                 Self::resolve_target_classes(&target.subject, target.access_kind, &rctx)
             };
-
             if candidates.is_empty() {
                 return vec![];
             }

src/inheritance.rs

@@ -25,6 +25,9 @@ use crate::types::{
     ParamCondition, PropertyInfo, TraitAlias, TraitPrecedence, Visibility,
 };
 use crate::util::short_name;
+use crate::virtual_members::laravel::{
+    extends_eloquent_model, factory_to_model_fqn, model_to_factory_fqn,
+};
 
 impl Backend {
     /// Resolve a class together with all inherited members from its parent
@@ -98,7 +101,29 @@ impl Backend {
             // Look through current's `extends_generics` for an entry
             // whose class name matches this parent, and zip its type
             // arguments with the parent's `template_params`.
-            let level_subs = build_substitution_map(&current, &parent, &active_subs);
+            let mut level_subs = build_substitution_map(&current, &parent, &active_subs);
+
+            // ── Convention-based Factory fallback ────────────────────
+            // When a factory class extends `Factory` without
+            // `@extends Factory<Model>`, derive the model class from
+            // the naming convention (e.g. `Database\Factories\UserFactory`
+            // → `App\Models\User`) and substitute `TModel` automatically.
+            if level_subs.is_empty()
+                && !parent.template_params.is_empty()
+                && is_factory_class(parent_name)
+            {
+                let factory_fqn = match &current.file_namespace {
+                    Some(ns) if !ns.is_empty() => format!("{}\\{}", ns, current.name),
+                    _ => current.name.clone(),
+                };
+                if let Some(model_fqn) = factory_to_model_fqn(&factory_fqn)
+                    && class_loader(&model_fqn).is_some()
+                {
+                    for param in &parent.template_params {
+                        level_subs.insert(param.clone(), model_fqn.clone());
+                    }
+                }
+            }
 
             // Merge traits used by the parent class as well, so that
             // grandparent-level trait members are visible.
@@ -252,7 +277,30 @@ impl Backend {
             // Build a substitution map for this trait if the using class
             // declared `@use TraitName<Type1, Type2>` and the trait has
             // `@template` parameters.
-            let trait_subs = build_trait_substitution_map(trait_name, &trait_info, use_generics);
+            let mut trait_subs =
+                build_trait_substitution_map(trait_name, &trait_info, use_generics);
+
+            // ── Convention-based HasFactory fallback ─────────────────
+            // When a model uses `HasFactory` without `@use HasFactory<X>`,
+            // derive the factory class from the naming convention
+            // (e.g. `App\Models\User` → `Database\Factories\UserFactory`)
+            // and substitute `TFactory` automatically.
+            if trait_subs.is_empty()
+                && !trait_info.template_params.is_empty()
+                && is_has_factory_trait(trait_name)
+                && extends_eloquent_model(merged, class_loader)
+            {
+                let model_fqn = match &merged.file_namespace {
+                    Some(ns) if !ns.is_empty() => format!("{}\\{}", ns, merged.name),
+                    _ => merged.name.clone(),
+                };
+                let factory_fqn = model_to_factory_fqn(&model_fqn);
+                if class_loader(&factory_fqn).is_some() {
+                    for param in &trait_info.template_params {
+                        trait_subs.insert(param.clone(), factory_fqn.clone());
+                    }
+                }
+            }
 
             // Recursively merge traits used by this trait (trait composition).
             // The sub-trait's own `@use` generics (from the trait's docblock)
@@ -454,6 +502,22 @@ impl Backend {
 
 // ─── Generic Type Substitution ──────────────────────────────────────────────
 
+/// Check whether a trait name is the Laravel `HasFactory` trait.
+///
+/// Matches the FQN `Illuminate\Database\Eloquent\Factories\HasFactory`
+/// as well as the short name `HasFactory` (common in same-file tests).
+fn is_has_factory_trait(trait_name: &str) -> bool {
+    let stripped = trait_name.strip_prefix('\\').unwrap_or(trait_name);
+    stripped == "Illuminate\\Database\\Eloquent\\Factories\\HasFactory" || stripped == "HasFactory"
+}
+
+/// Check whether a parent class name is the Laravel
+/// `Illuminate\Database\Eloquent\Factories\Factory` base class.
+fn is_factory_class(class_name: &str) -> bool {
+    let stripped = class_name.strip_prefix('\\').unwrap_or(class_name);
+    stripped == "Illuminate\\Database\\Eloquent\\Factories\\Factory" || stripped == "Factory"
+}
+
 /// Build a substitution map for a trait based on `@use` generics and the
 /// trait's `@template` parameters.
 ///

src/resolution.rs

@@ -166,6 +166,16 @@ impl Backend {
         let file_namespace = self.parse_namespace(content);
         Self::resolve_parent_class_names(&mut classes, &file_use_map, &file_namespace);
 
+        // Set the per-class file_namespace so that classes loaded via
+        // PSR-4 / classmap carry their namespace.  This mirrors the
+        // same assignment done in `update_ast_inner` for files opened
+        // through `did_open` / `did_change`.
+        for cls in &mut classes {
+            if cls.file_namespace.is_none() {
+                cls.file_namespace = file_namespace.clone();
+            }
+        }
+
         if let Ok(mut map) = self.ast_map.lock() {
             map.insert(uri.to_owned(), classes.clone());
         }