In a PHP model base class, how do you write a static factory such as User::create() that returns the subclass, and what can break it?

## The goal A common base-class design gives every model a **static named constructor**: ```php $user = User::create(['name' => 'Ada']); $post = Post::create(['title' => 'Hello']); ``` `create()` is written once, in the base class `Model`, but each call should return an instance of the class it was called on. That requires the base class to refer to "whichever subclass was called", which is what **late static binding** (the `static` keyword) provides. ## `new self` versus `new static` | Expression inside `Model::create()` | `User::create()` returns | Notes | |---|---|---| | `new self(...)` | a `Model` | `self` is the class where the code is written | | `new Model(...)` | a `Model` | same as `self`, but hard-coded | | `new static(...)` | a `User` | `static` is the called class, resolved at runtime | With `new self`, the subclass-specific methods are missing from the returned object. If the method also declares `: static` as its return type, PHP catches the mismatch at the return: `Model::create(): Return value must be of type User, Model returned` is a `TypeError`. ## The `static` return type PHP 8.0 added `static` as a **return type** (it is not allowed for parameters or properties). It means "an instance of the called class". It documents the contract, is enforced at runtime, and lets static analysers and IDEs infer `User` from `User::create()` without a docblock. PHP 8.5 also allows a `final` subclass to narrow an inherited `: static` return type to `self` or to its own class name when it overrides the method. ## What breaks `new static` 1. **Constructor signatures are not inherited contracts.** PHP checks that an overriding method is compatible with its parent, but it skips that check for constructors unless the parent constructor is `abstract` or declared in an interface. A subclass can therefore write `__construct(private string $title)`. `new static($attributes)` then passes the wrong arguments, and PHP throws `ArgumentCountError` ("Too few arguments to function Post::__construct() …") or a `TypeError`. 2. **An abstract base.** If `Model` is abstract, `Model::create()` makes `Model` the called class and `new static` throws `Error: Cannot instantiate abstract class Model`. Usually that is the right outcome; the factory is meant to be called on concrete subclasses. 3. **Abstract static hooks.** A base class often reads subclass details through `static::`, for example `static::table()`. If `table()` is declared `abstract public static` in the base and someone calls it on the base, PHP throws `Error: Cannot call abstract method Model::table()`. ## Making the constructor safe There are three ways to guarantee every subclass accepts what the factory passes: - **Declare the base constructor `final`.** Subclasses cannot override it, so `new static($attributes)` always matches. Subclass-specific setup moves into a protected hook the constructor calls. - **Declare it `abstract`, or in an interface the base implements.** PHP then applies the normal signature-compatibility check to subclass constructors. - **Make the class `final`** when it needs no subclasses at all. Then `static` and `self` name the same class and `new static` cannot meet a foreign constructor. PHPStan reports `Unsafe usage of new static()` for exactly this risk and stays quiet when the class is final, the constructor is final or abstract, or the constructor comes from an interface. ## Why not override `create()` in every subclass The alternative to late static binding is to write `create()` again in each subclass with `return new User(...)`. It works, but it multiplies identical code, and every new model must remember to add it. Worse, a subclass that forgets inherits the parent's version and quietly returns the wrong type unless a `: static` return type catches it. One `new static` in the base removes the duplication, and the return type turns a forgotten detail into an immediate `TypeError` instead of a subtle bug. ## Putting it together A robust version of the pattern: - the base constructor is `final` (or abstract with a fixed signature); - `create()` returns `new static(...)` and declares `: static`; - per-class details come from `static::` members such as a table-name method or constant; - the base class is `abstract`, so it cannot be instantiated by accident. The same technique powers fluent "with-er" methods that return `static` on immutable value objects, so a subclass's `withX()` keeps returning the subclass. Whether a class should have a single shared instance (the singleton pattern) is a separate design question; this pattern creates a new object on every call.