New Object Declaration Syntax

Tier 0 · Story 06Complete

Tyhp adds new syntax to class declarations that does not exist in PHP. This includes constructor return types for explicit constructor chaining, promoted constructor parameters, and property accessors. These features make class declarations more expressive and self-documenting.

Constructor Return Types

In PHP, constructors never have a return type. Tyhp constructors may declare : void when the constructor does not chain to a parent, or : parent(args...) when it does. Omitting the return type is equivalent to : void: no parent::__construct(...) call is inserted. Use : parent(args...) when you want the parent constructor called first.

Explicit Void Constructor

A constructor that does not use : parent(...) may be declared : void, or the return type may be omitted entirely — the two forms are equivalent. Both mean this constructor does not insert a parent::__construct(...) call.

<?tyhp

class SimpleClass
{
    public function __construct(
        public string $name,
        public int $age
    ): void {}
}

// Equivalent: the return type may be omitted.
class AnotherClass
{
    public function __construct(
        public string $name,
        public int $age
    ) {}
}

Compiled PHP Output

The : void annotation is stripped from the PHP output. The constructor is emitted as a standard PHP constructor with no return type.

<?php

class SimpleClass
{
    public function __construct(
        public string $name,
        public int $age
    ) {}
}

Constructor Chaining with : parent(args...)

The : parent(args...) syntax calls the parent constructor at the START of the child constructor body. The arguments in the parent(...) call are passed to parent::__construct(). This replaces the manual parent::__construct(...) call that PHP developers write by hand and guarantees it always runs first.

<?tyhp

class BaseModel
{
    public function __construct(
        protected bool $isActive,
        protected int $priority,
        protected string $label
    ): void {}
}

class UserModel extends BaseModel
{
    public string $displayName;

    public function __construct(string $name): parent(false, 19, $name)
    {
        $this->displayName = \strtoupper($name);
    }
}

Compiled PHP Output

The : parent(args...) annotation compiles to a parent::__construct(args...) call inserted at the very beginning of the constructor body. The return type annotation is removed.

<?php

class BaseModel
{
    public function __construct(
        protected bool $isActive,
        protected int $priority,
        protected string $label
    ) {}
}

class UserModel extends BaseModel
{
    public string $displayName;

    public function __construct(string $name)
    {
        parent::__construct(false, 19, $name);
        $this->displayName = \strtoupper($name);
    }
}

Original Incoming Values

An important detail: the arguments passed to parent(...) use the original incoming parameter values, not values modified within the constructor body. Even if a parameter is reassigned inside the constructor, the parent receives the value as it was when the constructor was called.

<?tyhp

class Child extends BaseModel
{
    public string $processed;

    public function __construct(string $input): parent(true, 5, $input)
    {
        $input = \strtolower($input);
        $this->processed = $input;
    }
}

<?php

class Child extends BaseModel
{
    public string $processed;

    public function __construct(string $input)
    {
        parent::__construct(true, 5, $input);
        $input = \strtolower($input);
        $this->processed = $input;
    }
}

Passing Static Values and Parameters

Because parent(...) is inserted at the start of the constructor body, prefer literals, constants, and incoming parameters. Avoid $this and method calls in those arguments — the instance is not fully constructed yet. The compiler does not currently reject those expressions; treat this as guidance, not a hard check.

<?tyhp

class Vehicle extends BaseModel
{
    public function __construct(
        string $type,
        int $year
    ): parent(true, $year, $type) {}
}

class DefaultVehicle extends BaseModel
{
    public function __construct(): parent(false, 0, 'unknown') {}
}

<?php

class Vehicle extends BaseModel
{
    public function __construct(
        string $type,
        int $year
    ) {
        parent::__construct(true, $year, $type);
    }
}

class DefaultVehicle extends BaseModel
{
    public function __construct()
    {
        parent::__construct(false, 0, 'unknown');
    }
}

Constructor Property Promotion

Constructor property promotion works as in PHP 8. Constructor parameters may be promoted with visibility and readonly. Use readonly when a property should be set only during construction. clone $obj with [...] can still update readonly properties on the copy; see the with keyword page.

<?tyhp

class Point
{
    public function __construct(
        public readonly float $x,
        public readonly float $y,
        public readonly float $z = 0.0
    ): void {}
}

$p = new Point(1.0, 2.0);
$q = clone $p with [z => 5.0];

Property Accessors (PHP 8.4 Hooks)

Tyhp supports PHP 8.4 property hooks (get / set) on class properties. Hook bodies match PHP: a parameter-less get { ... }, optional set { ... } (the incoming value is $value), or a typed set(string $value) { ... }. &get and final get / final set are also valid.

<?tyhp

final class Widget {
    private string $_name = '';

    public string $name {
        get {
            return $this->_name;
        }
        set(string $value) {
            $this->_name = $value;
        }
    }
}

On PHP 8.4+, the compiler emits native hook syntax. On PHP 8.2–8.3, it lowers the same source through a polyfill (\Tyhp\Concerns\UsesPropertyAccessors and $this->__tyhpPropertyHook) so hooked properties work without native PHP 8.4 hooks.

To describe a hooked PHP property in a .tyhpdef file, write the bodyless list { get; set; } (or { &get; }). Hook bodies stay in .tyhp (and in PHP). See Classes in Tyhpdef.

Best Practices

Common Mistakes

<?tyhp

// Avoid: no parent class to chain to (emits parent::__construct anyway)
// class NoParent {
//     public function __construct(): parent() {}
// }

// Avoid: $this / method calls in parent args (not a compiler error today)
// class Bad extends BaseModel {
//     public function __construct(string $name): parent(true, 0, $this->process($name)) {}
// }

// Avoid: double parent call (not a compiler error today)
// class Double extends BaseModel {
//     public function __construct(string $name): parent(true, 0, $name) {
//         parent::__construct(true, 0, $name);
//     }
// }

Compiler Errors

• Passing arguments to parent(...) that don't match the parent constructor's parameter types.