Add support for readonly classes

kocsismate · kocsismate · commit 1e3d5b8d5434 · 2021-07-25T15:19:20.000+02:00
diff --git a/Zend/tests/readonly_classes/readonly_class_duplicated_modifier.phpt b/Zend/tests/readonly_classes/readonly_class_duplicated_modifier.phpt
@@ -0,0 +1,12 @@
+--TEST--
+The readonly class modifier can only be added once
+--FILE--
+<?php
+
+readonly readonly class Foo
+{
+}
+
+?>
+--EXPECTF--
+Fatal error: Multiple readonly modifiers are not allowed in %s on line %d
diff --git a/Zend/tests/readonly_classes/readonly_class_dynamic_property.phpt b/Zend/tests/readonly_classes/readonly_class_dynamic_property.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Readonly classes cannot use dynamic properties
+--FILE--
+<?php
+
+readonly class Foo
+{
+}
+
+$foo = new Foo();
+
+try {
+    $foo->bar = 1;
+} catch (Error $exception) {
+    echo $exception->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+Cannot create dynamic property Foo::$bar
diff --git a/Zend/tests/readonly_classes/readonly_class_missing_type1.phpt b/Zend/tests/readonly_classes/readonly_class_missing_type1.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Normal properties of a readonly class must have type
+--FILE--
+<?php
+
+readonly class Foo
+{
+    public $bar;
+}
+
+?>
+--EXPECTF--
+Fatal error: Readonly property Foo::$bar must have type in %s on line %d
diff --git a/Zend/tests/readonly_classes/readonly_class_missing_type2.phpt b/Zend/tests/readonly_classes/readonly_class_missing_type2.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Promoted properties of a readonly class must have type
+--FILE--
+<?php
+
+readonly class Foo
+{
+    public function __construct(
+        private readonly $bar
+    ) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Readonly property Foo::$bar must have type in %s on line %d
diff --git a/Zend/tests/readonly_classes/readonly_class_property1.phpt b/Zend/tests/readonly_classes/readonly_class_property1.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Normal properties of a readonly class are implicitly declared as readonly
+--FILE--
+<?php
+
+readonly class Foo
+{
+    public int $bar;
+
+    public function __construct() {
+        $this->bar = 1;
+    }
+}
+
+$foo = new Foo();
+
+try {
+    $foo->bar = 2;
+} catch (Error $exception) {
+    echo $exception->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+Cannot modify readonly property Foo::$bar
diff --git a/Zend/tests/readonly_classes/readonly_class_property2.phpt b/Zend/tests/readonly_classes/readonly_class_property2.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Promoted properties of a readonly class are implicitly declared as readonly
+--FILE--
+<?php
+
+readonly class Foo
+{
+    public function __construct(
+        public int $bar
+    ) {}
+}
+
+$foo = new Foo(1);
+
+try {
+    $foo->bar = 2;
+} catch (Error $exception) {
+    echo $exception->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+Cannot modify readonly property Foo::$bar
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
@@ -1699,6 +1699,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio
 				if (decl->flags & ZEND_ACC_FINAL) {
 					smart_str_appends(str, "final ");
 				}
+				if (decl->flags & ZEND_ACC_READONLY_CLASS) {
+					smart_str_appends(str, "readonly ");
+				}
 				smart_str_appends(str, "class ");
 			}
 			smart_str_appendl(str, ZSTR_VAL(decl->name), ZSTR_LEN(decl->name));
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -794,6 +794,10 @@ uint32_t zend_add_class_modifier(uint32_t flags, uint32_t new_flag) /* {{{ */
 		zend_throw_exception(zend_ce_compile_error, "Multiple final modifiers are not allowed", 0);
 		return 0;
 	}
+	if ((flags & ZEND_ACC_READONLY_CLASS) && (new_flag & ZEND_ACC_READONLY_CLASS)) {
+		zend_throw_exception(zend_ce_compile_error, "Multiple readonly modifiers are not allowed", 0);
+		return 0;
+	}
 	if ((new_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) && (new_flags & ZEND_ACC_FINAL)) {
 		zend_throw_exception(zend_ce_compile_error,
 			"Cannot use the final modifier on an abstract class", 0);
@@ -6736,6 +6740,7 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall
 		if (property_flags) {
 			zend_op_array *op_array = CG(active_op_array);
 			zend_class_entry *scope = op_array->scope;
+
 			bool is_ctor =
 				scope && zend_is_constructor(op_array->function_name);
 			if (!is_ctor) {
@@ -6762,6 +6767,10 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall
 					ZSTR_VAL(scope->name), ZSTR_VAL(name), ZSTR_VAL(str));
 			}
 
+			if (!(property_flags & ZEND_ACC_READONLY) && (CG(active_class_entry)->ce_flags & ZEND_ACC_READONLY_CLASS)) {
+				property_flags |= ZEND_ACC_READONLY;
+			}
+
 			/* Recompile the type, as it has different memory management requirements. */
 			zend_type type = ZEND_TYPE_INIT_NONE(0);
 			if (type_ast) {
@@ -7364,6 +7373,10 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags, z
 			ZVAL_UNDEF(&value_zv);
 		}
 
+		if (!(flags & ZEND_ACC_READONLY) && (CG(active_class_entry)->ce_flags & ZEND_ACC_READONLY_CLASS)) {
+			flags |= ZEND_ACC_READONLY;
+		}
+
 		if (flags & ZEND_ACC_READONLY) {
 			if (!ZEND_TYPE_IS_SET(type)) {
 				zend_error_noreturn(E_COMPILE_ERROR, "Readonly property %s::$%s must have type",
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
@@ -241,7 +241,7 @@ typedef struct _zend_oparray_context {
 /* or IS_CONSTANT_VISITED_MARK                            |     |     |     */
 #define ZEND_CLASS_CONST_IS_CASE         (1 << 6)  /*     |     |     |  X  */
 /*                                                        |     |     |     */
-/* Class Flags (unused: 30...)                            |     |     |     */
+/* Class Flags (unused: 31...)                            |     |     |     */
 /* ===========                                            |     |     |     */
 /*                                                        |     |     |     */
 /* Special class types                                    |     |     |     */
@@ -307,6 +307,9 @@ typedef struct _zend_oparray_context {
 /* Class cannot be serialized or unserialized             |     |     |     */
 #define ZEND_ACC_NOT_SERIALIZABLE        (1 << 29) /*  X  |     |     |     */
 /*                                                        |     |     |     */
+/* Readonly class                                         |     |     |     */
+#define ZEND_ACC_READONLY_CLASS          (1 << 30) /*  X  |     |     |     */
+/*                                                        |     |     |     */
 /* Function Flags (unused: 27-30)                         |     |     |     */
 /* ==============                                         |     |     |     */
 /*                                                        |     |     |     */
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
@@ -595,6 +595,7 @@ class_modifiers:
 class_modifier:
 		T_ABSTRACT 		{ $$ = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }
 	|	T_FINAL 		{ $$ = ZEND_ACC_FINAL; }
+	|	T_READONLY 		{ $$ = ZEND_ACC_READONLY_CLASS|ZEND_ACC_NO_DYNAMIC_PROPERTIES; }
 ;
 
 trait_declaration_statement:
diff --git a/build/gen_stub.php b/build/gen_stub.php
@@ -1318,6 +1318,10 @@ private function getFlagsAsString(): string
             $flags[] = "ZEND_ACC_ABSTRACT";
         }
 
+        if ($this->flags & Class_::MODIFIER_READONLY) {
+            $flags[] = "ZEND_ACC_READONLY_CLASS";
+        }
+
         if ($this->isDeprecated) {
             $flags[] = "ZEND_ACC_DEPRECATED";
         }
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -348,6 +348,9 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char
 		if (ce->ce_flags & ZEND_ACC_FINAL) {
 			smart_str_append_printf(str, "final ");
 		}
+		if (ce->ce_flags & ZEND_ACC_READONLY) {
+			smart_str_append_printf(str, "readonly ");
+		}
 		smart_str_append_printf(str, "class ");
 	}
 	smart_str_append_printf(str, "%s", ZSTR_VAL(ce->name));
@@ -4842,6 +4845,12 @@ ZEND_METHOD(ReflectionClass, isFinal)
 }
 /* }}} */
 
+/* Returns whether this class is readonly */
+ZEND_METHOD(ReflectionClass, isReadonly)
+{
+	_class_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_READONLY);
+}
+
 /* {{{ Returns whether this class is abstract */
 ZEND_METHOD(ReflectionClass, isAbstract)
 {
@@ -4854,8 +4863,7 @@ ZEND_METHOD(ReflectionClass, getModifiers)
 {
 	reflection_object *intern;
 	zend_class_entry *ce;
-	uint32_t keep_flags = ZEND_ACC_FINAL
-		| ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
+	uint32_t keep_flags = ZEND_ACC_FINAL | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_READONLY;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_THROWS();
diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php
@@ -314,6 +314,9 @@ public function isAbstract(): bool {}
     /** @tentative-return-type */
     public function isFinal(): bool {}
 
+    /** @tentative-return-type */
+    public function isReadonly(): bool {}
+
     /** @tentative-return-type */
     public function getModifiers(): int {}
 
diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: aae05073f9a7898d836023183809faa265cb99c3 */
+ * Stub hash: 6c835a06c681b780b3c26f1fb5fcd6731eb1e90d */
 
 ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_Reflection_getModifierNames, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, modifiers, IS_LONG, 0)
@@ -256,6 +256,8 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_class_ReflectionClass_isFinal arginfo_class_ReflectionFunctionAbstract_inNamespace
 
+#define arginfo_class_ReflectionClass_isReadonly arginfo_class_ReflectionFunctionAbstract_inNamespace
+
 #define arginfo_class_ReflectionClass_getModifiers arginfo_class_ReflectionFunctionAbstract_getNumberOfParameters
 
 ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_ReflectionClass_isInstance, 0, 1, _IS_BOOL, 0)
@@ -694,6 +696,7 @@ ZEND_METHOD(ReflectionClass, isTrait);
 ZEND_METHOD(ReflectionClass, isEnum);
 ZEND_METHOD(ReflectionClass, isAbstract);
 ZEND_METHOD(ReflectionClass, isFinal);
+ZEND_METHOD(ReflectionClass, isReadonly);
 ZEND_METHOD(ReflectionClass, getModifiers);
 ZEND_METHOD(ReflectionClass, isInstance);
 ZEND_METHOD(ReflectionClass, newInstance);
@@ -958,6 +961,7 @@ static const zend_function_entry class_ReflectionClass_methods[] = {
 	ZEND_ME(ReflectionClass, isEnum, arginfo_class_ReflectionClass_isEnum, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, isAbstract, arginfo_class_ReflectionClass_isAbstract, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, isFinal, arginfo_class_ReflectionClass_isFinal, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionClass, isReadonly, arginfo_class_ReflectionClass_isReadonly, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getModifiers, arginfo_class_ReflectionClass_getModifiers, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, isInstance, arginfo_class_ReflectionClass_isInstance, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, newInstance, arginfo_class_ReflectionClass_newInstance, ZEND_ACC_PUBLIC)
diff --git a/ext/reflection/tests/ReflectionClass_modifiers_001.phpt b/ext/reflection/tests/ReflectionClass_modifiers_001.phpt
@@ -9,36 +9,48 @@ abstract class A {}
 class B extends A {}
 class C {}
 final class D {}
+readonly class E {}
 interface I {}
 
-$classes = array("A", "B", "C", "D", "I");
+$classes = array("A", "B", "C", "D", "E", "I");
 
 foreach ($classes as $class) {
     $rc = new ReflectionClass($class);
     var_dump($rc->isFinal());
     var_dump($rc->isInterface());
     var_dump($rc->isAbstract());
+    var_dump($rc->isReadonly());
     var_dump($rc->getModifiers());
 }
 ?>
 --EXPECT--
 bool(false)
 bool(false)
 bool(true)
+bool(false)
 int(64)
 bool(false)
 bool(false)
 bool(false)
+bool(false)
 int(0)
 bool(false)
 bool(false)
 bool(false)
+bool(false)
 int(0)
 bool(true)
 bool(false)
 bool(false)
+bool(false)
 int(32)
 bool(false)
+bool(false)
+bool(false)
+bool(true)
+int(128)
+bool(false)
 bool(true)
 bool(false)
+bool(false)
 int(0)
diff --git a/ext/reflection/tests/ReflectionClass_toString_001.phpt b/ext/reflection/tests/ReflectionClass_toString_001.phpt
@@ -27,7 +27,7 @@ Class [ <internal:Reflection> class ReflectionClass implements Reflector, String
     Property [ public string $name ]
   }
 
-  - Methods [55] {
+  - Methods [56] {
     Method [ <internal:Reflection> private method __clone ] {
 
       - Parameters [0] {
@@ -284,6 +284,13 @@ Class [ <internal:Reflection> class ReflectionClass implements Reflector, String
       - Tentative return [ bool ]
     }
 
+    Method [ <internal:Reflection> public method isReadonly ] {
+
+      - Parameters [0] {
+      }
+      - Tentative return [ bool ]
+    }
+
     Method [ <internal:Reflection> public method getModifiers ] {
 
       - Parameters [0] {
diff --git a/ext/reflection/tests/ReflectionClass_toString_005.phpt b/ext/reflection/tests/ReflectionClass_toString_005.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Using ReflectionClass::__toString() on readonly classes
+--FILE--
+<?php
+
+readonly class Foo {
+    public int $bar;
+    public readonly int $baz;
+}
+
+echo new ReflectionClass(Foo::class);
+
+?>
+--EXPECTF--
+Class [ <user> readonly class Foo ] {
+  @@ %s 3-6
+
+  - Constants [0] {
+  }
+
+  - Static properties [0] {
+  }
+
+  - Static methods [0] {
+  }
+
+  - Properties [2] {
+    Property [ public readonly int $bar ]
+    Property [ public readonly int $baz ]
+  }
+
+  - Methods [0] {
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -1699,6 +1699,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str str, zend_ast ast, int prio`
`1699`	`1699`	`if (decl->flags & ZEND_ACC_FINAL) {`
`1700`	`1700`	`smart_str_appends(str, "final ");`
`1701`	`1701`	`}`
	`1702`	`+ if (decl->flags & ZEND_ACC_READONLY_CLASS) {`
	`1703`	`+ smart_str_appends(str, "readonly ");`
	`1704`	`+ }`
`1702`	`1705`	`smart_str_appends(str, "class ");`
`1703`	`1706`	`}`
`1704`	`1707`	`smart_str_appendl(str, ZSTR_VAL(decl->name), ZSTR_LEN(decl->name));`
Original file line number	Diff line number	Diff line change
`@@ -595,6 +595,7 @@ class_modifiers:`
`595`	`595`	`class_modifier:`
`596`	`596`	`T_ABSTRACT { $$ = ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; }`
`597`	`597`	`\| T_FINAL { $$ = ZEND_ACC_FINAL; }`
	`598`	`+ \| T_READONLY { $$ = ZEND_ACC_READONLY_CLASS\|ZEND_ACC_NO_DYNAMIC_PROPERTIES; }`
`598`	`599`	`;`
`599`	`600`
`600`	`601`	`trait_declaration_statement:`