Adjust enum reflection according to the RFC

iluuu1994 · iluuu1994 · commit 9549133865f8 · 2021-03-04T21:25:30.000+01:00
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -90,6 +90,7 @@ PHPAPI zend_class_entry *reflection_reference_ptr;
 PHPAPI zend_class_entry *reflection_attribute_ptr;
 PHPAPI zend_class_entry *reflection_enum_ptr;
 PHPAPI zend_class_entry *reflection_enum_unit_case_ptr;
+PHPAPI zend_class_entry *reflection_enum_backed_case_ptr;
 
 /* Exception throwing macro */
 #define _DO_THROW(msg) \
@@ -1448,11 +1449,14 @@ static void reflection_class_constant_factory(zend_string *name_str, zend_class_
 }
 /* }}} */
 
-static void reflection_enum_case_factory(zend_string *name_str, zend_class_constant *constant, zval *object)
+static void reflection_enum_case_factory(zend_class_entry *ce, zend_string *name_str, zend_class_constant *constant, zval *object)
 {
 	reflection_object *intern;
 
-	reflection_instantiate(reflection_enum_unit_case_ptr, object);
+	zend_class_entry *case_reflection_class = ce->backed_enum_table == IS_UNDEF
+		? reflection_enum_unit_case_ptr
+		: reflection_enum_backed_case_ptr;
+	reflection_instantiate(case_reflection_class, object);
 	intern = Z_REFLECTION_P(object);
 	intern->ptr = constant;
 	intern->ref_type = REF_TYPE_CLASS_CONSTANT;
@@ -6595,7 +6599,7 @@ ZEND_METHOD(ReflectionEnum, getCase)
 		RETURN_FALSE;
 	}
 
-	reflection_enum_case_factory(name, constant, return_value);
+	reflection_enum_case_factory(ce, name, constant, return_value);
 }
 
 ZEND_METHOD(ReflectionEnum, getCases)
@@ -6615,7 +6619,7 @@ ZEND_METHOD(ReflectionEnum, getCases)
 	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, name, constant) {
 		if (Z_ACCESS_FLAGS(constant->value) & ZEND_CLASS_CONST_IS_CASE) {
 			zval class_const;
-			reflection_enum_case_factory(name, constant, &class_const);
+			reflection_enum_case_factory(ce, name, constant, &class_const);
 			zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &class_const);
 		}
 	} ZEND_HASH_FOREACH_END();
@@ -6671,7 +6675,7 @@ ZEND_METHOD(ReflectionEnumUnitCase, __construct)
 	}
 }
 
-ZEND_METHOD(ReflectionEnumUnitCase, getBackingValue)
+ZEND_METHOD(ReflectionEnumBackedCase, getBackingValue)
 {
 	reflection_object *intern;
 	zend_class_constant *ref;
@@ -6685,10 +6689,7 @@ ZEND_METHOD(ReflectionEnumUnitCase, getBackingValue)
 		zval_update_constant_ex(&ref->value, ref->ce);
 	}
 
-	if (intern->ce->enum_backing_type == IS_UNDEF) {
-		RETURN_NULL();
-	}
-
+	ZEND_ASSERT(intern->ce->enum_backing_type != IS_UNDEF);
 	zval *member_p = zend_enum_fetch_case_value(Z_OBJ(ref->value));
 
 	ZVAL_COPY_OR_DUP(return_value, member_p);
@@ -6707,6 +6708,24 @@ ZEND_METHOD(ReflectionEnumUnitCase, getEnum)
 	zend_reflection_enum_factory(ref->ce, return_value);
 }
 
+ZEND_METHOD(ReflectionEnumBackedCase, __construct)
+{
+	ZEND_MN(ReflectionEnumUnitCase___construct)(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+
+	reflection_object *intern;
+	zend_class_constant *ref;
+
+	GET_REFLECTION_OBJECT_PTR(ref);
+
+	if (ref->ce->enum_backing_type == IS_UNDEF) {
+		if (!EG(exception)) {
+			zval *case_name = reflection_prop_name(ZEND_THIS);
+			zend_throw_exception_ex(reflection_exception_ptr, 0, "Enum case %s::%s is not a backed case", ZSTR_VAL(ref->ce->name), Z_STRVAL_P(case_name));
+		}
+		RETURN_THROWS();
+	}
+}
+
 /* {{{ _reflection_write_property */
 static zval *_reflection_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot)
 {
@@ -6821,7 +6840,10 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
 
 	reflection_enum_unit_case_ptr = register_class_ReflectionEnumUnitCase(reflection_class_constant_ptr);
 	reflection_init_class_handlers(reflection_enum_unit_case_ptr);
-	REGISTER_REFLECTION_CLASS_CONST_LONG(enum_unit_case, "IS_FINAL", ZEND_ACC_FINAL);
+
+	reflection_enum_backed_case_ptr = register_class_ReflectionEnumBackedCase(reflection_enum_unit_case_ptr);
+	reflection_init_class_handlers(reflection_enum_backed_case_ptr);
+	REGISTER_REFLECTION_CLASS_CONST_LONG(enum_backed_case, "IS_FINAL", ZEND_ACC_FINAL);
 
 	REGISTER_REFLECTION_CLASS_CONST_LONG(attribute, "IS_INSTANCEOF", REFLECTION_ATTRIBUTE_IS_INSTANCEOF);
 
diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php
@@ -704,14 +704,19 @@ public function isBacked(): bool {}
     public function getBackingType(): ReflectionType|null {}
 }
 
-final class ReflectionEnumUnitCase extends ReflectionClassConstant
+class ReflectionEnumUnitCase extends ReflectionClassConstant
 {
     public function __construct(object|string $class, string $constant) {}
 
-    public function getBackingValue(): int|string|null {}
-
     public function getEnum(): ReflectionEnum {}
 
     /** @implementation-alias ReflectionClassConstant::getValue */
     public function getValue(): UnitEnum {}
 }
+
+final class ReflectionEnumBackedCase extends ReflectionEnumUnitCase
+{
+    public function __construct(object|string $class, string $constant) {}
+
+    public function getBackingValue(): int|string {}
+}
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: 7a0e72d87c9d51907124bac58a1f902135575674 */
+ * Stub hash: b4ec9ccf1844750cdc959918192efb3d22b257ce */
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Reflection_getModifierNames, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, modifiers, IS_LONG, 0)
@@ -512,15 +512,17 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_class_ReflectionEnumUnitCase___construct arginfo_class_ReflectionClassConstant___construct
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_ReflectionEnumUnitCase_getBackingValue, 0, 0, MAY_BE_LONG|MAY_BE_STRING|MAY_BE_NULL)
-ZEND_END_ARG_INFO()
-
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_ReflectionEnumUnitCase_getEnum, 0, 0, ReflectionEnum, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_ReflectionEnumUnitCase_getValue, 0, 0, UnitEnum, 0)
 ZEND_END_ARG_INFO()
 
+#define arginfo_class_ReflectionEnumBackedCase___construct arginfo_class_ReflectionClassConstant___construct
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_class_ReflectionEnumBackedCase_getBackingValue, 0, 0, MAY_BE_LONG|MAY_BE_STRING)
+ZEND_END_ARG_INFO()
+
 
 ZEND_METHOD(Reflection, getModifierNames);
 ZEND_METHOD(ReflectionClass, __clone);
@@ -731,8 +733,9 @@ ZEND_METHOD(ReflectionEnum, getCases);
 ZEND_METHOD(ReflectionEnum, isBacked);
 ZEND_METHOD(ReflectionEnum, getBackingType);
 ZEND_METHOD(ReflectionEnumUnitCase, __construct);
-ZEND_METHOD(ReflectionEnumUnitCase, getBackingValue);
 ZEND_METHOD(ReflectionEnumUnitCase, getEnum);
+ZEND_METHOD(ReflectionEnumBackedCase, __construct);
+ZEND_METHOD(ReflectionEnumBackedCase, getBackingValue);
 
 
 static const zend_function_entry class_ReflectionException_methods[] = {
@@ -1054,12 +1057,18 @@ static const zend_function_entry class_ReflectionEnum_methods[] = {
 
 static const zend_function_entry class_ReflectionEnumUnitCase_methods[] = {
 	ZEND_ME(ReflectionEnumUnitCase, __construct, arginfo_class_ReflectionEnumUnitCase___construct, ZEND_ACC_PUBLIC)
-	ZEND_ME(ReflectionEnumUnitCase, getBackingValue, arginfo_class_ReflectionEnumUnitCase_getBackingValue, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionEnumUnitCase, getEnum, arginfo_class_ReflectionEnumUnitCase_getEnum, ZEND_ACC_PUBLIC)
 	ZEND_MALIAS(ReflectionClassConstant, getValue, getValue, arginfo_class_ReflectionEnumUnitCase_getValue, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
 
+
+static const zend_function_entry class_ReflectionEnumBackedCase_methods[] = {
+	ZEND_ME(ReflectionEnumBackedCase, __construct, arginfo_class_ReflectionEnumBackedCase___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionEnumBackedCase, getBackingValue, arginfo_class_ReflectionEnumBackedCase_getBackingValue, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
 static zend_class_entry *register_class_ReflectionException(zend_class_entry *class_entry_Exception)
 {
 	zend_class_entry ce, *class_entry;
@@ -1341,6 +1350,16 @@ static zend_class_entry *register_class_ReflectionEnumUnitCase(zend_class_entry
 
 	INIT_CLASS_ENTRY(ce, "ReflectionEnumUnitCase", class_ReflectionEnumUnitCase_methods);
 	class_entry = zend_register_internal_class_ex(&ce, class_entry_ReflectionClassConstant);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_ReflectionEnumBackedCase(zend_class_entry *class_entry_ReflectionEnumUnitCase)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "ReflectionEnumBackedCase", class_ReflectionEnumBackedCase_methods);
+	class_entry = zend_register_internal_class_ex(&ce, class_entry_ReflectionEnumUnitCase);
 	class_entry->ce_flags |= ZEND_ACC_FINAL;
 
 	return class_entry;
diff --git a/ext/reflection/tests/ReflectionEnumBackedCase_getBackingValue.phpt b/ext/reflection/tests/ReflectionEnumBackedCase_getBackingValue.phpt
@@ -0,0 +1,31 @@
+--TEST--
+ReflectionEnumBackedCase::getBackingValue()
+--FILE--
+<?php
+
+enum Enum_ {
+    case Foo;
+}
+
+enum IntEnum: int {
+    case Foo = 0;
+}
+
+enum StringEnum: string {
+    case Foo = 'Foo';
+}
+
+try {
+    var_dump((new ReflectionEnumBackedCase(Enum_::class, 'Foo'))->getBackingValue());
+} catch (ReflectionException $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump((new ReflectionEnumBackedCase(IntEnum::class, 'Foo'))->getBackingValue());
+var_dump((new ReflectionEnumBackedCase(StringEnum::class, 'Foo'))->getBackingValue());
+
+?>
+--EXPECT--
+Enum case Enum_::Foo is not a backed case
+int(0)
+string(3) "Foo"
diff --git a/ext/reflection/tests/ReflectionEnumUnitCase_getBackingValue.phpt b/ext/reflection/tests/ReflectionEnumUnitCase_getBackingValue.phpt
diff --git a/ext/reflection/tests/ReflectionEnum_getCase.phpt b/ext/reflection/tests/ReflectionEnum_getCase.phpt
@@ -3,24 +3,41 @@ ReflectionEnum::getCases()
 --FILE--
 <?php
 
-enum Foo {
-    case Bar;
-    const Baz = self::Bar;
+enum Enum_ {
+    case Foo;
+    const Bar = self::Foo;
 }
 
-$reflectionEnum = new ReflectionEnum(Foo::class);
+enum IntEnum: int {
+    case Foo = 0;
+    const Bar = self::Foo;
+}
 
+$reflectionEnum = new ReflectionEnum(Enum_::class);
+var_dump($reflectionEnum->getCase('Foo'));
+var_dump($reflectionEnum->getCase('Bar'));
+var_dump($reflectionEnum->getCase('Baz'));
+
+$reflectionEnum = new ReflectionEnum(IntEnum::class);
+var_dump($reflectionEnum->getCase('Foo'));
 var_dump($reflectionEnum->getCase('Bar'));
 var_dump($reflectionEnum->getCase('Baz'));
-var_dump($reflectionEnum->getCase('Qux'));
 
 ?>
 --EXPECT--
 object(ReflectionEnumUnitCase)#2 (2) {
   ["name"]=>
-  string(3) "Bar"
+  string(3) "Foo"
   ["class"]=>
+  string(5) "Enum_"
+}
+bool(false)
+bool(false)
+object(ReflectionEnumBackedCase)#1 (2) {
+  ["name"]=>
   string(3) "Foo"
+  ["class"]=>
+  string(7) "IntEnum"
 }
 bool(false)
 bool(false)
diff --git a/ext/reflection/tests/ReflectionEnum_getCases.phpt b/ext/reflection/tests/ReflectionEnum_getCases.phpt
@@ -3,29 +3,52 @@ ReflectionEnum::getCases()
 --FILE--
 <?php
 
-enum Foo {
+enum Enum_ {
+    case Foo;
     case Bar;
-    case Baz;
-    const Qux = self::Bar;
+    const Baz = self::Bar;
 }
 
-var_dump((new ReflectionEnum(Foo::class))->getCases());
+enum IntEnum: int {
+  case Foo = 0;
+  case Bar = 1;
+  const Baz = self::Bar;
+}
+
+var_dump((new ReflectionEnum(Enum_::class))->getCases());
+var_dump((new ReflectionEnum(IntEnum::class))->getCases());
 
 ?>
 --EXPECT--
 array(2) {
   [0]=>
   object(ReflectionEnumUnitCase)#2 (2) {
     ["name"]=>
-    string(3) "Bar"
-    ["class"]=>
     string(3) "Foo"
+    ["class"]=>
+    string(5) "Enum_"
   }
   [1]=>
   object(ReflectionEnumUnitCase)#3 (2) {
     ["name"]=>
-    string(3) "Baz"
+    string(3) "Bar"
     ["class"]=>
+    string(5) "Enum_"
+  }
+}
+array(2) {
+  [0]=>
+  object(ReflectionEnumBackedCase)#2 (2) {
+    ["name"]=>
     string(3) "Foo"
+    ["class"]=>
+    string(7) "IntEnum"
+  }
+  [1]=>
+  object(ReflectionEnumBackedCase)#1 (2) {
+    ["name"]=>
+    string(3) "Bar"
+    ["class"]=>
+    string(7) "IntEnum"
   }
 }
diff --git a/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt b/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt
@@ -8,7 +8,7 @@ $ext = new ReflectionExtension('reflection');
 var_dump($ext->getClasses());
 ?>
 --EXPECT--
-array(21) {
+array(22) {
   ["ReflectionException"]=>
   object(ReflectionClass)#2 (1) {
     ["name"]=>
@@ -114,4 +114,9 @@ array(21) {
     ["name"]=>
     string(22) "ReflectionEnumUnitCase"
   }
+  ["ReflectionEnumBackedCase"]=>
+  object(ReflectionClass)#23 (1) {
+    ["name"]=>
+    string(24) "ReflectionEnumBackedCase"
+  }
 }
