Property Promotion And Constructor Shorthand

The Boilerplate It Replaces

The classic pattern — declare, accept, assign — for every dependency or value:

<?php

declare(strict_types=1);

// Pre-8.0 style: each property named three or four times.
class Point {
    private float $x;
    private float $y;

    public function __construct(float $x, float $y) {
        $this->x = $x;
        $this->y = $y;
    }
}

$p = new Point(1.5, 2.5);
echo 'created' . PHP_EOL;

// Prints:
// created

For a service with five injected dependencies, this is fifteen lines of pure ceremony that say nothing the parameter list did not already say.

Promotion: One Declaration Each

Put a visibility modifier (public, private, protected, or readonly) on a constructor parameter, and PHP automatically declares the property and assigns the argument to it. The two classes below are equivalent:

<?php

declare(strict_types=1);

class Point {
    public function __construct(
        private float $x,
        private float $y,
    ) {}
}

$p = new Point(1.5, 2.5);

// A promoted parameter becomes a real property: declared, typed, and assigned.
echo 'x and y are now private properties of $p' . PHP_EOL;

// Prints:
// x and y are now private properties of $p

The visibility keyword is the trigger: a plain float $x parameter stays an ordinary argument, while private float $x is promoted to a property. Promoted properties keep their type, can have default values, and pair naturally with readonly for immutable value objects — public readonly float $x declares a public, read-once property in one stroke, which is the modern idiom for DTOs and value objects.

What It Expands To, And The Edges

Promotion is pure syntactic sugar: the compiler rewrites it into the declare-and-assign form above, so everything you know about ordinary properties still applies. That mental model resolves the edge cases:

• Mixing promoted and non-promoted is fine. Some parameters can be promoted while others stay plain arguments used only inside the constructor body.
• You can still have a constructor body. Promotion assigns before the body runs, so the body can validate or derive from the promoted properties: if ($this->x < 0) throw ... works.
• Defaults and nullability carry over, exactly as in a normal parameter and property.
• No promotion outside constructors. The feature is constructor-specific; other methods gain nothing from it.
• Combine with readonly for immutability, and remember readonly means assign-once — the property is set during construction and cannot change afterward, which is what makes promoted value objects safe to pass around.

Because it desugars to the familiar form, promotion changes only how much you type, not how the object behaves — reflection, serialization, and inheritance all see ordinary properties. The property promotion and readonly lessons in the OOP track go deeper on the object-design implications; here the point is the mechanic and its equivalence.

What To Check

Before moving on, make sure you can:

• write a promoted constructor and state the declare/accept/assign it replaces
• explain that a visibility (or readonly) modifier is what triggers promotion
• mix promoted and non-promoted parameters, and keep a constructor body
• combine promotion with readonly for immutable value objects
• explain that promotion is sugar that desugars to ordinary properties

What You Should Be Able To Do

After this lesson, you should be able to use constructor property promotion to remove declaration boilerplate, reach for readonly promoted properties when building value objects and DTOs, and reason about promoted properties by mentally expanding them to their plain equivalent.