New review round

kocsismate · kocsismate · commit e4498cca47e4 · 2023-04-16T19:43:54.000+02:00
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -1412,15 +1412,17 @@ static zend_result update_property(zval *val, zend_property_info *prop_info) {
 	return zval_update_constant_ex(val, prop_info->ce);
 }
 
-zend_result zend_update_class_constant(zend_class_constant *c, zval *value, zend_class_entry *scope)
+ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_class_entry *scope)
 {
+	ZEND_ASSERT(Z_TYPE(c->value) == IS_CONSTANT_AST);
+
 	if (EXPECTED(!ZEND_TYPE_IS_SET(c->type) || ZEND_TYPE_PURE_MASK(c->type) == MAY_BE_ANY)) {
-		return zval_update_constant_ex(value, scope);
+		return zval_update_constant_ex(&c->value, scope);
 	}
 
 	zval tmp;
 
-	ZVAL_COPY_OR_DUP(&tmp, value);
+	ZVAL_COPY(&tmp, &c->value);
 	zend_result result = zval_update_constant_ex(&tmp, scope);
 	if (result == FAILURE) {
 		zval_ptr_dtor(&tmp);
@@ -1432,9 +1434,8 @@ zend_result zend_update_class_constant(zend_class_constant *c, zval *value, zend
 		return FAILURE;
 	}
 
-	zval_ptr_dtor(value);
-	ZVAL_COPY_OR_DUP(value, &tmp);
-	zval_ptr_dtor(&tmp);
+	zval_ptr_dtor(&c->value);
+	ZVAL_COPY_VALUE(&c->value, &tmp);
 
 	return SUCCESS;
 }
@@ -1497,7 +1498,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /
 				}
 
 				val = &c->value;
-				if (UNEXPECTED(zend_update_class_constant(c, val, c->ce) != SUCCESS)) {
+				if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {
 					return FAILURE;
 				}
 			}
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
@@ -439,7 +439,7 @@ ZEND_API void zend_declare_class_constant_double(zend_class_entry *ce, const cha
 ZEND_API void zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length);
 ZEND_API void zend_declare_class_constant_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value);
 
-zend_result zend_update_class_constant(zend_class_constant *c, zval *value, zend_class_entry *scope);
+ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, zend_class_entry *scope);
 ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type);
 ZEND_API HashTable *zend_separate_class_constants_table(zend_class_entry *class_type);
 
diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
@@ -361,7 +361,7 @@ ZEND_API zval *zend_get_class_constant_ex(zend_string *class_name, zend_string *
 		}
 
 		MARK_CONSTANT_VISITED(ret_constant);
-		ret = zend_update_class_constant(c, ret_constant, c->ce);
+		ret = zend_update_class_constant(c, c->ce);
 		RESET_CONSTANT_VISITED(ret_constant);
 
 		if (UNEXPECTED(ret != SUCCESS)) {
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -918,7 +918,7 @@ static const zend_class_entry *resolve_single_class_type(zend_string *name, cons
 }
 
 static zend_always_inline const zend_class_entry *zend_ce_from_type(
-		const zend_class_entry *class_ce, const zend_type *type) {
+		const zend_class_entry *scope, const zend_type *type) {
 	ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*type));
 	zend_string *name = ZEND_TYPE_NAME(*type);
 	if (ZSTR_HAS_CE_CACHE(name)) {
@@ -928,53 +928,53 @@ static zend_always_inline const zend_class_entry *zend_ce_from_type(
 		}
 		return ce;
 	}
-	return resolve_single_class_type(name, class_ce);
+	return resolve_single_class_type(name, scope);
 }
 
-static bool zend_check_intersection_for_property_or_class_constant_class_type(zend_type_list *intersection_type_list,
-	const zend_class_entry *class_ce, const zend_class_entry *object_ce)
+static bool zend_check_intersection_for_property_or_class_constant_class_type(
+	const zend_class_entry *scope, zend_type_list *intersection_type_list, const zend_class_entry *value_ce)
 {
 	zend_type *list_type;
 
 	ZEND_TYPE_LIST_FOREACH(intersection_type_list, list_type) {
 		ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));
-		const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);
-		if (!ce || !instanceof_function(object_ce, ce)) {
+		const zend_class_entry *ce = zend_ce_from_type(scope, list_type);
+		if (!ce || !instanceof_function(value_ce, ce)) {
 			return false;
 		}
 	} ZEND_TYPE_LIST_FOREACH_END();
 	return true;
 }
 
 static bool zend_check_and_resolve_property_or_class_constant_class_type(
-		zend_type type, const zend_class_entry *class_ce, const zend_class_entry *object_ce) {
-	if (ZEND_TYPE_HAS_LIST(type)) {
+	const zend_class_entry *scope, zend_type member_type, const zend_class_entry *value_ce) {
+if (ZEND_TYPE_HAS_LIST(member_type)) {
 		zend_type *list_type;
-		if (ZEND_TYPE_IS_INTERSECTION(type)) {
+		if (ZEND_TYPE_IS_INTERSECTION(member_type)) {
 			return zend_check_intersection_for_property_or_class_constant_class_type(
-				ZEND_TYPE_LIST(type), class_ce, object_ce);
+				scope, ZEND_TYPE_LIST(member_type), value_ce);
 		} else {
-			ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), list_type) {
+			ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(member_type), list_type) {
 				if (ZEND_TYPE_IS_INTERSECTION(*list_type)) {
 					if (zend_check_intersection_for_property_or_class_constant_class_type(
-							ZEND_TYPE_LIST(*list_type), class_ce, object_ce)) {
+							scope, ZEND_TYPE_LIST(*list_type), value_ce)) {
 						return true;
 					}
 					continue;
 				}
 				ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));
-				const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);
-				if (ce && instanceof_function(object_ce, ce)) {
+				const zend_class_entry *ce = zend_ce_from_type(scope, list_type);
+				if (ce && instanceof_function(value_ce, ce)) {
 					return true;
 				}
 			} ZEND_TYPE_LIST_FOREACH_END();
 			return false;
 		}
-	} else if ((ZEND_TYPE_PURE_MASK(type) & MAY_BE_STATIC)) {
-		return instanceof_function(object_ce, class_ce);
+	} else if ((ZEND_TYPE_PURE_MASK(member_type) & MAY_BE_STATIC)) {
+		return instanceof_function(value_ce, scope);
 	} else {
-		const zend_class_entry *ce = zend_ce_from_type(class_ce, &type);
-		return ce && instanceof_function(object_ce, ce);
+		const zend_class_entry *ce = zend_ce_from_type(scope, &member_type);
+		return ce && instanceof_function(value_ce, ce);
 	}
 }
 
@@ -986,7 +986,7 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in
 	}
 
 	if (ZEND_TYPE_IS_COMPLEX(info->type) && Z_TYPE_P(property) == IS_OBJECT
-			&& zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(property))) {
+			&& zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(property))) {
 		return 1;
 	}
 
@@ -1475,13 +1475,13 @@ static zend_always_inline bool zend_check_class_constant_type(zend_class_constan
 	}
 
 	if (((ZEND_TYPE_PURE_MASK(c->type) & MAY_BE_STATIC) || ZEND_TYPE_IS_COMPLEX(c->type)) && Z_TYPE_P(constant) == IS_OBJECT
-		&& zend_check_and_resolve_property_or_class_constant_class_type(c->type, c->ce, Z_OBJCE_P(constant))) {
+		&& zend_check_and_resolve_property_or_class_constant_class_type(c->ce, c->type, Z_OBJCE_P(constant))) {
 		return 1;
 	}
 
 	uint32_t type_mask = ZEND_TYPE_FULL_MASK(c->type);
 	ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE|MAY_BE_NEVER|MAY_BE_VOID)));
-	return zend_verify_scalar_type_hint(type_mask, constant, 1, 0);
+	return zend_verify_scalar_type_hint(type_mask, constant, true, false);
 }
 
 ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant *c, zval *constant)
@@ -3512,7 +3512,7 @@ static zend_always_inline int i_zend_verify_type_assignable_zval(
 	}
 
 	if (ZEND_TYPE_IS_COMPLEX(type) && zv_type == IS_OBJECT
-			&& zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(zv))) {
+			&& zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(zv))) {
 		return 1;
 	}
 
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -5991,7 +5991,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CO
 				}
 			}
 			if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
-				if (UNEXPECTED(zend_update_class_constant(c, value, c->ce) != SUCCESS)) {
+				if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {
 					ZVAL_UNDEF(EX_VAR(opline->result.var));
 					FREE_OP2();
 					HANDLE_EXCEPTION();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
@@ -3760,7 +3760,7 @@ static bool preload_try_resolve_constants(zend_class_entry *ce)
 		ZEND_HASH_MAP_FOREACH_PTR(&ce->constants_table, c) {
 			val = &c->value;
 			if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
-				if (EXPECTED(zend_update_class_constant(c, val, c->ce) == SUCCESS)) {
+				if (EXPECTED(zend_update_class_constant(c, c->ce) == SUCCESS)) {
 					was_changed = changed = true;
 				} else {
 					ok = false;
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
@@ -558,13 +558,14 @@ static void _const_string(smart_str *str, char *name, zval *value, char *indent)
 /* {{{ _class_const_string */
 static void _class_const_string(smart_str *str, char *name, zend_class_constant *c, char *indent)
 {
-	if (zend_update_class_constant(c, &c->value, c->ce) == FAILURE) {
+	if (zend_update_class_constant(c, c->ce) == FAILURE) {
 		return;
 	}
 
 	const char *visibility = zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c));
 	const char *final = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_FINAL ? "final " : "";
-	const char *type = ZEND_TYPE_IS_SET(c->type) ? ZSTR_VAL(zend_type_to_string(c->type)) : zend_zval_type_name(&c->value);
+	zend_string *type_str = ZEND_TYPE_IS_SET(c->type) ? zend_type_to_string(c->type) : NULL;
+	const char *type = type_str ? ZSTR_VAL(type_str) : zend_zval_type_name(&c->value);
 	smart_str_append_printf(str, "%sConstant [ %s%s %s %s ] { ",
 		indent, final, visibility, type, name);
 	if (Z_TYPE(c->value) == IS_ARRAY) {
@@ -578,6 +579,10 @@ static void _class_const_string(smart_str *str, char *name, zend_class_constant
 		zend_tmp_string_release(tmp_value_str);
 	}
 	smart_str_appends(str, " }\n");
+
+	if (type_str) {
+		zend_string_release(type_str);
+	}
 }
 /* }}} */
 
@@ -3921,7 +3926,7 @@ ZEND_METHOD(ReflectionClassConstant, getValue)
 	GET_REFLECTION_OBJECT_PTR(ref);
 
 	if (Z_TYPE(ref->value) == IS_CONSTANT_AST) {
-		zend_result result = zend_update_class_constant(ref, &ref->value, ref->ce);
+		zend_result result = zend_update_class_constant(ref, ref->ce);
 		if (result == FAILURE) {
 			RETURN_THROWS();
 		}
@@ -4730,7 +4735,7 @@ ZEND_METHOD(ReflectionClass, getConstants)
 
 	array_init(return_value);
 	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(CE_CONSTANTS_TABLE(ce), key, constant) {
-		if (UNEXPECTED(zend_update_class_constant(constant, &constant->value, constant->ce) != SUCCESS)) {
+		if (UNEXPECTED(zend_update_class_constant(constant, constant->ce) != SUCCESS)) {
 			RETURN_THROWS();
 		}
 
@@ -4789,7 +4794,7 @@ ZEND_METHOD(ReflectionClass, getConstant)
 	GET_REFLECTION_OBJECT_PTR(ce);
 	constants_table = CE_CONSTANTS_TABLE(ce);
 	ZEND_HASH_MAP_FOREACH_PTR(constants_table, c) {
-		if (UNEXPECTED(zend_update_class_constant(c, &c->value, c->ce) != SUCCESS)) {
+		if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {
 			RETURN_THROWS();
 		}
 	} ZEND_HASH_FOREACH_END();

Original file line number	Diff line number	Diff line change
`@@ -1412,15 +1412,17 @@ static zend_result update_property(zval val, zend_property_info prop_info) {`
`1412`	`1412`	`return zval_update_constant_ex(val, prop_info->ce);`
`1413`	`1413`	`}`
`1414`	`1414`
`1415`		`-zend_result zend_update_class_constant(zend_class_constant c, zval value, zend_class_entry *scope)`
	`1415`	`+ZEND_API zend_result zend_update_class_constant(zend_class_constant c, zend_class_entry scope)`
`1416`	`1416`	`{`
	`1417`	`+ ZEND_ASSERT(Z_TYPE(c->value) == IS_CONSTANT_AST);`
	`1418`	`+`
`1417`	`1419`	`if (EXPECTED(!ZEND_TYPE_IS_SET(c->type) \|\| ZEND_TYPE_PURE_MASK(c->type) == MAY_BE_ANY)) {`
`1418`		`- return zval_update_constant_ex(value, scope);`
	`1420`	`+ return zval_update_constant_ex(&c->value, scope);`
`1419`	`1421`	`}`
`1420`	`1422`
`1421`	`1423`	`zval tmp;`
`1422`	`1424`
`1423`		`- ZVAL_COPY_OR_DUP(&tmp, value);`
	`1425`	`+ ZVAL_COPY(&tmp, &c->value);`
`1424`	`1426`	`zend_result result = zval_update_constant_ex(&tmp, scope);`
`1425`	`1427`	`if (result == FAILURE) {`
`1426`	`1428`	`zval_ptr_dtor(&tmp);`
`@@ -1432,9 +1434,8 @@ zend_result zend_update_class_constant(zend_class_constant c, zval value, zend`
`1432`	`1434`	`return FAILURE;`
`1433`	`1435`	`}`
`1434`	`1436`
`1435`		`- zval_ptr_dtor(value);`
`1436`		`- ZVAL_COPY_OR_DUP(value, &tmp);`
`1437`		`- zval_ptr_dtor(&tmp);`
	`1437`	`+ zval_ptr_dtor(&c->value);`
	`1438`	`+ ZVAL_COPY_VALUE(&c->value, &tmp);`
`1438`	`1439`
`1439`	`1440`	`return SUCCESS;`
`1440`	`1441`	`}`
`@@ -1497,7 +1498,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /`
`1497`	`1498`	`}`
`1498`	`1499`
`1499`	`1500`	`val = &c->value;`
`1500`		`- if (UNEXPECTED(zend_update_class_constant(c, val, c->ce) != SUCCESS)) {`
	`1501`	`+ if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {`
`1501`	`1502`	`return FAILURE;`
`1502`	`1503`	`}`
`1503`	`1504`	`}`
Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ ZEND_API zval zend_get_class_constant_ex(zend_string class_name, zend_string *`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`MARK_CONSTANT_VISITED(ret_constant);`
`364`		`- ret = zend_update_class_constant(c, ret_constant, c->ce);`
	`364`	`+ ret = zend_update_class_constant(c, c->ce);`
`365`	`365`	`RESET_CONSTANT_VISITED(ret_constant);`
`366`	`366`
`367`	`367`	`if (UNEXPECTED(ret != SUCCESS)) {`
Original file line number	Diff line number	Diff line change
`@@ -918,7 +918,7 @@ static const zend_class_entry resolve_single_class_type(zend_string name, cons`
`918`	`918`	`}`
`919`	`919`
`920`	`920`	`static zend_always_inline const zend_class_entry *zend_ce_from_type(`
`921`		`- const zend_class_entry class_ce, const zend_type type) {`
	`921`	`+ const zend_class_entry scope, const zend_type type) {`
`922`	`922`	`ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*type));`
`923`	`923`	`zend_string name = ZEND_TYPE_NAME(type);`
`924`	`924`	`if (ZSTR_HAS_CE_CACHE(name)) {`
`@@ -928,53 +928,53 @@ static zend_always_inline const zend_class_entry *zend_ce_from_type(`
`928`	`928`	`}`
`929`	`929`	`return ce;`
`930`	`930`	`}`
`931`		`- return resolve_single_class_type(name, class_ce);`
	`931`	`+ return resolve_single_class_type(name, scope);`
`932`	`932`	`}`
`933`	`933`
`934`		`-static bool zend_check_intersection_for_property_or_class_constant_class_type(zend_type_list *intersection_type_list,`
`935`		`- const zend_class_entry class_ce, const zend_class_entry object_ce)`
	`934`	`+static bool zend_check_intersection_for_property_or_class_constant_class_type(`
	`935`	`+ const zend_class_entry scope, zend_type_list intersection_type_list, const zend_class_entry *value_ce)`
`936`	`936`	`{`
`937`	`937`	`zend_type *list_type;`
`938`	`938`
`939`	`939`	`ZEND_TYPE_LIST_FOREACH(intersection_type_list, list_type) {`
`940`	`940`	`ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));`
`941`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);`
`942`		`- if (!ce \|\| !instanceof_function(object_ce, ce)) {`
	`941`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, list_type);`
	`942`	`+ if (!ce \|\| !instanceof_function(value_ce, ce)) {`
`943`	`943`	`return false;`
`944`	`944`	`}`
`945`	`945`	`} ZEND_TYPE_LIST_FOREACH_END();`
`946`	`946`	`return true;`
`947`	`947`	`}`
`948`	`948`
`949`	`949`	`static bool zend_check_and_resolve_property_or_class_constant_class_type(`
`950`		`- zend_type type, const zend_class_entry class_ce, const zend_class_entry object_ce) {`
`951`		`- if (ZEND_TYPE_HAS_LIST(type)) {`
	`950`	`+ const zend_class_entry scope, zend_type member_type, const zend_class_entry value_ce) {`
	`951`	`+if (ZEND_TYPE_HAS_LIST(member_type)) {`
`952`	`952`	`zend_type *list_type;`
`953`		`- if (ZEND_TYPE_IS_INTERSECTION(type)) {`
	`953`	`+ if (ZEND_TYPE_IS_INTERSECTION(member_type)) {`
`954`	`954`	`return zend_check_intersection_for_property_or_class_constant_class_type(`
`955`		`- ZEND_TYPE_LIST(type), class_ce, object_ce);`
	`955`	`+ scope, ZEND_TYPE_LIST(member_type), value_ce);`
`956`	`956`	`} else {`
`957`		`- ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), list_type) {`
	`957`	`+ ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(member_type), list_type) {`
`958`	`958`	`if (ZEND_TYPE_IS_INTERSECTION(*list_type)) {`
`959`	`959`	`if (zend_check_intersection_for_property_or_class_constant_class_type(`
`960`		`- ZEND_TYPE_LIST(*list_type), class_ce, object_ce)) {`
	`960`	`+ scope, ZEND_TYPE_LIST(*list_type), value_ce)) {`
`961`	`961`	`return true;`
`962`	`962`	`}`
`963`	`963`	`continue;`
`964`	`964`	`}`
`965`	`965`	`ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));`
`966`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);`
`967`		`- if (ce && instanceof_function(object_ce, ce)) {`
	`966`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, list_type);`
	`967`	`+ if (ce && instanceof_function(value_ce, ce)) {`
`968`	`968`	`return true;`
`969`	`969`	`}`
`970`	`970`	`} ZEND_TYPE_LIST_FOREACH_END();`
`971`	`971`	`return false;`
`972`	`972`	`}`
`973`		`- } else if ((ZEND_TYPE_PURE_MASK(type) & MAY_BE_STATIC)) {`
`974`		`- return instanceof_function(object_ce, class_ce);`
	`973`	`+ } else if ((ZEND_TYPE_PURE_MASK(member_type) & MAY_BE_STATIC)) {`
	`974`	`+ return instanceof_function(value_ce, scope);`
`975`	`975`	`} else {`
`976`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, &type);`
`977`		`- return ce && instanceof_function(object_ce, ce);`
	`976`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, &member_type);`
	`977`	`+ return ce && instanceof_function(value_ce, ce);`
`978`	`978`	`}`
`979`	`979`	`}`
`980`	`980`
`@@ -986,7 +986,7 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in`
`986`	`986`	`}`
`987`	`987`
`988`	`988`	`if (ZEND_TYPE_IS_COMPLEX(info->type) && Z_TYPE_P(property) == IS_OBJECT`
`989`		`- && zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(property))) {`
	`989`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(property))) {`
`990`	`990`	`return 1;`
`991`	`991`	`}`
`992`	`992`
`@@ -1475,13 +1475,13 @@ static zend_always_inline bool zend_check_class_constant_type(zend_class_constan`
`1475`	`1475`	`}`
`1476`	`1476`
`1477`	`1477`	`if (((ZEND_TYPE_PURE_MASK(c->type) & MAY_BE_STATIC) \|\| ZEND_TYPE_IS_COMPLEX(c->type)) && Z_TYPE_P(constant) == IS_OBJECT`
`1478`		`- && zend_check_and_resolve_property_or_class_constant_class_type(c->type, c->ce, Z_OBJCE_P(constant))) {`
	`1478`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(c->ce, c->type, Z_OBJCE_P(constant))) {`
`1479`	`1479`	`return 1;`
`1480`	`1480`	`}`
`1481`	`1481`
`1482`	`1482`	`uint32_t type_mask = ZEND_TYPE_FULL_MASK(c->type);`
`1483`	`1483`	`ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE\|MAY_BE_NEVER\|MAY_BE_VOID)));`
`1484`		`- return zend_verify_scalar_type_hint(type_mask, constant, 1, 0);`
	`1484`	`+ return zend_verify_scalar_type_hint(type_mask, constant, true, false);`
`1485`	`1485`	`}`
`1486`	`1486`
`1487`	`1487`	`ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant c, zval constant)`
`@@ -3512,7 +3512,7 @@ static zend_always_inline int i_zend_verify_type_assignable_zval(`
`3512`	`3512`	`}`
`3513`	`3513`
`3514`	`3514`	`if (ZEND_TYPE_IS_COMPLEX(type) && zv_type == IS_OBJECT`
`3515`		`- && zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(zv))) {`
	`3515`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(zv))) {`
`3516`	`3516`	`return 1;`
`3517`	`3517`	`}`
`3518`	`3518`
Original file line number	Diff line number	Diff line change
`@@ -5991,7 +5991,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR\|CONST\|UNUSED\|CLASS_FETCH, CO`
`5991`	`5991`	`}`
`5992`	`5992`	`}`
`5993`	`5993`	`if (Z_TYPE_P(value) == IS_CONSTANT_AST) {`
`5994`		`- if (UNEXPECTED(zend_update_class_constant(c, value, c->ce) != SUCCESS)) {`
	`5994`	`+ if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {`
`5995`	`5995`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`5996`	`5996`	`FREE_OP2();`
`5997`	`5997`	`HANDLE_EXCEPTION();`