Remove class for enum case

Author: iluuu1994

Zend/tests/enum/003.phpt

@@ -31,5 +31,5 @@ try {
 
 ?>
 --EXPECTF--
-takesBaz(): Argument #1 ($baz) must be of type Baz, Foo::Bar given, called in %s on line %d
-takesFoo(): Argument #1 ($foo) must be of type Foo, Baz::Qux given, called in %s on line %d
+takesBaz(): Argument #1 ($baz) must be of type Baz, Foo given, called in %s on line %d
+takesFoo(): Argument #1 ($foo) must be of type Foo, Baz given, called in %s on line %d

Zend/tests/enum/005.phpt

@@ -7,7 +7,7 @@ interface Colorful {
     public function color(): string;
 }
 
-enum Suit /* implements Colorful */ {
+enum Suit implements Colorful {
     case Hearts;
     case Diamonds;
     case Clubs;

Zend/tests/enum/006.phpt

@@ -1,5 +1,9 @@
 --TEST--
 Enum is abstract
+--SKIPIF--
+<?php
+die("skip doesn't work yet");
+?>
 --FILE--
 <?php
 

Zend/tests/enum/008.phpt

@@ -17,4 +17,4 @@ try {
 
 ?>
 --EXPECT--
-Cannot create dynamic property Foo::Bar::$baz
+Cannot create dynamic property Foo::$baz

Zend/tests/enum/010.phpt

@@ -4,11 +4,9 @@ Enum disallows static properties
 <?php
 
 enum Foo {
-    case Bar {
-        public static $baz;
-    }
+    public static $bar;
 }
 
 ?>
 --EXPECTF--
-Fatal error: Enum cases may not include member variables in %s on line %d
+Fatal error: Enums may not include member variables in %s on line %d

Zend/tests/enum/011.phpt

@@ -1,56 +1,23 @@
 --TEST--
-Enum case attributes
+Enum attributes
 --FILE--
 <?php
 
 #[Attribute]
-class EnumValue {
+class EnumAttribute {
     public function __construct(
         public string $value,
     ) {}
 }
 
-enum Suit {
-    #[EnumValue('H')] case Hearts;
-    #[EnumValue('D')] case Diamonds;
-    #[EnumValue('C')] case Clubs;
-    #[EnumValue('S')] case Spades;
+#[EnumAttribute('Foo')]
+enum Foo {}
 
-    public function value(): string {
-        return self::getEnumCaseValue($this::class);
-    }
-
-    public static function from(string $value): self {
-        $constants = (new \ReflectionClass(__CLASS__))->getConstants();
-
-        foreach ($constants as $constant) {
-            if ($value === self::getEnumCaseValue($constant::class)) {
-                return $constant;
-            }
-        }
-
-        throw new \InvalidArgumentException('Unknown enum value ' . $value);
-    }
-
-    private static function getEnumCaseValue(string $caseClass): string {
-        return (new \ReflectionClass($caseClass))
-            ->getAttributes(EnumValue::class)[0]
-            ->newInstance()
-            ->value;
-    }
-}
-
-var_dump(Suit::Hearts->value());
-var_dump(Suit::from('D'));
-
-try {
-    var_dump(Suit::from('X'));
-} catch (\InvalidArgumentException $e) {
-    echo $e->getMessage() . "\n";
-}
+var_dump((new \ReflectionClass(Foo::class))->getAttributes(EnumAttribute::class)[0]->newInstance());
 
 ?>
 --EXPECT--
-string(1) "H"
-enum(Suit::Diamonds)
-Unknown enum value X
+object(EnumAttribute)#1 (1) {
+  ["value"]=>
+  string(3) "Foo"
+}

Zend/tests/enum/012.phpt

@@ -754,14 +754,21 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate(zval *result, zend_ast *ast
 				}
 			}
 			break;
-		case ZEND_AST_NEW:
+		case ZEND_AST_CONST_ENUM_INIT:
 		{
-			// FIXME: Assert enum constants
 			zend_ast *class_name_ast = ast->child[0];
+			zend_ast *case_name_ast = ast->child[1];
 			zval *class_name_zv = zend_ast_get_zval(class_name_ast);
 			zend_string *class_name = Z_STR_P(class_name_zv);
+			zval *case_name_zv = zend_ast_get_zval(case_name_ast);
 			zend_class_entry *ce = zend_fetch_class_by_name(class_name, NULL, 0);
 			object_init_ex(result, ce);
+			zend_object *zobj = Z_OBJ_P(result);
+			zend_string *case_property_name = zend_string_init("case", strlen("case"), 0);
+
+			zobj->handlers->write_property(zobj, case_property_name, case_name_zv, NULL);
+
+			zend_string_free(case_property_name);
 			break;
 		}
 		default:

Zend/tests/enum/014.phpt

@@ -149,6 +149,9 @@ enum _zend_ast_kind {
 	ZEND_AST_MATCH_ARM,
 	ZEND_AST_NAMED_ARG,
 
+	// Pseudo node for initializing enums
+	ZEND_AST_CONST_ENUM_INIT,
+
 	/* 3 child nodes */
 	ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,
 	ZEND_AST_NULLSAFE_METHOD_CALL,

Zend/tests/enum/017.phpt

@@ -1063,7 +1063,7 @@ ZEND_FUNCTION(trait_exists)
 
 ZEND_FUNCTION(is_enum)
 {
-	class_exists_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ENUM|ZEND_ACC_ENUM_CASE, 0);
+	class_exists_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_ENUM, 0);
 }
 
 /* {{{ Checks if the function exists */

Zend/tests/enum/018.phpt

@@ -6765,9 +6765,6 @@ zend_string *zend_begin_method_decl(zend_op_array *op_array, zend_string *name,
 	if ((ce->ce_flags & ZEND_ACC_ENUM) && zend_is_constructor(name)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Enums cannot contain constructors");
 	}
-	if ((ce->ce_flags & ZEND_ACC_ENUM_CASE) && zend_is_constructor(name)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Enum cases cannot contain constructors");
-	}
 
 	if (in_interface) {
 		if (!(fn_flags & ZEND_ACC_PUBLIC) || (fn_flags & (ZEND_ACC_FINAL|ZEND_ACC_ABSTRACT))) {
@@ -7014,10 +7011,6 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags, z
 		zend_error_noreturn(E_COMPILE_ERROR, "Enums may not include member variables");
 	}
 
-	if (ce->ce_flags & ZEND_ACC_ENUM_CASE) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Enum cases may not include member variables");
-	}
-
 	if (flags & ZEND_ACC_ABSTRACT) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Properties cannot be declared abstract");
 	}
@@ -7134,11 +7127,6 @@ void zend_compile_class_const_decl(zend_ast *ast, uint32_t flags, zend_ast *attr
 		return;
 	}
 
-	if (ce->ce_flags & ZEND_ACC_ENUM_CASE) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Enum cases cannot have constants");
-		return;
-	}
-
 	for (i = 0; i < children; ++i) {
 		zend_class_constant *c;
 		zend_ast *const_ast = list->child[i];
@@ -7434,6 +7422,15 @@ zend_class_entry *zend_compile_class_decl(znode *result, zend_ast *ast, zend_boo
 		zend_verify_abstract_class(ce);
 	}
 
+	if (ce->ce_flags & ZEND_ACC_ENUM) {
+		zval default_value;
+		ZVAL_NULL(&default_value);
+		zend_string *case_property_name = zend_string_init("case", strlen("case"), 0);
+		zend_type case_type = ZEND_TYPE_INIT_NONE(0);
+		zend_declare_typed_property(ce, case_property_name, &default_value, ZEND_ACC_PUBLIC, NULL, case_type);
+		zend_string_release(case_property_name);
+	}
+
 	CG(active_class_entry) = original_ce;
 
 	if (toplevel) {
@@ -7518,63 +7515,36 @@ zend_class_entry *zend_compile_class_decl(znode *result, zend_ast *ast, zend_boo
 }
 /* }}} */
 
-static void zend_declare_enum_case_constant(zend_ast *ast, zend_class_entry *enum_class, zend_class_entry *enum_case_class)
+static void zend_declare_enum_case_constant(zend_ast *ast, zend_class_entry *enum_class)
 {
 	zend_ast_decl *enum_case_decl = (zend_ast_decl *) ast;
 	zend_string *enum_case_name = enum_case_decl->name;
-	zend_string *enum_case_class_name = enum_case_class->name;
+	zend_string *enum_class_name = enum_class->name;
+
 	zval class_name_zval;
-	ZVAL_STR_COPY(&class_name_zval, enum_case_class_name);
+	ZVAL_STR_COPY(&class_name_zval, enum_class_name);
 	zend_ast *class_name_ast = zend_ast_create_zval_ex(&class_name_zval, ZEND_NAME_NOT_FQ);
-	zend_ast *new_ast = zend_ast_create(ZEND_AST_NEW, class_name_ast, NULL);
+
+	zval case_name_zval;
+	ZVAL_STR_COPY(&case_name_zval, enum_case_name);
+	zend_ast *case_name_ast = zend_ast_create_zval_ex(&case_name_zval, ZEND_NAME_NOT_FQ);
+
+	zend_ast *const_enum_init_ast = zend_ast_create(ZEND_AST_CONST_ENUM_INIT, class_name_ast, case_name_ast);
 
 	zval value_zv;
-	zend_const_expr_to_zval(&value_zv, &new_ast);
+	zend_const_expr_to_zval(&value_zv, &const_enum_init_ast);
 	zend_declare_class_constant_ex(enum_class, enum_case_name, &value_zv, ZEND_ACC_PUBLIC, NULL);
 
-	zend_ast_destroy(new_ast);
+	zend_ast_destroy(const_enum_init_ast);
 }
 
 static void zend_compile_enum_case_class(zend_ast *ast)
 {
 	zend_ast_decl *enum_case_decl = (zend_ast_decl *) ast;
 
 	zend_class_entry *enum_class = CG(active_class_entry);
-	CG(active_class_entry) = NULL;
-
-	zend_string *enum_class_name = enum_class->name;
-	zend_string *enum_case_name = enum_case_decl->name;
-	zend_string *enum_case_class_name = zend_string_concat3(
-		ZSTR_VAL(enum_class_name), ZSTR_LEN(enum_class_name),
-		"::", sizeof("::") - 1,
-		ZSTR_VAL(enum_case_name), ZSTR_LEN(enum_case_name)
-	);
-
-	zend_ast *extends_from = zend_ast_create_zval_from_str(enum_class_name);
-
-	zend_ast *implements_list = enum_case_decl->child[1];
-	if (implements_list == NULL) {
-		implements_list = zend_ast_create_list(0, ZEND_AST_NAME_LIST);
-	}
-
-	zval enum_interface_name_zv;
-	ZVAL_INTERNED_STR(&enum_interface_name_zv, ZSTR_KNOWN(ZEND_STR_ENUM));
-	zend_ast *enum_interface_name_ast = zend_ast_create_zval_ex(&enum_interface_name_zv, ZEND_NAME_FQ);
-	zend_ast_list_add(implements_list, enum_interface_name_ast);
-
-	zend_ast *statement_list = enum_case_decl->child[2];
-	zend_ast *attribute_list = enum_case_decl->child[3];
-
-	zend_ast_decl *enum_case_class_decl = (zend_ast_decl *) zend_ast_create_decl(ZEND_AST_CLASS, enum_case_decl->flags, ast->lineno, NULL, enum_case_class_name, extends_from, implements_list, statement_list, attribute_list, NULL);
-	zend_class_entry *enum_case_class = zend_compile_class_decl(NULL, (zend_ast *) enum_case_class_decl, 0);
-
-	CG(active_class_entry) = enum_class;
-
-	enum_case_class_decl->child[2] = NULL;
-	enum_case_class_decl->child[3] = NULL;
-	zend_ast_destroy((zend_ast *) enum_case_class_decl);
 
-	zend_declare_enum_case_constant(ast, enum_class, enum_case_class);
+	zend_declare_enum_case_constant(ast, enum_class);
 
 	zend_ast *enum_primitive_expr_ast = enum_case_decl->child[4];
 	if (enum_primitive_expr_ast != NULL) {
@@ -9284,7 +9254,7 @@ zend_bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */
 		|| kind == ZEND_AST_CONST || kind == ZEND_AST_CLASS_CONST
 		|| kind == ZEND_AST_CLASS_NAME
 		|| kind == ZEND_AST_MAGIC_CONST || kind == ZEND_AST_COALESCE
-		|| kind == ZEND_AST_NEW; // FIXME: Only allow new for enum constants
+		|| kind == ZEND_AST_CONST_ENUM_INIT;
 }
 /* }}} */