Implement property hooks via virtual properties

composer.json

@@ -7,7 +7,7 @@
   "keywords": ["module", "xp"],
   "require" : {
     "xp-framework/core": "^11.0 | ^10.0",
-    "xp-framework/ast": "^10.1",
+    "xp-framework/ast": "dev-feature/property-hooks as 10.2.0",
     "php" : ">=7.0.0"
   },
   "require-dev" : {

src/main/php/lang/ast/emit/PHP.class.php

@@ -441,7 +441,7 @@ protected function emitClass($result, $class) {
       }
       $result->out->write('];');
 
-      $result->out->write('public function __get($name) { switch ($name) {');
+      $result->out->write('public function &__get($name) { switch ($name) {');
       foreach ($context->virtual as $name => $access) {
         $result->out->write($name ? 'case "'.$name.'":' : 'default:');
         $this->emitOne($result, $access[0]);

src/main/php/lang/ast/emit/PHP70.class.php

@@ -22,13 +22,13 @@ class PHP70 extends PHP {
     OmitConstantTypes,
     OmitPropertyTypes,
     ReadonlyClasses,
-    ReadonlyProperties,
     RewriteAssignments,
     RewriteClassOnObjects,
     RewriteEnums,
     RewriteExplicitOctals,
     RewriteLambdaExpressions,
     RewriteMultiCatch,
+    RewriteProperties,
     RewriteThrowableExpressions
   ;
 

src/main/php/lang/ast/emit/PHP71.class.php

@@ -20,13 +20,13 @@ class PHP71 extends PHP {
     OmitArgumentNames,
     OmitConstantTypes,
     OmitPropertyTypes,
-    ReadonlyProperties,
     ReadonlyClasses,
     RewriteAssignments,
     RewriteClassOnObjects,
     RewriteEnums,
     RewriteExplicitOctals,
     RewriteLambdaExpressions,
+    RewriteProperties,
     RewriteThrowableExpressions
   ;
 

src/main/php/lang/ast/emit/PHP72.class.php

@@ -20,13 +20,13 @@ class PHP72 extends PHP {
     OmitArgumentNames,
     OmitConstantTypes,
     OmitPropertyTypes,
-    ReadonlyProperties,
     ReadonlyClasses,
     RewriteAssignments,
     RewriteClassOnObjects,
     RewriteEnums,
     RewriteExplicitOctals,
     RewriteLambdaExpressions,
+    RewriteProperties,
     RewriteThrowableExpressions
   ;
 

src/main/php/lang/ast/emit/PHP73.class.php

@@ -21,12 +21,12 @@ class PHP73 extends PHP {
     OmitArgumentNames,
     OmitConstantTypes,
     OmitPropertyTypes,
-    ReadonlyProperties,
     ReadonlyClasses,
     RewriteClassOnObjects,
     RewriteEnums,
     RewriteExplicitOctals,
     RewriteLambdaExpressions,
+    RewriteProperties,
     RewriteThrowableExpressions
   ;
 

src/main/php/lang/ast/emit/PHP74.class.php

@@ -19,11 +19,11 @@ class PHP74 extends PHP {
     OmitArgumentNames,
     OmitConstantTypes,
     ReadonlyClasses,
-    ReadonlyProperties,
     RewriteBlockLambdaExpressions,
     RewriteClassOnObjects,
     RewriteEnums,
     RewriteExplicitOctals,
+    RewriteProperties,
     RewriteThrowableExpressions
   ;
 

src/main/php/lang/ast/emit/PHP80.class.php

@@ -23,11 +23,11 @@ class PHP80 extends PHP {
     CallablesAsClosures,
     OmitConstantTypes,
     ReadonlyClasses,
-    ReadonlyProperties,
     RewriteBlockLambdaExpressions,
     RewriteDynamicClassConstants,
     RewriteEnums,
-    RewriteExplicitOctals
+    RewriteExplicitOctals,
+    RewriteProperties
   ;
 
   /** Sets up type => literal mappings */

src/main/php/lang/ast/emit/PHP81.class.php

@@ -19,7 +19,7 @@
  * @see  https://wiki.php.net/rfc#php_81
  */
 class PHP81 extends PHP {
-  use RewriteBlockLambdaExpressions, RewriteDynamicClassConstants, ReadonlyClasses, OmitConstantTypes;
+  use RewriteBlockLambdaExpressions, RewriteDynamicClassConstants, ReadonlyClasses, OmitConstantTypes, PropertyHooks;
 
   /** Sets up type => literal mappings */
   public function __construct() {

src/main/php/lang/ast/emit/PHP82.class.php

@@ -19,7 +19,7 @@
  * @see  https://wiki.php.net/rfc#php_82
  */
 class PHP82 extends PHP {
-  use RewriteBlockLambdaExpressions, RewriteDynamicClassConstants, ReadonlyClasses, OmitConstantTypes;
+  use RewriteBlockLambdaExpressions, RewriteDynamicClassConstants, ReadonlyClasses, OmitConstantTypes, PropertyHooks;
 
   /** Sets up type => literal mappings */
   public function __construct() {

src/main/php/lang/ast/emit/PHP83.class.php

@@ -18,7 +18,7 @@
  * @see  https://wiki.php.net/rfc#php_83
  */
 class PHP83 extends PHP {
-  use RewriteBlockLambdaExpressions, ReadonlyClasses;
+  use RewriteBlockLambdaExpressions, ReadonlyClasses, PropertyHooks;
 
   /** Sets up type => literal mappings */
   public function __construct() {

src/main/php/lang/ast/emit/PropertyHooks.class.php

@@ -0,0 +1,171 @@
+<?php namespace lang\ast\emit;
+
+use lang\ast\Code;
+use lang\ast\nodes\{
+  Assignment,
+  Block,
+  InstanceExpression,
+  InvokeExpression,
+  Literal,
+  Method,
+  OffsetExpression,
+  Parameter,
+  ReturnStatement,
+  ScopeExpression,
+  Signature,
+  Variable
+};
+
+/**
+ * Property hooks
+ *
+ * @see  https://wiki.php.net/rfc/property-hooks
+ * @test lang.ast.unittest.emit.PropertyHooksTest
+ */
+trait PropertyHooks {
+
+  protected function rewriteHook($node, $name, $virtual, $literal) {
+
+    // Magic constant referencing property name
+    if ($node instanceof Literal && '__PROPERTY__' === $node->expression) return $literal;
+
+    // Special variable $field, $this->propertyName syntax
+    if ($node instanceof Variable && 'field' === $node->pointer || (
+      $node instanceof InstanceExpression &&
+      $node->expression instanceof Variable && 'this' === $node->expression->pointer &&
+      $node->member instanceof Literal && $name === $node->member->expression
+    )) return $virtual;
+
+    // <T>::$field::hook() => <T>::__<hook>_<field>()
+    if (
+      $node instanceof ScopeExpression &&
+      $node->member instanceof InvokeExpression &&
+      $node->member->expression instanceof Literal &&
+      $node->type instanceof ScopeExpression &&
+      $node->type->member instanceof Variable &&
+      is_string($node->type->type) &&
+      is_string($node->type->member->pointer)
+    ) {
+      return new ScopeExpression($node->type->type, new InvokeExpression(
+        new Literal('__'.$node->member->expression->expression.'_'.$node->type->member->pointer),
+        $node->member->arguments
+      ));
+    }
+
+    foreach ($node->children() as &$child) {
+      $child= $this->rewriteHook($child, $name, $virtual, $literal);
+    }
+    return $node;
+  }
+
+  protected function withScopeCheck($modifiers, $nodes) {
+    if ($modifiers & MODIFIER_PRIVATE) {
+      $check= (
+        '$scope= debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]["class"] ?? null;'.
+        'if (__CLASS__ !== $scope && \\lang\\VirtualProperty::class !== $scope)'.
+        'throw new \\Error("Cannot access private property ".__CLASS__."::".$name);'
+      );
+    } else if ($modifiers & MODIFIER_PROTECTED) {
+      $check= (
+        '$scope= debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]["class"] ?? null;'.
+        'if (__CLASS__ !== $scope && !is_subclass_of($scope, __CLASS__) && \\lang\\VirtualProperty::class !== $scope)'.
+        'throw new \\Error("Cannot access protected property ".__CLASS__."::".$name);'
+      );
+    } else if (1 === sizeof($nodes)) {
+      return $nodes[0];
+    } else {
+      return new Block($nodes);
+    }
+
+    array_unshift($nodes, new Code($check));
+    return new Block($nodes);
+  }
+
+  protected function emitProperty($result, $property) {
+    static $lookup= [
+      'public'    => MODIFIER_PUBLIC,
+      'protected' => MODIFIER_PROTECTED,
+      'private'   => MODIFIER_PRIVATE,
+      'static'    => MODIFIER_STATIC,
+      'final'     => MODIFIER_FINAL,
+      'abstract'  => MODIFIER_ABSTRACT,
+      'readonly'  => 0x0080, // XP 10.13: MODIFIER_READONLY
+    ];
+
+    if (empty($property->hooks)) return parent::emitProperty($result, $property);
+
+    // Emit XP meta information for the reflection API
+    $scope= $result->codegen->scope[0];
+    $modifiers= 0;
+    foreach ($property->modifiers as $name) {
+      $modifiers|= $lookup[$name];
+    }
+    $scope->meta[self::PROPERTY][$property->name]= [
+      DETAIL_RETURNS     => $property->type ? $property->type->name() : 'var',
+      DETAIL_ANNOTATIONS => $property->annotations,
+      DETAIL_COMMENT     => $property->comment,
+      DETAIL_TARGET_ANNO => [],
+      DETAIL_ARGUMENTS   => [$modifiers]
+    ];
+
+    $literal= new Literal("'{$property->name}'");
+    $virtual= new InstanceExpression(new Variable('this'), new OffsetExpression(new Literal('__virtual'), $literal));
+
+    // Emit get and set hooks in-place. Ignore any unknown hooks
+    $get= $set= null;
+    foreach ($property->hooks as $type => $hook) {
+      $method= '__'.$type.'_'.$property->name;
+      $modifierList= $modifiers & MODIFIER_ABSTRACT ? ['abstract'] : $hook->modifiers;
+      if ('get' === $type) {
+        $this->emitOne($result, new Method(
+          $modifierList,
+          $method,
+          new Signature([], null, $hook->byref),
+          null === $hook->expression ? null : [$this->rewriteHook(
+            $hook->expression instanceof Block ? $hook->expression : new ReturnStatement($hook->expression),
+            $property->name,
+            $virtual,
+            $literal
+          )],
+          null // $hook->annotations
+        ));
+        $get= $this->withScopeCheck($modifiers, [
+          new Assignment(new Variable('r'), $hook->byref ? '=&' : '=', new InvokeExpression(
+            new InstanceExpression(new Variable('this'), new Literal($method)),
+            []
+          )),
+          new ReturnStatement(new Variable('r'))
+        ]);
+      } else if ('set' === $type) {
+        $this->emitOne($result, new Method(
+          $modifierList,
+          $method,
+          new Signature($hook->parameter ? [$hook->parameter] : [new Parameter('value', null)], null),
+          null === $hook->expression ? null : [$this->rewriteHook(
+            $hook->expression,
+            $property->name,
+            $virtual,
+            $literal
+          )],
+          null // $hook->annotations
+        ));
+        $set= $this->withScopeCheck($modifiers, [new InvokeExpression(
+          new InstanceExpression(new Variable('this'), new Literal($method)),
+          [new Variable('value')]
+        )]);
+      }
+    }
+
+    // Declare virtual properties with __set and __get as well as initializations
+    // except inside interfaces, which cannot contain properties.
+    if ('interface' === $scope->type->kind) return;
+
+    $scope->virtual[$property->name]= [
+      $get ?? new ReturnStatement($virtual),
+      $set ?? new Assignment($virtual, '=', new Variable('value'))
+    ];
+    if (isset($property->expression)) {
+      $scope->init[sprintf('$this->__virtual["%s"]', $property->name)]= $property->expression;
+    }
+  }
+}

src/main/php/lang/ast/emit/ReadonlyProperties.class.php

@@ -55,7 +55,7 @@ protected function emitProperty($result, $property) {
 
     // Create virtual property implementing the readonly semantics
     $scope->virtual[$property->name]= [
-      new Code(sprintf($check.'return $this->__virtual["%1$s"][0] ?? null;', $property->name)),
+      new Code(sprintf($check.'return $this->__virtual["%1$s"][0];', $property->name)),
       new Code(sprintf(
         ($check ?: '$scope= debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2)[1]["class"] ?? null;').
         'if (isset($this->__virtual["%1$s"])) throw new \\Error("Cannot modify readonly property ".__CLASS__."::{$name}");'.

src/main/php/lang/ast/emit/RewriteProperties.class.php

@@ -0,0 +1,17 @@
+<?php namespace lang\ast\emit;
+
+trait RewriteProperties {
+  use PropertyHooks, ReadonlyProperties {
+    PropertyHooks::emitProperty as emitPropertyHooks;
+    ReadonlyProperties::emitProperty as emitReadonlyProperties;
+  }
+
+  protected function emitProperty($result, $property) {
+    if ($property->hooks) {
+      return $this->emitPropertyHooks($result, $property);
+    } else if (in_array('readonly', $property->modifiers)) {
+      return $this->emitReadonlyProperties($result, $property);
+    }
+    parent::emitProperty($result, $property);
+  }
+}