Fixes for enums

Author: nikic

Zend/Optimizer/zend_inference.c

@@ -3486,7 +3486,7 @@ static zend_always_inline int _zend_update_type_info(
 			break;
 		case ZEND_FETCH_CONSTANT:
 		case ZEND_FETCH_CLASS_CONSTANT:
-			UPDATE_SSA_TYPE(MAY_BE_RC1|MAY_BE_RCN|MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_STRING|MAY_BE_RESOURCE|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY, ssa_op->result_def);
+			UPDATE_SSA_TYPE(MAY_BE_RC1|MAY_BE_RCN|MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY, ssa_op->result_def);
 			break;
 		case ZEND_STRLEN:
 			tmp = MAY_BE_LONG;

Zend/tests/enum/cases-refcount.phpt

@@ -16,7 +16,7 @@ debug_zval_dump(Foo::Bar);
 
 ?>
 --EXPECT--
-object(Foo)#2 (1) refcount(2){
+object(Foo)#1 (1) refcount(2){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }

Zend/tests/enum/name-property.phpt

@@ -33,14 +33,14 @@ array(1) {
 string(3) "Bar"
 array(2) {
   [0]=>
-  object(ReflectionProperty)#4 (2) {
+  object(ReflectionProperty)#3 (2) {
     ["name"]=>
     string(4) "name"
     ["class"]=>
     string(6) "IntFoo"
   }
   [1]=>
-  object(ReflectionProperty)#5 (2) {
+  object(ReflectionProperty)#4 (2) {
     ["name"]=>
     string(5) "value"
     ["class"]=>

Zend/tests/enum/scalar-int-const-invalid-expr.phpt

@@ -11,4 +11,4 @@ var_dump(Foo::Bar->value);
 
 ?>
 --EXPECTF--
-Fatal error: Unsupported constant expression in %s on line %d
+Fatal error: Enum case value must be constant in %s on line %d

Zend/tests/enum/unserialize-refcount.phpt

@@ -23,23 +23,23 @@ debug_zval_dump(Foo::Bar);
 
 ?>
 --EXPECT--
-object(Foo)#2 (1) refcount(2){
+object(Foo)#1 (1) refcount(2){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }
-object(Foo)#2 (1) refcount(3){
+object(Foo)#1 (1) refcount(3){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }
-object(Foo)#2 (1) refcount(4){
+object(Foo)#1 (1) refcount(4){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }
-object(Foo)#2 (1) refcount(3){
+object(Foo)#1 (1) refcount(3){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }
-object(Foo)#2 (1) refcount(2){
+object(Foo)#1 (1) refcount(2){
   ["name"]=>
-  string(3) "Bar" refcount(2)
+  string(3) "Bar" interned
 }

Zend/zend_API.c

@@ -1337,9 +1337,6 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 		return SUCCESS;
 	}
 
-	// Set ZEND_ACC_CONSTANTS_UPDATED flag before loading constants to avoid infinite recursion on constant enums
-	class_type->ce_flags |= ZEND_ACC_CONSTANTS_UPDATED;
-
 	if (ce_flags & ZEND_ACC_IMMUTABLE) {
 		mutable_data = ZEND_MAP_PTR_GET_IMM(class_type->mutable_data);
 		if (mutable_data) {
@@ -1354,7 +1351,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 
 	if (class_type->parent) {
 		if (UNEXPECTED(zend_update_class_constants(class_type->parent) != SUCCESS)) {
-			goto failure;
+			return FAILURE;
 		}
 	}
 
@@ -1373,7 +1370,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 			if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
 				val = &c->value;
 				if (UNEXPECTED(zval_update_constant_ex(val, c->ce) != SUCCESS)) {
-					goto failure;
+					return FAILURE;
 				}
 			}
 		} ZEND_HASH_FOREACH_END();
@@ -1423,22 +1420,23 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 					ZVAL_COPY(&tmp, val);
 					if (UNEXPECTED(zval_update_constant_ex(&tmp, prop_info->ce) != SUCCESS)) {
 						zval_ptr_dtor(&tmp);
-						goto failure;
+						return FAILURE;
 					}
 					/* property initializers must always be evaluated with strict types */;
 					if (UNEXPECTED(!zend_verify_property_type(prop_info, &tmp, /* strict */ 1))) {
 						zval_ptr_dtor(&tmp);
-						goto failure;
+						return FAILURE;
 					}
 					zval_ptr_dtor(val);
 					ZVAL_COPY_VALUE(val, &tmp);
 				} else if (UNEXPECTED(zval_update_constant_ex(val, prop_info->ce) != SUCCESS)) {
-					goto failure;
+					return FAILURE;
 				}
 			}
 		} ZEND_HASH_FOREACH_END();
 	}
 
+	ce_flags |= ZEND_ACC_CONSTANTS_UPDATED;
 	ce_flags &= ~ZEND_ACC_HAS_AST_CONSTANTS;
 	ce_flags &= ~ZEND_ACC_HAS_AST_PROPERTIES;
 	if (class_type->ce_flags & ZEND_ACC_IMMUTABLE) {
@@ -1454,10 +1452,6 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 	}
 
 	return SUCCESS;
-
-failure:
-	class_type->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
-	return FAILURE;
 }
 /* }}} */
 

Zend/zend_compile.c

@@ -7679,7 +7679,7 @@ static void zend_compile_enum_case(zend_ast *ast)
 		zend_error_noreturn(E_COMPILE_ERROR, "Case can only be used in enums");
 	}
 
-	zend_string *enum_case_name = zend_ast_get_str(ast->child[0]);
+	zend_string *enum_case_name = zval_make_interned_string(zend_ast_get_zval(ast->child[0]));
 	zend_string *enum_class_name = enum_class->name;
 
 	zval class_name_zval;
@@ -7704,18 +7704,22 @@ static void zend_compile_enum_case(zend_ast *ast)
 				ZSTR_VAL(enum_class_name));
 		}
 
-		if (!zend_is_allowed_in_const_expr(case_value_ast->kind)) {
+		zend_eval_const_expr(&ast->child[1]);
+		case_value_ast = ast->child[1];
+		if (case_value_ast->kind != ZEND_AST_ZVAL) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Enum case value must be constant");
 		}
+
 		zval case_value_zv;
-		zend_ast_evaluate(&case_value_zv, case_value_ast, enum_class);
+		ZVAL_COPY(&case_value_zv, zend_ast_get_zval(case_value_ast));
 		if (enum_class->enum_scalar_type != Z_TYPE(case_value_zv)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Enum case type %s does not match enum scalar type %s", 
 				zend_get_type_by_const(Z_TYPE(case_value_zv)),
 				zend_get_type_by_const(enum_class->enum_scalar_type));
 		}
 		case_value_zval_ast = zend_ast_create_zval(&case_value_zv);
 
+		Z_TRY_ADDREF(case_name_zval);
 		if (enum_class->enum_scalar_type == IS_LONG) {
 			zend_long long_key = Z_LVAL(case_value_zv);
 			zval *existing_case_name = zend_hash_index_find(enum_class->enum_scalar_table, long_key);
@@ -7745,7 +7749,7 @@ static void zend_compile_enum_case(zend_ast *ast)
 	zval value_zv;
 	zend_const_expr_to_zval(&value_zv, &const_enum_init_ast);
 	zend_class_constant *c = zend_declare_class_constant_ex(enum_class, enum_case_name, &value_zv, ZEND_ACC_PUBLIC, NULL);
-	c->value.u2.access_flags |= ZEND_CLASS_CONST_IS_CASE;
+	Z_ACCESS_FLAGS(c->value) |= ZEND_CLASS_CONST_IS_CASE;
 
 	zend_ast *attr_ast = ast->child[2];
 	if (attr_ast) {

Zend/zend_enum.c

@@ -19,7 +19,7 @@
 #include "zend.h"
 #include "zend_API.h"
 #include "zend_compile.h"
-#include "zend_interfaces_arginfo.h"
+#include "zend_enum_arginfo.h"
 
 #define ZEND_ENUM_PROPERTY_ERROR() \
 	zend_throw_error(NULL, "Enum properties are immutable")
@@ -31,16 +31,16 @@
 		} \
 	} while (0);
 
+ZEND_API zend_class_entry *zend_ce_unit_enum;
+ZEND_API zend_class_entry *zend_ce_scalar_enum;
+
 static zend_object_handlers enum_handlers;
 
 zend_object *zend_enum_new(zval *result, zend_class_entry *ce, zend_string *case_name, zval *scalar_zv)
 {
-	// Temporarily remove the ZEND_ACC_ENUM flag to allow instantiation
-	ce->ce_flags &= ~ZEND_ACC_ENUM;
-	object_init_ex(result, ce);
-	ce->ce_flags |= ZEND_ACC_ENUM;
+	zend_object *zobj = zend_objects_new(ce);
+	ZVAL_OBJ(result, zobj);
 
-	zend_object *zobj = Z_OBJ_P(result);
 	ZVAL_STR_COPY(OBJ_PROP_NUM(zobj, 0), case_name);
 	if (scalar_zv != NULL) {
 		ZVAL_COPY(OBJ_PROP_NUM(zobj, 1), scalar_zv);
@@ -123,7 +123,7 @@ static zval *zend_enum_read_property(zend_object *zobj, zend_string *name, int t
 	return zend_std_read_property(zobj, name, type, cache_slot, rv);
 }
 
-ZEND_COLD zval *zend_enum_write_property(zend_object *object, zend_string *member, zval *value, void **cache_slot)
+static ZEND_COLD zval *zend_enum_write_property(zend_object *object, zend_string *member, zval *value, void **cache_slot)
 {
 	ZEND_ENUM_PROPERTY_ERROR();
 	return &EG(uninitialized_zval);
@@ -134,12 +134,12 @@ static ZEND_COLD void zend_enum_unset_property(zend_object *object, zend_string
 	ZEND_ENUM_PROPERTY_ERROR();
 }
 
-ZEND_API zval *zend_enum_get_property_ptr_ptr(zend_object *zobj, zend_string *name, int type, void **cache_slot)
+static zval *zend_enum_get_property_ptr_ptr(zend_object *zobj, zend_string *name, int type, void **cache_slot)
 {
 	return NULL;
 }
 
-int zend_enum_compare_objects(zval *o1, zval *o2)
+static int zend_enum_compare_objects(zval *o1, zval *o2)
 {
 	if (Z_TYPE_P(o1) != IS_OBJECT || Z_TYPE_P(o2) != IS_OBJECT) {
 		return ZEND_UNCOMPARABLE;
@@ -148,8 +148,46 @@ int zend_enum_compare_objects(zval *o1, zval *o2)
 	return Z_OBJ_P(o1) == Z_OBJ_P(o2) ? 0 : 1;
 }
 
+static int zend_implement_unit_enum(zend_class_entry *interface, zend_class_entry *class_type)
+{
+	if (class_type->ce_flags & ZEND_ACC_ENUM) {
+		return SUCCESS;
+	}
+
+	zend_error_noreturn(E_ERROR, "Non-enum class %s cannot implement interface %s",
+		ZSTR_VAL(class_type->name),
+		ZSTR_VAL(interface->name));
+
+	return FAILURE;
+}
+
+static int zend_implement_scalar_enum(zend_class_entry *interface, zend_class_entry *class_type)
+{
+	if (!(class_type->ce_flags & ZEND_ACC_ENUM)) {
+		zend_error_noreturn(E_ERROR, "Non-enum class %s cannot implement interface %s",
+			ZSTR_VAL(class_type->name),
+			ZSTR_VAL(interface->name));
+		return FAILURE;
+	}
+
+	if (class_type->enum_scalar_type == IS_UNDEF) {
+		zend_error_noreturn(E_ERROR, "Non-scalar enum %s cannot implement interface %s",
+			ZSTR_VAL(class_type->name),
+			ZSTR_VAL(interface->name));
+		return FAILURE;
+	}
+
+	return SUCCESS;
+}
+
 void zend_register_enum_ce(void)
 {
+	zend_ce_unit_enum = register_class_UnitEnum();
+	zend_ce_unit_enum->interface_gets_implemented = zend_implement_unit_enum;
+
+	zend_ce_scalar_enum = register_class_ScalarEnum(zend_ce_unit_enum);
+	zend_ce_scalar_enum->interface_gets_implemented = zend_implement_scalar_enum;
+
 	memcpy(&enum_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 	enum_handlers.read_property = zend_enum_read_property;
 	enum_handlers.write_property = zend_enum_write_property;
@@ -190,8 +228,8 @@ static ZEND_NAMED_FUNCTION(zend_enum_cases_func)
 
 	array_init(return_value);
 
-	ZEND_HASH_FOREACH_PTR(&ce->constants_table, c) {
-		if (!(c->value.u2.access_flags & ZEND_CLASS_CONST_IS_CASE)) {
+	ZEND_HASH_FOREACH_PTR(CE_CONSTANTS_TABLE(ce), c) {
+		if (!(Z_ACCESS_FLAGS(c->value) & ZEND_CLASS_CONST_IS_CASE)) {
 			continue;
 		}
 		zval *zv = &c->value;
@@ -243,9 +281,8 @@ static void zend_enum_from_base(INTERNAL_FUNCTION_PARAMETERS, bool try)
 	}
 
 	ZEND_ASSERT(Z_TYPE_P(case_name_zv) == IS_STRING);
-	zval *case_const_zv = zend_hash_find(&ce->constants_table, Z_STR_P(case_name_zv));
-	ZEND_ASSERT(case_const_zv != NULL);
-	zend_class_constant *c = Z_PTR_P(case_const_zv);
+	zend_class_constant *c = zend_hash_find_ptr(CE_CONSTANTS_TABLE(ce), Z_STR_P(case_name_zv));
+	ZEND_ASSERT(c != NULL);
 	zval *case_zv = &c->value;
 	if (Z_TYPE_P(case_zv) == IS_CONSTANT_AST) {
 		zval_update_constant_ex(case_zv, c->ce);
@@ -269,45 +306,49 @@ static ZEND_NAMED_FUNCTION(zend_enum_try_from_func)
 
 void zend_enum_register_funcs(zend_class_entry *ce)
 {
-	zend_string *cases_func_name = zend_string_init("cases", strlen("cases"), 1);
-	zend_internal_function *cases_function = malloc(sizeof(zend_internal_function));
+	const uint32_t fn_flags =
+		ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_ARENA_ALLOCATED;
+	zend_internal_function *cases_function =
+		zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
 	memset(cases_function, 0, sizeof(zend_internal_function));
 	cases_function->type = ZEND_INTERNAL_FUNCTION;
 	cases_function->module = EG(current_module);
 	cases_function->handler = zend_enum_cases_func;
-	cases_function->function_name = cases_func_name;
+	cases_function->function_name = ZSTR_KNOWN(ZEND_STR_CASES);
 	cases_function->scope = ce;
-	cases_function->fn_flags = ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE;
+	cases_function->fn_flags = fn_flags;
 	cases_function->arg_info = (zend_internal_arg_info *) (arginfo_class_UnitEnum_cases + 1);
-	zend_hash_add_ptr(&ce->function_table, cases_func_name, cases_function);
+	zend_hash_add_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_CASES), cases_function);
 
 	if (ce->enum_scalar_type != IS_UNDEF) {
-		zend_string *from_func_name = zend_string_init("from", strlen("from"), 1);
-		zend_internal_function *from_function = malloc(sizeof(zend_internal_function));
+		zend_internal_function *from_function =
+			zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
 		memset(from_function, 0, sizeof(zend_internal_function));
 		from_function->type = ZEND_INTERNAL_FUNCTION;
 		from_function->module = EG(current_module);
 		from_function->handler = zend_enum_from_func;
-		from_function->function_name = from_func_name;
+		from_function->function_name = ZSTR_KNOWN(ZEND_STR_FROM);
 		from_function->scope = ce;
-		from_function->fn_flags = ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE;
+		from_function->fn_flags = fn_flags;
 		from_function->num_args = 1;
 		from_function->required_num_args = 1;
 		from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_ScalarEnum_from + 1);
-		zend_hash_add_ptr(&ce->function_table, from_func_name, from_function);
+		zend_hash_add_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_FROM), from_function);
 
-		zend_internal_function *try_from_function = malloc(sizeof(zend_internal_function));
+		zend_internal_function *try_from_function =
+			zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
 		memset(try_from_function, 0, sizeof(zend_internal_function));
 		try_from_function->type = ZEND_INTERNAL_FUNCTION;
 		try_from_function->module = EG(current_module);
 		try_from_function->handler = zend_enum_try_from_func;
-		try_from_function->function_name = zend_string_init("tryFrom", strlen("tryFrom"), 1);
+		try_from_function->function_name = ZSTR_KNOWN(ZEND_STR_TRYFROM);
 		try_from_function->scope = ce;
-		try_from_function->fn_flags = ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE;
+		try_from_function->fn_flags = fn_flags;
 		try_from_function->num_args = 1;
 		try_from_function->required_num_args = 1;
 		try_from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_ScalarEnum_tryFrom + 1);
-		zend_hash_add_ptr(&ce->function_table, zend_string_init("tryfrom", strlen("tryfrom"), 1), try_from_function);
+		zend_hash_add_ptr(
+			&ce->function_table, ZSTR_KNOWN(ZEND_STR_TRYFROM_LOWERCASE), try_from_function);
 	}
 }
 

Zend/zend_enum.h

@@ -22,6 +22,11 @@
 #include "zend.h"
 #include "zend_types.h"
 
+BEGIN_EXTERN_C()
+
+extern ZEND_API zend_class_entry *zend_ce_unit_enum;
+extern ZEND_API zend_class_entry *zend_ce_scalar_enum;
+
 void zend_register_enum_ce(void);
 void zend_enum_add_interfaces(zend_class_entry *ce);
 zend_object *zend_enum_new(zval *result, zend_class_entry *ce, zend_string *case_name, zval *scalar_zv);
@@ -31,4 +36,6 @@ void zend_enum_register_props(zend_class_entry *ce);
 zval *zend_enum_fetch_case_name(zend_object *zobj);
 zval *zend_enum_fetch_case_value(zend_object *zobj);
 
+END_EXTERN_C()
+
 #endif /* ZEND_ENUM_H */