ReflectionClass: show enums differently from classes

DanielEScherzer · DanielEScherzer · commit bc5d739aa4e8 · 2024-09-19T01:48:05.000-07:00
While internally enums are mostly the same as classes, their output in `ReflectionClass::__toString()` should show the enum as the developer wrote it, rather than as the engine stored it. Accordingly - Say that the enum is an enum, not a final class - Include the backing type, if any, in the declaration line - Remove the `UnitEnum` and `BackedEnum` interfaces from the list of interfaces implemented - List enum cases separately from constants, and show the underlying values, if any GH-15766
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -306,6 +306,7 @@ static void _const_string(smart_str *str, const char *name, zval *value, const c
 static void _function_string(smart_str *str, zend_function *fptr, zend_class_entry *scope, const char* indent);
 static void _property_string(smart_str *str, zend_property_info *prop, const char *prop_name, const char* indent);
 static void _class_const_string(smart_str *str, const zend_string *name, zend_class_constant *c, const char* indent);
+static void _enum_case_string(smart_str *str, const zend_string *name, zend_class_constant *c, const char* indent);
 static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const char *indent);
 static void _extension_string(smart_str *str, const zend_module_entry *module, const char *indent);
 static void _zend_extension_string(smart_str *str, const zend_extension *extension, const char *indent);
@@ -330,6 +331,8 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const
 			kind = "Interface";
 		} else if (ce->ce_flags & ZEND_ACC_TRAIT) {
 			kind = "Trait";
+		} else if (ce->ce_flags & ZEND_ACC_ENUM) {
+			kind = "Enum";
 		}
 		smart_str_append_printf(str, "%s%s [ ", indent, kind);
 	}
@@ -345,6 +348,8 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const
 		smart_str_append_printf(str, "interface ");
 	} else if (ce->ce_flags & ZEND_ACC_TRAIT) {
 		smart_str_append_printf(str, "trait ");
+	} else if (ce->ce_flags & ZEND_ACC_ENUM) {
+		smart_str_append_printf(str, "enum ");
 	} else {
 		if (ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
 			smart_str_append_printf(str, "abstract ");
@@ -362,18 +367,47 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const
 		smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->parent->name));
 	}
 
-	if (ce->num_interfaces) {
-		uint32_t i;
+	uint32_t num_interfaces = ce->num_interfaces;
+	if (ce->ce_flags & ZEND_ACC_ENUM) {
+		// Ignore `UnitEnum`
+		num_interfaces--;
+		if (ce->enum_backing_type != IS_UNDEF) {
+			// Ignore `BackedEnum`
+			num_interfaces--;
+			// And show backing type
+			if (ce->enum_backing_type == IS_STRING) {
+				smart_str_append_printf(str, ": string");
+			} else {
+				smart_str_append_printf(str, ": int");
+			}
+		}
+	}
+	if (num_interfaces) {
+		uint32_t next_interface = 0;
 
 		ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED);
+
+#define IS_ENUM_INTERFACE(_iface) (_iface == zend_ce_unit_enum || _iface == zend_ce_backed_enum)
+		if (ce->ce_flags & ZEND_ACC_ENUM && IS_ENUM_INTERFACE(ce->interfaces[0])) {
+			next_interface++;
+			if (ce->num_interfaces > 1 && IS_ENUM_INTERFACE(ce->interfaces[1])) {
+				next_interface++;
+			}
+		}
+
 		if (ce->ce_flags & ZEND_ACC_INTERFACE) {
 			smart_str_append_printf(str, " extends %s", ZSTR_VAL(ce->interfaces[0]->name));
 		} else {
-			smart_str_append_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[0]->name));
+			smart_str_append_printf(str, " implements %s", ZSTR_VAL(ce->interfaces[next_interface]->name));
 		}
-		for (i = 1; i < ce->num_interfaces; ++i) {
-			smart_str_append_printf(str, ", %s", ZSTR_VAL(ce->interfaces[i]->name));
+		next_interface++;
+		// Going through the entire interface list, skipping the enum ones
+		for (; next_interface < ce->num_interfaces; ++next_interface) {
+			if (!IS_ENUM_INTERFACE(ce->interfaces[next_interface])) {
+				smart_str_append_printf(str, ", %s", ZSTR_VAL(ce->interfaces[next_interface]->name));
+			}
 		}
+#undef IS_ENUM_INTERFACE
 	}
 	smart_str_append_printf(str, " ] {\n");
 
@@ -384,23 +418,58 @@ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, const
 	}
 
 	/* Constants */
-	smart_str_append_printf(str, "\n");
-	count = zend_hash_num_elements(&ce->constants_table);
-	smart_str_append_printf(str, "%s  - Constants [%d] {\n", indent, count);
-	if (count > 0) {
+	int total_count = zend_hash_num_elements(&ce->constants_table);
+	int constant_count = 0;
+	int enum_case_count = 0;
+	smart_str constant_str = {0};
+	smart_str enum_case_str = {0};
+	// So that we don't need to loop through all of the constants multiple
+	// times (count the constants vs. enum cases, print the constants, print
+	// the enum cases) use some temporary helper smart strings
+	if (total_count > 0) {
 		zend_string *key;
 		zend_class_constant *c;
 
 		ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(CE_CONSTANTS_TABLE(ce), key, c) {
-			_class_const_string(str, key, c, ZSTR_VAL(sub_indent));
+			if (Z_TYPE(c->value) == IS_CONSTANT_AST
+				&& zend_update_class_constant(c, key, c->ce) == FAILURE
+			) {
+				ZEND_ASSERT(EG(exception));
+				zend_string_release(sub_indent);
+				smart_str_free(&enum_case_str);
+				smart_str_free(&constant_str);
+				return;
+			}
+			if (ZEND_CLASS_CONST_FLAGS(c) & ZEND_CLASS_CONST_IS_CASE) {
+				_enum_case_string(&enum_case_str, key, c, ZSTR_VAL(sub_indent));
+				enum_case_count++;
+			} else {
+				_class_const_string(&constant_str, key, c, ZSTR_VAL(sub_indent));
+				constant_count++;
+			}
 			if (UNEXPECTED(EG(exception))) {
 				zend_string_release(sub_indent);
+				smart_str_free(&enum_case_str);
+				smart_str_free(&constant_str);
 				return;
 			}
 		} ZEND_HASH_FOREACH_END();
 	}
+	// Enum cases go first, but the heading is only shown if there are any
+	if (enum_case_count) {
+		smart_str_append_printf(str, "\n");
+		smart_str_append_printf(str, "%s  - Enum cases [%d] {\n", indent, enum_case_count);
+		smart_str_append_smart_str(str, &enum_case_str);
+		smart_str_append_printf(str, "%s  }\n", indent);
+	}
+	smart_str_append_printf(str, "\n");
+	smart_str_append_printf(str, "%s  - Constants [%d] {\n", indent, constant_count);
+	smart_str_append_smart_str(str, &constant_str);
 	smart_str_append_printf(str, "%s  }\n", indent);
 
+	smart_str_free(&enum_case_str);
+	smart_str_free(&constant_str);
+
 	/* Static properties */
 	/* counting static properties */
 	count = zend_hash_num_elements(&ce->properties_info);
@@ -626,6 +695,30 @@ static void _class_const_string(smart_str *str, const zend_string *name, zend_cl
 }
 /* }}} */
 
+/* {{{ _enum_case_string */
+static void _enum_case_string(smart_str *str, const zend_string *name, zend_class_constant *c, const char *indent)
+{
+	if (c->doc_comment) {
+		smart_str_append_printf(str, "%s%s\n", indent, ZSTR_VAL(c->doc_comment));
+	}
+	smart_str_append_printf(str, "%sCase %s", indent, ZSTR_VAL(name));
+	if (c->ce->enum_backing_type == IS_UNDEF) {
+		// No value
+		smart_str_appends(str, "\n");
+	} else {
+		// Has a value, which is the enum instance, get the value from that.
+		// We know it must be either a string or integer so no need
+		// for the IS_ARRAY or IS_OBJECT handling that _class_const_string()
+		// requires
+		zval *enum_val = zend_enum_fetch_case_value(Z_OBJ(c->value));
+		zend_string *tmp_value_str;
+		zend_string *value_str = zval_get_tmp_string(enum_val, &tmp_value_str);
+		smart_str_append_printf(str, " = %s\n", ZSTR_VAL(value_str));
+		zend_tmp_string_release(tmp_value_str);
+	}
+}
+/* }}} */
+
 static zend_op *get_recv_op(const zend_op_array *op_array, uint32_t offset)
 {
 	zend_op *op = op_array->opcodes;
diff --git a/ext/reflection/tests/ReflectionEnumUnitCase_getEnum.phpt b/ext/reflection/tests/ReflectionEnumUnitCase_getEnum.phpt
@@ -11,11 +11,14 @@ echo (new ReflectionEnumUnitCase(Foo::class, 'Bar'))->getEnum();
 
 ?>
 --EXPECTF--
-Class [ <user> final class Foo implements UnitEnum ] {
+Enum [ <user> enum Foo ] {
   @@ %sReflectionEnumUnitCase_getEnum.php 3-5
 
-  - Constants [1] {
-    Constant [ public Foo Bar ] { Object }
+  - Enum cases [1] {
+    Case Bar
+  }
+
+  - Constants [0] {
   }
 
   - Static properties [0] {
diff --git a/ext/reflection/tests/ReflectionEnum_toString.phpt b/ext/reflection/tests/ReflectionEnum_toString.phpt
@@ -11,11 +11,14 @@ echo new ReflectionEnum(Foo::class);
 
 ?>
 --EXPECTF--
-Class [ <user> final class Foo implements UnitEnum ] {
+Enum [ <user> enum Foo ] {
   @@ %sReflectionEnum_toString.php 3-5
 
-  - Constants [1] {
-    Constant [ public Foo Bar ] { Object }
+  - Enum cases [1] {
+    Case Bar
+  }
+
+  - Constants [0] {
   }
 
   - Static properties [0] {
diff --git a/ext/reflection/tests/ReflectionEnum_toString_backed_int.phpt b/ext/reflection/tests/ReflectionEnum_toString_backed_int.phpt
@@ -28,12 +28,15 @@ var_export( MyBool::cases() );
 
 ?>
 --EXPECTF--
-Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum ] {
+Enum [ <user> enum MyBool: int implements MyStringable ] {
   @@ %sReflectionEnum_toString_backed_int.php 7-16
 
-  - Constants [3] {
-    Constant [ public MyBool MyFalse ] { Object }
-    Constant [ public MyBool MyTrue ] { Object }
+  - Enum cases [2] {
+    Case MyFalse = 0
+    Case MyTrue = 1
+  }
+
+  - Constants [1] {
     Constant [ public MyBool OtherTrue ] { Object }
   }
 
@@ -81,12 +84,15 @@ Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum
   }
 }
 
-Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum ] {
+Enum [ <user> enum MyBool: int implements MyStringable ] {
   @@ %sReflectionEnum_toString_backed_int.php 7-16
 
-  - Constants [3] {
-    Constant [ public MyBool MyFalse ] { Object }
-    Constant [ public MyBool MyTrue ] { Object }
+  - Enum cases [2] {
+    Case MyFalse = 0
+    Case MyTrue = 1
+  }
+
+  - Constants [1] {
     Constant [ public MyBool OtherTrue ] { Object }
   }
 
diff --git a/ext/reflection/tests/ReflectionEnum_toString_backed_string.phpt b/ext/reflection/tests/ReflectionEnum_toString_backed_string.phpt
@@ -28,12 +28,15 @@ var_export( MyBool::cases() );
 
 ?>
 --EXPECTF--
-Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum ] {
+Enum [ <user> enum MyBool: string implements MyStringable ] {
   @@ %sReflectionEnum_toString_backed_string.php 7-16
 
-  - Constants [3] {
-    Constant [ public MyBool MyFalse ] { Object }
-    Constant [ public MyBool MyTrue ] { Object }
+  - Enum cases [2] {
+    Case MyFalse = ~FALSE~
+    Case MyTrue = ~TRUE~
+  }
+
+  - Constants [1] {
     Constant [ public MyBool OtherTrue ] { Object }
   }
 
@@ -81,12 +84,15 @@ Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum
   }
 }
 
-Class [ <user> final class MyBool implements MyStringable, UnitEnum, BackedEnum ] {
+Enum [ <user> enum MyBool: string implements MyStringable ] {
   @@ %sReflectionEnum_toString_backed_string.php 7-16
 
-  - Constants [3] {
-    Constant [ public MyBool MyFalse ] { Object }
-    Constant [ public MyBool MyTrue ] { Object }
+  - Enum cases [2] {
+    Case MyFalse = ~FALSE~
+    Case MyTrue = ~TRUE~
+  }
+
+  - Constants [1] {
     Constant [ public MyBool OtherTrue ] { Object }
   }
 
diff --git a/ext/reflection/tests/ReflectionEnum_toString_unbacked.phpt b/ext/reflection/tests/ReflectionEnum_toString_unbacked.phpt
@@ -30,14 +30,17 @@ var_export( Suit::cases() );
 
 ?>
 --EXPECTF--
-Class [ <user> final class Suit implements MyStringable, UnitEnum ] {
+Enum [ <user> enum Suit implements MyStringable ] {
   @@ %sReflectionEnum_toString_unbacked.php 7-18
 
-  - Constants [5] {
-    Constant [ public Suit Hearts ] { Object }
-    Constant [ public Suit Diamonds ] { Object }
-    Constant [ public Suit Clubs ] { Object }
-    Constant [ public Suit Spades ] { Object }
+  - Enum cases [4] {
+    Case Hearts
+    Case Diamonds
+    Case Clubs
+    Case Spades
+  }
+
+  - Constants [1] {
     Constant [ public Suit OtherHearts ] { Object }
   }
 
@@ -68,14 +71,17 @@ Class [ <user> final class Suit implements MyStringable, UnitEnum ] {
   }
 }
 
-Class [ <user> final class Suit implements MyStringable, UnitEnum ] {
+Enum [ <user> enum Suit implements MyStringable ] {
   @@ %sReflectionEnum_toString_unbacked.php 7-18
 
-  - Constants [5] {
-    Constant [ public Suit Hearts ] { Object }
-    Constant [ public Suit Diamonds ] { Object }
-    Constant [ public Suit Clubs ] { Object }
-    Constant [ public Suit Spades ] { Object }
+  - Enum cases [4] {
+    Case Hearts
+    Case Diamonds
+    Case Clubs
+    Case Spades
+  }
+
+  - Constants [1] {
     Constant [ public Suit OtherHearts ] { Object }
   }
 
