New review round

kocsismate · kocsismate · commit 3c14339ce161 · 2023-03-21T20:43:29.000+01:00
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -1413,15 +1413,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);
@@ -1433,9 +1435,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;
 }
@@ -1498,7 +1499,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
@@ -440,7 +440,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
@@ -373,7 +373,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
@@ -926,7 +926,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)) {
@@ -936,53 +936,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);
 	}
 }
 
@@ -994,7 +994,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;
 	}
 
@@ -1482,13 +1482,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)
@@ -3518,7 +3518,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
@@ -5955,7 +5955,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
@@ -3762,7 +3762,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);
+	}
 }
 /* }}} */
 
@@ -3920,7 +3925,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();
 		}
@@ -4729,7 +4734,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();
 		}
 
@@ -4788,7 +4793,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
`@@ -1413,15 +1413,17 @@ static zend_result update_property(zval val, zend_property_info prop_info) {`
`1413`	`1413`	`return zval_update_constant_ex(val, prop_info->ce);`
`1414`	`1414`	`}`
`1415`	`1415`
`1416`		`-zend_result zend_update_class_constant(zend_class_constant c, zval value, zend_class_entry *scope)`
	`1416`	`+ZEND_API zend_result zend_update_class_constant(zend_class_constant c, zend_class_entry scope)`
`1417`	`1417`	`{`
	`1418`	`+ ZEND_ASSERT(Z_TYPE(c->value) == IS_CONSTANT_AST);`
	`1419`	`+`
`1418`	`1420`	`if (EXPECTED(!ZEND_TYPE_IS_SET(c->type) \|\| ZEND_TYPE_PURE_MASK(c->type) == MAY_BE_ANY)) {`
`1419`		`- return zval_update_constant_ex(value, scope);`
	`1421`	`+ return zval_update_constant_ex(&c->value, scope);`
`1420`	`1422`	`}`
`1421`	`1423`
`1422`	`1424`	`zval tmp;`
`1423`	`1425`
`1424`		`- ZVAL_COPY_OR_DUP(&tmp, value);`
	`1426`	`+ ZVAL_COPY(&tmp, &c->value);`
`1425`	`1427`	`zend_result result = zval_update_constant_ex(&tmp, scope);`
`1426`	`1428`	`if (result == FAILURE) {`
`1427`	`1429`	`zval_ptr_dtor(&tmp);`
`@@ -1433,9 +1435,8 @@ zend_result zend_update_class_constant(zend_class_constant c, zval value, zend`
`1433`	`1435`	`return FAILURE;`
`1434`	`1436`	`}`
`1435`	`1437`
`1436`		`- zval_ptr_dtor(value);`
`1437`		`- ZVAL_COPY_OR_DUP(value, &tmp);`
`1438`		`- zval_ptr_dtor(&tmp);`
	`1438`	`+ zval_ptr_dtor(&c->value);`
	`1439`	`+ ZVAL_COPY_VALUE(&c->value, &tmp);`
`1439`	`1440`
`1440`	`1441`	`return SUCCESS;`
`1441`	`1442`	`}`
`@@ -1498,7 +1499,7 @@ ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type) /`
`1498`	`1499`	`}`
`1499`	`1500`
`1500`	`1501`	`val = &c->value;`
`1501`		`- if (UNEXPECTED(zend_update_class_constant(c, val, c->ce) != SUCCESS)) {`
	`1502`	`+ if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {`
`1502`	`1503`	`return FAILURE;`
`1503`	`1504`	`}`
`1504`	`1505`	`}`
Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ ZEND_API zval zend_get_class_constant_ex(zend_string class_name, zend_string *`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`MARK_CONSTANT_VISITED(ret_constant);`
`376`		`- ret = zend_update_class_constant(c, ret_constant, c->ce);`
	`376`	`+ ret = zend_update_class_constant(c, c->ce);`
`377`	`377`	`RESET_CONSTANT_VISITED(ret_constant);`
`378`	`378`
`379`	`379`	`if (UNEXPECTED(ret != SUCCESS)) {`
Original file line number	Diff line number	Diff line change
`@@ -926,7 +926,7 @@ static const zend_class_entry resolve_single_class_type(zend_string name, cons`
`926`	`926`	`}`
`927`	`927`
`928`	`928`	`static zend_always_inline const zend_class_entry *zend_ce_from_type(`
`929`		`- const zend_class_entry class_ce, const zend_type type) {`
	`929`	`+ const zend_class_entry scope, const zend_type type) {`
`930`	`930`	`ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*type));`
`931`	`931`	`zend_string name = ZEND_TYPE_NAME(type);`
`932`	`932`	`if (ZSTR_HAS_CE_CACHE(name)) {`
`@@ -936,53 +936,53 @@ static zend_always_inline const zend_class_entry *zend_ce_from_type(`
`936`	`936`	`}`
`937`	`937`	`return ce;`
`938`	`938`	`}`
`939`		`- return resolve_single_class_type(name, class_ce);`
	`939`	`+ return resolve_single_class_type(name, scope);`
`940`	`940`	`}`
`941`	`941`
`942`		`-static bool zend_check_intersection_for_property_or_class_constant_class_type(zend_type_list *intersection_type_list,`
`943`		`- const zend_class_entry class_ce, const zend_class_entry object_ce)`
	`942`	`+static bool zend_check_intersection_for_property_or_class_constant_class_type(`
	`943`	`+ const zend_class_entry scope, zend_type_list intersection_type_list, const zend_class_entry *value_ce)`
`944`	`944`	`{`
`945`	`945`	`zend_type *list_type;`
`946`	`946`
`947`	`947`	`ZEND_TYPE_LIST_FOREACH(intersection_type_list, list_type) {`
`948`	`948`	`ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));`
`949`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);`
`950`		`- if (!ce \|\| !instanceof_function(object_ce, ce)) {`
	`949`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, list_type);`
	`950`	`+ if (!ce \|\| !instanceof_function(value_ce, ce)) {`
`951`	`951`	`return false;`
`952`	`952`	`}`
`953`	`953`	`} ZEND_TYPE_LIST_FOREACH_END();`
`954`	`954`	`return true;`
`955`	`955`	`}`
`956`	`956`
`957`	`957`	`static bool zend_check_and_resolve_property_or_class_constant_class_type(`
`958`		`- zend_type type, const zend_class_entry class_ce, const zend_class_entry object_ce) {`
`959`		`- if (ZEND_TYPE_HAS_LIST(type)) {`
	`958`	`+ const zend_class_entry scope, zend_type member_type, const zend_class_entry value_ce) {`
	`959`	`+if (ZEND_TYPE_HAS_LIST(member_type)) {`
`960`	`960`	`zend_type *list_type;`
`961`		`- if (ZEND_TYPE_IS_INTERSECTION(type)) {`
	`961`	`+ if (ZEND_TYPE_IS_INTERSECTION(member_type)) {`
`962`	`962`	`return zend_check_intersection_for_property_or_class_constant_class_type(`
`963`		`- ZEND_TYPE_LIST(type), class_ce, object_ce);`
	`963`	`+ scope, ZEND_TYPE_LIST(member_type), value_ce);`
`964`	`964`	`} else {`
`965`		`- ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), list_type) {`
	`965`	`+ ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(member_type), list_type) {`
`966`	`966`	`if (ZEND_TYPE_IS_INTERSECTION(*list_type)) {`
`967`	`967`	`if (zend_check_intersection_for_property_or_class_constant_class_type(`
`968`		`- ZEND_TYPE_LIST(*list_type), class_ce, object_ce)) {`
	`968`	`+ scope, ZEND_TYPE_LIST(*list_type), value_ce)) {`
`969`	`969`	`return true;`
`970`	`970`	`}`
`971`	`971`	`continue;`
`972`	`972`	`}`
`973`	`973`	`ZEND_ASSERT(!ZEND_TYPE_HAS_LIST(*list_type));`
`974`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, list_type);`
`975`		`- if (ce && instanceof_function(object_ce, ce)) {`
	`974`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, list_type);`
	`975`	`+ if (ce && instanceof_function(value_ce, ce)) {`
`976`	`976`	`return true;`
`977`	`977`	`}`
`978`	`978`	`} ZEND_TYPE_LIST_FOREACH_END();`
`979`	`979`	`return false;`
`980`	`980`	`}`
`981`		`- } else if ((ZEND_TYPE_PURE_MASK(type) & MAY_BE_STATIC)) {`
`982`		`- return instanceof_function(object_ce, class_ce);`
	`981`	`+ } else if ((ZEND_TYPE_PURE_MASK(member_type) & MAY_BE_STATIC)) {`
	`982`	`+ return instanceof_function(value_ce, scope);`
`983`	`983`	`} else {`
`984`		`- const zend_class_entry *ce = zend_ce_from_type(class_ce, &type);`
`985`		`- return ce && instanceof_function(object_ce, ce);`
	`984`	`+ const zend_class_entry *ce = zend_ce_from_type(scope, &member_type);`
	`985`	`+ return ce && instanceof_function(value_ce, ce);`
`986`	`986`	`}`
`987`	`987`	`}`
`988`	`988`
`@@ -994,7 +994,7 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in`
`994`	`994`	`}`
`995`	`995`
`996`	`996`	`if (ZEND_TYPE_IS_COMPLEX(info->type) && Z_TYPE_P(property) == IS_OBJECT`
`997`		`- && zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(property))) {`
	`997`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(property))) {`
`998`	`998`	`return 1;`
`999`	`999`	`}`
`1000`	`1000`
`@@ -1482,13 +1482,13 @@ static zend_always_inline bool zend_check_class_constant_type(zend_class_constan`
`1482`	`1482`	`}`
`1483`	`1483`
`1484`	`1484`	`if (((ZEND_TYPE_PURE_MASK(c->type) & MAY_BE_STATIC) \|\| ZEND_TYPE_IS_COMPLEX(c->type)) && Z_TYPE_P(constant) == IS_OBJECT`
`1485`		`- && zend_check_and_resolve_property_or_class_constant_class_type(c->type, c->ce, Z_OBJCE_P(constant))) {`
	`1485`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(c->ce, c->type, Z_OBJCE_P(constant))) {`
`1486`	`1486`	`return 1;`
`1487`	`1487`	`}`
`1488`	`1488`
`1489`	`1489`	`uint32_t type_mask = ZEND_TYPE_FULL_MASK(c->type);`
`1490`	`1490`	`ZEND_ASSERT(!(type_mask & (MAY_BE_CALLABLE\|MAY_BE_NEVER\|MAY_BE_VOID)));`
`1491`		`- return zend_verify_scalar_type_hint(type_mask, constant, 1, 0);`
	`1491`	`+ return zend_verify_scalar_type_hint(type_mask, constant, true, false);`
`1492`	`1492`	`}`
`1493`	`1493`
`1494`	`1494`	`ZEND_API bool zend_never_inline zend_verify_class_constant_type(zend_class_constant c, zval constant)`
`@@ -3518,7 +3518,7 @@ static zend_always_inline int i_zend_verify_type_assignable_zval(`
`3518`	`3518`	`}`
`3519`	`3519`
`3520`	`3520`	`if (ZEND_TYPE_IS_COMPLEX(type) && zv_type == IS_OBJECT`
`3521`		`- && zend_check_and_resolve_property_or_class_constant_class_type(info->type, info->ce, Z_OBJCE_P(zv))) {`
	`3521`	`+ && zend_check_and_resolve_property_or_class_constant_class_type(info->ce, info->type, Z_OBJCE_P(zv))) {`
`3522`	`3522`	`return 1;`
`3523`	`3523`	`}`
`3524`	`3524`
Original file line number	Diff line number	Diff line change
`@@ -5955,7 +5955,7 @@ ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR\|CONST\|UNUSED\|CLASS_FETCH, CO`
`5955`	`5955`	`}`
`5956`	`5956`	`}`
`5957`	`5957`	`if (Z_TYPE_P(value) == IS_CONSTANT_AST) {`
`5958`		`- if (UNEXPECTED(zend_update_class_constant(c, value, c->ce) != SUCCESS)) {`
	`5958`	`+ if (UNEXPECTED(zend_update_class_constant(c, c->ce) != SUCCESS)) {`
`5959`	`5959`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`5960`	`5960`	`FREE_OP2();`
`5961`	`5961`	`HANDLE_EXCEPTION();`