On the ambiguity of parent::$propertyName::get()

In current PHP, this means the following:

On the parent class' static property $x, invoke a static method named get

Example

abstract class OS {
  public function exec($command, $arguments= []) { ... } }

class Command {
  public static $OS;

  static fucntion __static() {
    self::$OS= ...
  }
}

class Test extends Command {
  public function run($arguments= []) {
    return parent::$OS::exec('xp', ['test', ...$arguments]);
  }
}

Inside Test, however, self::$OS would suffice, so after carefully thinking about it I agree with the statement in the RFC: As the above code is very rare in the wild and rather contrived, and easily worked around, we feel this edge case is acceptable.

Possible alternative: parent::$propertyName (without ::[set|get]())

The most consistent way would be to use parent::$property here. Determining whether to invoke get or set could be done by looking for assignment expression, and only invoking set in those situations.

Possible alternative: $this->propertyName

Inside hooks, we should use $field to reference the property rather than $this->propertyName, which the RFC states is "supported by discouraged". If we drop this translation, we could use it as follows:

class Base {
  public $test { get => 'Test'; }
}

class Child extends Base {
  public $test { get => $this->test.'!'; }
}

$test= (new Child())->test; // "Test!"

See https://gist.github.com/thekid/d83bac22f30e3d3e41425bb703ab1d0b

Possible alternative: parent->propertyName

Same as above, a bit more specific and in line with #164, but would be ambiguous with accessing the property propertyName of a constant named parent:

define('parent', new class() { public $propertyName= 'Test'; }); 

$name= parent->propertyName; // "Test"

This would be inconsistent with parent::<method>() syntax to invoke parent methods and the parent constructor.

Discussion in the original "Property accessors" RFC

An open question is how parent accessors may be invoked. A possible syntax is to use parent::$prop for the parent getter and parent::$prop = $value for the parent setter. As the “static-ness” of properties cannot change, this reference should be unambiguous.

This syntax can't extend to other accessor types though, so those would either have no way to invoke the parent accessor, or invoke it implicitly. For possible guard accessors, it would make sense to automatically chain the accessors (though the order is not entirely obvious). For lazy accessors this wouldn't be possible though.

Other syntax choices like parent::$prop::get() are somewhat ambiguous, for example this syntax looks like a static property access followed by a static method call.

In any case, adding support for parent accessors will be technically non-trivial, because we need to perform a modified-scope property access through a separate syntax.

Source: https://wiki.php.net/rfc/property_accessors

After much on-again/off-again work, Ilija and I are back with a more polished property access hooks/interface properties RFC. It’s 99% unchanged from last summer; the PR is now essentially complete and more robust, and we were able to squish the last remaining edge cases.

Baring any major changes, we plan to bring this to a vote in mid-March.

https://externals.io/message/122445

More changes, see https://externals.io/message/122445#122583, especially:

Shorthands

The $foo => expression shorthand has been removed. The legal shorthands are now:

public string $foo {
  get => /* evaluates to a value; */
  set => /* assigns this value; */
}

The set shorthand (with =>) now means "write this value instead", see https://wiki.php.net/rfc/property-hooks#short-set

Type and name

On a set hook, the user may specify both a type and name, or neither. (That is, set {} or set (Foo $newFoo). If not specified, it defaults to the type of the property and $value, as before.

Parent

Clarified that the parent::$foo::get() syntax works on a parent property regardless of whether it has hooks

The rest of the changes seem to not have any effect on this implementation

Clarified that the parent::$foo::get() syntax works on a parent property regardless of whether it has hooks

This cannot work in this implementation due to us relying on __set and __get, as in the following, the virtual property would never be triggered:

class B {
    public mixed $x;
}
class C extends B {
    public mixed $x {
        set {
            $f = parent::$x::set(...);
            $f($value);
        }
    }
}

$c = new C();
$c->x = 0;

Status: Waiting for PHP RFC to successfully be voted on

The vote for the Property Hooks RFC is now open, see https://externals.io/message/123139

✅ Now works with both current PHP 8.4 and PHP 8.4 with php/php-src#13455 in place

AST syntax is released: https://github.com/xp-framework/ast/releases/tag/v11.1.0

Released in https://github.com/xp-framework/compiler/releases/tag/v9.1.0