CPP-owning model

Author: nicolas-grekas

Zend/tests/readonly_props/cpp_reassign_child_redefine.phpt

@@ -29,8 +29,8 @@ $c1 = new C1();
 var_dump($c1->x);
 
 // Case 2: Parent uses CPP and reassigns; child redefines as non-promoted.
-// Parent's CPP sets the initial value, but the reassignment fails because the
-// child's non-promoted redefinition does not open a reassignment window for the parent.
+// The child does not use CPP, so it does not claim CPP ownership of the property.
+// P2's CPP "owns" the reassignment window: P2's body write succeeds.
 class P2 {
     public function __construct(
         public readonly string $x = 'P1',
@@ -43,11 +43,7 @@ class C2 extends P2 {
     public readonly string $x;
 
     public function __construct() {
-        try {
-            parent::__construct();
-        } catch (Throwable $e) {
-            echo get_class($e), ": ", $e->getMessage(), "\n";
-        }
+        parent::__construct();
     }
 }
 
@@ -83,7 +79,6 @@ var_dump($c3->x);
 --EXPECT--
 Error: Cannot modify readonly property C1::$x
 string(1) "P"
-Error: Cannot modify readonly property C2::$x
-string(2) "P1"
+string(2) "P2"
 Error: Cannot modify readonly property C3::$x
 string(2) "C1"

Zend/tests/readonly_props/cpp_reassign_indirect_allowed.phpt

@@ -24,16 +24,16 @@ class MultipleReassign {
     public function __construct(
         public readonly string $prop = 'default',
     ) {
-        $this->initProp();
+        $this->initProp("first from method");
         try {
-            $this->initProp();  // Second call - should fail
+            $this->initProp("second from method");  // Second call - should fail
         } catch (Throwable $e) {
             echo get_class($e), ": ", $e->getMessage(), "\n";
         }
     }
 
-    private function initProp(): void {
-        $this->prop = 'from method';
+    private function initProp(string $v): void {
+        $this->prop = $v;
     }
 }
 
@@ -44,4 +44,4 @@ var_dump($mr->prop);
 --EXPECT--
 string(11) "from method"
 Error: Cannot modify readonly property MultipleReassign::$prop
-string(11) "from method"
+string(17) "first from method"

Zend/tests/readonly_props/cpp_reassign_reflection.phpt

@@ -7,7 +7,7 @@ class Foo {
     public function __construct(
         public readonly string $bar = 'default',
     ) {
-        $this->bar = 'overwritten in constructor';
+        $this->bar = strtoupper($bar);
     }
 }
 
@@ -31,9 +31,11 @@ try {
 } catch (Throwable $e) {
     echo get_class($e), ": ", $e->getMessage(), "\n";
 }
+var_dump($obj->bar);
 
 ?>
 --EXPECT--
 Error: Typed property Foo::$bar must not be accessed before initialization
-string(26) "overwritten in constructor"
+string(13) "EXPLICIT CALL"
 Error: Cannot modify readonly property Foo::$bar
+string(13) "EXPLICIT CALL"

Zend/tests/readonly_props/cpp_reassign_visibility.phpt

@@ -49,10 +49,10 @@ class Child2 extends Parent2 {
 $child2 = new Child2();
 var_dump($child2->prop);
 
-// Case 3: public - child's init() CAN modify within CPP window
+// Case 3: public(set) - child's init() CAN modify within CPP window
 class Parent3 {
     public function __construct(
-        public readonly string $prop = 'parent default',
+        public public(set) readonly string $prop = 'parent default',
     ) {
         $this->init();
     }

Zend/zend_object_handlers.c

@@ -1111,16 +1111,38 @@ ZEND_API zval *zend_std_write_property(zend_object *zobj, zend_string *name, zva
 					variable_ptr = &EG(error_zval);
 					goto exit;
 				}
-				/* For promoted readonly properties being initialized for the first time,
-				 * set IS_PROP_REINITABLE to allow one reassignment in the constructor.
-				 * The flag will be cleared by zend_leave_helper when the constructor exits.
-				 * We check the current execute data directly (no stack walk needed) because
-				 * CPP initialization always runs within the constructor frame itself. */
-				if ((prop_info->flags & (ZEND_ACC_READONLY | ZEND_ACC_PROMOTED)) == (ZEND_ACC_READONLY | ZEND_ACC_PROMOTED)
+				/* For readonly properties initialized for the first time via CPP, set
+				 * IS_PROP_REINITABLE to allow one reassignment in the constructor body.
+				 * The flag is cleared by zend_leave_helper when the constructor exits.
+				 *
+				 * Classical case: the property is promoted in the declaring class and the
+				 * executing constructor belongs to that class (scope == prop_info->ce).
+				 *
+				 * Extended case: a child class redeclared the property without CPP, so
+				 * prop_info->ce is the child but the property isn't promoted there. CPP
+				 * "ownership" still belongs to the ancestor whose constructor has CPP for
+				 * this property name, so its body is allowed to reassign once. The clearing
+				 * loop in zend_leave_helper iterates the exiting ctor's own promoted props,
+				 * which share the same object slot, so cleanup happens automatically. */
+				bool reinitable = false;
+				if ((prop_info->flags & ZEND_ACC_READONLY)
 				 && (Z_PROP_FLAG_P(variable_ptr) & IS_PROP_UNINIT)
 				 && EG(current_execute_data)
-				 && (EG(current_execute_data)->func->common.fn_flags & ZEND_ACC_CTOR)
-				 && EG(current_execute_data)->func->common.scope == prop_info->ce) {
+				 && (EG(current_execute_data)->func->common.fn_flags & ZEND_ACC_CTOR)) {
+					zend_class_entry *ctor_scope = EG(current_execute_data)->func->common.scope;
+					if (prop_info->flags & ZEND_ACC_PROMOTED) {
+						reinitable = (ctor_scope == prop_info->ce);
+					} else if (ctor_scope != prop_info->ce) {
+						/* Child redeclared without CPP: check if the executing ctor's class
+						 * has a CPP declaration for this property name. */
+						zend_property_info *scope_prop = zend_hash_find_ptr(
+							&ctor_scope->properties_info, prop_info->name);
+						reinitable = scope_prop != NULL
+							&& (scope_prop->flags & (ZEND_ACC_READONLY|ZEND_ACC_PROMOTED))
+							   == (ZEND_ACC_READONLY|ZEND_ACC_PROMOTED);
+					}
+				}
+				if (reinitable) {
 					Z_PROP_FLAG_P(variable_ptr) = IS_PROP_REINITABLE;
 				} else {
 					Z_PROP_FLAG_P(variable_ptr) &= ~(IS_PROP_UNINIT|IS_PROP_REINITABLE);