search

xp-framework / compiler

Compiles future PHP to today's PHP.
19 stars 0 forks source link

Implement property hooks via virtual properties #166

Closed thekid closed 3 months ago

thekid commented 1 year ago

This pull request adds support for property hooks to all PHP versions

Example

This example calculates and caches the full name from first and last names

class User {
  private string $full;
  private string $first { set { $field= $value; unset($this->full); } }
  private string $last { set { $field= $value; unset($this->full); } }
  public string $fullName => $this->full??= $this->first.' '.$this->last;

  public function __construct(string $first, string $last) {
    $this->first= $first;
    $this->last= $last;
  }
}

$u= new User('Timm', 'Friebe');
$u->fullName; // "Timm Friebe"

Implementation

The above results in the following being emitted:

class User {
  private string $full;
  private function __set_first($value) { $this->__virtual['first']= $value; unset($this->full); }
  private function __set_last($value) { $this->__virtual['last']= $value; unset($this->full); }
  public function __get_fullName() { return $this->full??= $this->first.' '.$this->last; }

  public function __construct(string $first, string $last) {
    $this->first= $first;
    $this->last= $last;
  }

  private $__virtual= ['first' => null, 'last' => null, 'fullName' =>  null];

  public function __set($name, $value) {
    switch ($name) {
       case 'first': /* Check omitted for brevity */ $this->__set_first($value); break;
       case 'last': /* Check omitted for brevity */ $this->__set_last($value); break; 
       default: throw new \Error('Unknown property '.$name);
    }
  }

  public function __get($name) {
    switch ($name) {
       case 'fullName': return $this->__get_fullName(); break;
       default: throw new \Error('Unknown property '.$name);
    }
  }
}

Shortcomings

See also

thekid commented 1 year ago

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]())

Kind This member Parent member
Constant self::CONSTANT parent::CONSTANT
Static method self::method() parent::method()
Static property self::$property parent::$property
Instance method $this->method() parent::method()
Constructor never invoked directly parent::__construct()
Instance property $this->property not possible or useful

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 https://github.com/xp-framework/compiler/pull/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

thekid commented 6 months ago

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

thekid commented 6 months ago

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

thekid commented 6 months ago

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;
thekid commented 6 months ago

Status: Waiting for PHP RFC to successfully be voted on

thekid commented 5 months ago

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

thekid commented 4 months ago

✅ Now works with both current PHP 8.4 and PHP 8.4 with https://github.com/php/php-src/pull/13455 in place

thekid commented 3 months ago

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

thekid commented 3 months ago

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