Use zend_zval_type_name() API where possible

Rather than zend_get_type_by_const(Z_TYPE_P()).

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 8e620b277915ee44edcf25b5cccf93a770ee9870..58c74e1da08e95f93a6be5cca9ae6bd15ba82ddc 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -6417,7 +6417,7 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags) /
                                } else {
                                        zend_error_noreturn(E_COMPILE_ERROR,
                                                "Cannot use %s as default value for property %s::$%s of type %s",
-                                               zend_get_type_by_const(Z_TYPE(value_zv)),
+                                               zend_zval_type_name(&value_zv),
                                                ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(str));
                                }
                        }
@@ -8320,7 +8320,7 @@ void zend_compile_class_name(znode *result, zend_ast *ast) /* {{{ */
                        /* Unlikely case that happen if class_ast is constant folded.
                         * Handle it here, to avoid needing a CONST specialization in the VM. */
                        zend_error_noreturn(E_COMPILE_ERROR, "Cannot use ::class on value of type %s",
-                               zend_get_type_by_const(Z_TYPE(expr_node.u.constant)));
+                               zend_zval_type_name(&expr_node.u.constant));
                }
 
                zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, &expr_node, NULL);

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 99e429f39be17d330786f1a79cfd65f750981f8f..35e3691a4c8e3e762ca3ca1751990822d6595395 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -844,7 +844,7 @@ ZEND_COLD zend_never_inline void zend_verify_property_type_error(zend_property_i
 
        type_str = zend_type_to_string(info->type);
        zend_type_error("Cannot assign %s to property %s::$%s of type %s",
-               Z_TYPE_P(property) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(property)->name) : zend_get_type_by_const(Z_TYPE_P(property)),
+               Z_TYPE_P(property) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(property)->name) : zend_zval_type_name(property),
                ZSTR_VAL(info->ce->name),
                zend_get_unmangled_property_name(info->name),
                ZSTR_VAL(type_str));
@@ -1915,7 +1915,8 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_undefined_method(cons
 
 static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_invalid_method_call(zval *object, zval *function_name)
 {
-       zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
+       zend_throw_error(NULL, "Call to a member function %s() on %s",
+               Z_STRVAL_P(function_name), zend_zval_type_name(object));
 }
 
 static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_non_static_method_call(const zend_function *fbc)
@@ -2556,8 +2557,7 @@ static ZEND_COLD void ZEND_FASTCALL zend_array_key_exists_error(
        }
        if (!EG(exception)) {
                zend_type_error("array_key_exists(): Argument #2 ($array) must be of type array, %s given",
-                       zend_get_type_by_const(Z_TYPE_P(subject))
-               );
+                       zend_zval_type_name(subject));
        }
 }
 
@@ -2943,7 +2943,7 @@ ZEND_API ZEND_COLD void zend_throw_ref_type_error_type(zend_property_info *prop1
        zend_string *type1_str = zend_type_to_string(prop1->type);
        zend_string *type2_str = zend_type_to_string(prop2->type);
        zend_type_error("Reference with value of type %s held by property %s::$%s of type %s is not compatible with property %s::$%s of type %s",
-               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_zval_type_name(zv),
                ZSTR_VAL(prop1->ce->name),
                zend_get_unmangled_property_name(prop1->name),
                ZSTR_VAL(type1_str),
@@ -2958,7 +2958,7 @@ ZEND_API ZEND_COLD void zend_throw_ref_type_error_type(zend_property_info *prop1
 ZEND_API ZEND_COLD void zend_throw_ref_type_error_zval(zend_property_info *prop, zval *zv) {
        zend_string *type_str = zend_type_to_string(prop->type);
        zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s",
-               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_zval_type_name(zv),
                ZSTR_VAL(prop->ce->name),
                zend_get_unmangled_property_name(prop->name),
                ZSTR_VAL(type_str)
@@ -2970,7 +2970,7 @@ ZEND_API ZEND_COLD void zend_throw_conflicting_coercion_error(zend_property_info
        zend_string *type1_str = zend_type_to_string(prop1->type);
        zend_string *type2_str = zend_type_to_string(prop2->type);
        zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s and property %s::$%s of type %s, as this would result in an inconsistent type conversion",
-               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_zval_type_name(zv),
                ZSTR_VAL(prop1->ce->name),
                zend_get_unmangled_property_name(prop1->name),
                ZSTR_VAL(type1_str),

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 53cc6e45eafe40fb35b04ccf030333cc1f1ec474..c8360fbf395109ce67cd580a6aa696d74aae1792 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -936,7 +936,7 @@ static ZEND_COLD zend_never_inline void ZEND_FASTCALL zend_binop_error(const cha
        }
 
        zend_type_error("Unsupported operand types: %s %s %s",
-               zend_get_type_by_const(Z_TYPE_P(op1)), operator, zend_get_type_by_const(Z_TYPE_P(op2)));
+               zend_zval_type_name(op1), operator, zend_zval_type_name(op2));
 }
 /* }}} */
 
@@ -1468,8 +1468,7 @@ try_again:
                        if (result != op1) {
                                ZVAL_UNDEF(result);
                        }
-                       zend_type_error("Cannot perform bitwise not on %s",
-                               zend_get_type_by_const(Z_TYPE_P(op1)));
+                       zend_type_error("Cannot perform bitwise not on %s", zend_zval_type_name(op1));
                        return FAILURE;
        }
 }
@@ -2376,7 +2375,7 @@ try_again:
                        /* break missing intentionally */
                case IS_RESOURCE:
                case IS_ARRAY:
-                       zend_type_error("Cannot increment %s", zend_get_type_by_const(Z_TYPE_P(op1)));
+                       zend_type_error("Cannot increment %s", zend_zval_type_name(op1));
                        return FAILURE;
                EMPTY_SWITCH_DEFAULT_CASE()
        }
@@ -2438,7 +2437,7 @@ try_again:
                        /* break missing intentionally */
                case IS_RESOURCE:
                case IS_ARRAY:
-                       zend_type_error("Cannot decrement %s", zend_get_type_by_const(Z_TYPE_P(op1)));
+                       zend_type_error("Cannot decrement %s", zend_zval_type_name(op1));
                        return FAILURE;
                EMPTY_SWITCH_DEFAULT_CASE()
        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 5be0f1156de3b4af5fe29e127135e2a1517d833d..de0dfa2f357c3894e6536349b4ee7e9cee985f29 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -3695,7 +3695,7 @@ ZEND_VM_C_LABEL(try_function_name):
                        }
                }
                zend_throw_error(NULL, "Value of type %s is not callable",
-                       zend_get_type_by_const(Z_TYPE_P(function_name)));
+                       zend_zval_type_name(function_name));
                call = NULL;
        }
 
@@ -4934,7 +4934,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM)
                                ZEND_VM_C_GOTO(send_array);
                        }
                }
-               zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+               zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_type_name(args));
                FREE_UNFETCHED_OP2();
                FREE_OP1();
                HANDLE_EXCEPTION();
@@ -6188,7 +6188,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET_R, CONST|TMP|VAR|CV, JMP_ADDR)
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                FREE_OP1();
@@ -6277,7 +6277,7 @@ ZEND_VM_COLD_CONST_HANDLER(125, ZEND_FE_RESET_RW, CONST|TMP|VAR|CV, JMP_ADDR)
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                if (OP1_TYPE == IS_VAR) {
@@ -6587,7 +6587,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR)
                        value_type = Z_TYPE_INFO_P(value);
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array));
                if (UNEXPECTED(EG(exception))) {
                        UNDEF_RESULT();
                        HANDLE_EXCEPTION();
@@ -7917,7 +7917,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
                                zval_ptr_dtor(&tmp);
                        }
                        if (!EG(exception)) {
-                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_zval_type_name(value));
                        }
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                } while (0);
@@ -8012,8 +8012,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY)
                if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
                        ZVAL_DEREF(op);
                        if (Z_TYPE_P(op) != IS_OBJECT) {
-                               zend_type_error("Cannot use ::class on value of type %s",
-                                       zend_get_type_by_const(Z_TYPE_P(op)));
+                               zend_type_error("Cannot use ::class on value of type %s", zend_zval_type_name(op));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                                FREE_OP1();
                                HANDLE_EXCEPTION();
@@ -8525,7 +8524,7 @@ ZEND_VM_COLD_CONST_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMPVAR|CV, UNUSED)
                                if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
                                        ZVAL_UNDEFINED_OP1();
                                }
-                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_type_name(op1));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                        }
                        break;

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 4b54565719b9efbdb91bf1e250797e534580a658..0bf16a6fee8125cd189c6be3cb056a4be06b3ce8 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1977,7 +1977,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O
                                goto send_array;
                        }
                }
-               zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+               zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_type_name(args));
                FREE_UNFETCHED_OP(opline->op2_type, opline->op2.var);
                FREE_OP(opline->op1_type, opline->op1.var);
                HANDLE_EXCEPTION();
@@ -2900,7 +2900,7 @@ try_function_name:
                        }
                }
                zend_throw_error(NULL, "Value of type %s is not callable",
-                       zend_get_type_by_const(Z_TYPE_P(function_name)));
+                       zend_zval_type_name(function_name));
                call = NULL;
        }
 
@@ -3067,7 +3067,7 @@ try_function_name:
                        }
                }
                zend_throw_error(NULL, "Value of type %s is not callable",
-                       zend_get_type_by_const(Z_TYPE_P(function_name)));
+                       zend_zval_type_name(function_name));
                call = NULL;
        }
 
@@ -3185,7 +3185,7 @@ try_function_name:
                        }
                }
                zend_throw_error(NULL, "Value of type %s is not callable",
-                       zend_get_type_by_const(Z_TYPE_P(function_name)));
+                       zend_zval_type_name(function_name));
                call = NULL;
        }
 
@@ -4096,7 +4096,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
 
@@ -4184,7 +4184,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                if (IS_CONST == IS_VAR) {
@@ -4473,7 +4473,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST
                                zval_ptr_dtor(&tmp);
                        }
                        if (!EG(exception)) {
-                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_zval_type_name(value));
                        }
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                } while (0);
@@ -9342,7 +9342,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CO
                                if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
                                        ZVAL_UNDEFINED_OP1();
                                }
-                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_type_name(op1));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                        }
                        break;
@@ -13314,7 +13314,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN
                                zval_ptr_dtor(&tmp);
                        }
                        if (!EG(exception)) {
-                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_zval_type_name(value));
                        }
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                } while (0);
@@ -13371,8 +13371,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_H
                if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
                        ZVAL_DEREF(op);
                        if (Z_TYPE_P(op) != IS_OBJECT) {
-                               zend_type_error("Cannot use ::class on value of type %s",
-                                       zend_get_type_by_const(Z_TYPE_P(op)));
+                               zend_type_error("Cannot use ::class on value of type %s", zend_zval_type_name(op));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                                zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
                                HANDLE_EXCEPTION();
@@ -16421,7 +16420,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_H
                                if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
                                        ZVAL_UNDEFINED_OP1();
                                }
-                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_type_name(op1));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                        }
                        break;
@@ -17694,7 +17693,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZE
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
@@ -17782,7 +17781,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(Z
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                if (IS_TMP_VAR == IS_VAR) {
@@ -20354,7 +20353,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZE
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
@@ -20443,7 +20442,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(Z
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                if (IS_VAR == IS_VAR) {
@@ -20753,7 +20752,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z
                        value_type = Z_TYPE_INFO_P(value);
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array));
                if (UNEXPECTED(EG(exception))) {
                        UNDEF_RESULT();
                        HANDLE_EXCEPTION();
@@ -29111,8 +29110,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H
                if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
                        ZVAL_DEREF(op);
                        if (Z_TYPE_P(op) != IS_OBJECT) {
-                               zend_type_error("Cannot use ::class on value of type %s",
-                                       zend_get_type_by_const(Z_TYPE_P(op)));
+                               zend_type_error("Cannot use ::class on value of type %s", zend_zval_type_name(op));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
 
                                HANDLE_EXCEPTION();
@@ -33317,7 +33315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_H
                                if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
                                        ZVAL_UNDEFINED_OP1();
                                }
-                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_type_name(op1));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                        }
                        break;
@@ -36343,7 +36341,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEN
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
 
@@ -36431,7 +36429,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZE
                        }
                }
        } else {
-               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_get_type_by_const(Z_TYPE_P(array_ptr)));
+               zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_type_name(array_ptr));
                ZVAL_UNDEF(EX_VAR(opline->result.var));
                Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
                if (IS_CV == IS_VAR) {
@@ -36711,7 +36709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP
                                zval_ptr_dtor(&tmp);
                        }
                        if (!EG(exception)) {
-                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+                               zend_type_error("strlen(): Argument #1 ($str) must be of type string, %s given", zend_zval_type_name(value));
                        }
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                } while (0);
@@ -36768,8 +36766,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDL
                if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
                        ZVAL_DEREF(op);
                        if (Z_TYPE_P(op) != IS_OBJECT) {
-                               zend_type_error("Cannot use ::class on value of type %s",
-                                       zend_get_type_by_const(Z_TYPE_P(op)));
+                               zend_type_error("Cannot use ::class on value of type %s", zend_zval_type_name(op));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
 
                                HANDLE_EXCEPTION();
@@ -45268,7 +45265,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDL
                                if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
                                        ZVAL_UNDEFINED_OP1();
                                }
-                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+                               zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_type_name(op1));
                                ZVAL_UNDEF(EX_VAR(opline->result.var));
                        }
                        break;

diff --git a/ext/ffi/ffi.c b/ext/ffi/ffi.c
index 2d3369476458fc175a185bb139ebd52c6f519053..e4ea0099c1492d1dec48b04da5b877c07c74e059 100644 (file)
--- a/ext/ffi/ffi.c
+++ b/ext/ffi/ffi.c
@@ -1567,7 +1567,7 @@ static ZEND_COLD void zend_ffi_pass_incompatible(zval *arg, zend_ffi_type *type,
                                zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s', found '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start, buf2.start);
                        }
                } else {
-                       zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s', found PHP '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start, zend_get_type_by_const(Z_TYPE_P(arg)));
+                       zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s', found PHP '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start, zend_zval_type_name(arg));
                }
        }
 }
@@ -1594,7 +1594,7 @@ static ZEND_COLD void zend_ffi_assign_incompatible(zval *arg, zend_ffi_type *typ
                                zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s' from type '%s'", buf1.start, buf2.start);
                        }
                } else {
-                       zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s' from PHP '%s'", buf1.start, zend_get_type_by_const(Z_TYPE_P(arg)));
+                       zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s' from PHP '%s'", buf1.start, zend_zval_type_name(arg));
                }
        }
 }

diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c
index b9458405acb9b8a3fc99ac6f4ef911e8c4528c60..fb650e3a745005da4708709d8d5383270e694c3c 100644 (file)
--- a/ext/standard/proc_open.c
+++ b/ext/standard/proc_open.c
@@ -740,7 +740,7 @@ int set_proc_descriptor_from_array(
                        goto finish;
                }
                if (Z_TYPE_P(ztarget) != IS_LONG) {
-                       zend_value_error("Redirection target must be of type int, %s given", zend_get_type_by_const(Z_TYPE_P(ztarget)));
+                       zend_value_error("Redirection target must be of type int, %s given", zend_zval_type_name(ztarget));
                        goto finish;
                }
 

diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c
index cb7524e0f9e6e7fbedb714a308d9c9d44d0d14bc..ae65ba439624bf4a92b5cef0f47533dbccaf2d12 100644 (file)
--- a/ext/zlib/zlib.c
+++ b/ext/zlib/zlib.c
@@ -818,7 +818,7 @@ static zend_bool zlib_create_dictionary_string(HashTable *options, char **dict,
                        } break;
 
                        default:
-                               zend_argument_type_error(2, "must be of type zero-terminated string or array, %s given", zend_get_type_by_const(Z_TYPE_P(option_buffer)));
+                               zend_argument_type_error(2, "must be of type zero-terminated string or array, %s given", zend_zval_type_name(option_buffer));
                                return 0;
                }
        }