Change argument error message format

kocsismate · kocsismate · commit 0bdde04da965 · 2020-02-26T00:51:04.000+01:00
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
@@ -216,7 +216,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(int num, z
 		return;
 	}
 
-	zend_argument_type_error(num, "to be %s, %s given", expected_error[expected_type], zend_zval_type_name(arg));
+	zend_argument_type_error(num, "must be %s, %s given", expected_error[expected_type], zend_zval_type_name(arg));
 }
 /* }}} */
 
@@ -226,7 +226,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_error(int num,
 		return;
 	}
 
-	zend_argument_type_error(num, "to be of type %s, %s given", name, zend_zval_type_name(arg));
+	zend_argument_type_error(num, "must be of type %s, %s given", name, zend_zval_type_name(arg));
 }
 /* }}} */
 
@@ -236,7 +236,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(int num, char *e
 		return;
 	}
 
-	zend_argument_type_error(num, "to be a valid callback, %s", error);
+	zend_argument_type_error(num, "must be a valid callback, %s", error);
 	efree(error);
 }
 /* }}} */
@@ -259,9 +259,9 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error(zend_class_entry *erro
 	zend_vspprintf(&message, 0, format, va);
 	va_end(va);
 
-	zend_throw_error(error_ce, "%s%s%s() expects argument #%d%s%s%s %s",
-		class_name, space, get_active_function_name(), arg_num,
-		arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "", message
+	zend_throw_error(error_ce, "Argument #%d%s%s%s passed to %s%s%s() %s",
+		arg_num, arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "",
+		class_name, space, get_active_function_name(), message
     );
 	efree(message);
 }
@@ -283,13 +283,13 @@ ZEND_API int ZEND_FASTCALL zend_parse_arg_class(zval *arg, zend_class_entry **pc
 	*pce = zend_lookup_class(Z_STR_P(arg));
 	if (ce_base) {
 		if ((!*pce || !instanceof_function(*pce, ce_base))) {
-			zend_argument_type_error(num, "to be a class name derived from %s, '%s' given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));
+			zend_argument_type_error(num, "must be a class name derived from %s, '%s' given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));
 			*pce = NULL;
 			return 0;
 		}
 	}
 	if (!*pce) {
-		zend_argument_type_error(num, "to be a valid class name, '%s' given", Z_STRVAL_P(arg));
+		zend_argument_type_error(num, "must be a valid class name, '%s' given", Z_STRVAL_P(arg));
 		return 0;
 	}
 	return 1;
@@ -745,10 +745,10 @@ static int zend_parse_arg(int arg_num, zval *arg, va_list *va, const char **spec
 		}
 		if (!(flags & ZEND_PARSE_PARAMS_QUIET) && (*expected_type || error)) {
 			if (error) {
-				zend_argument_type_error(arg_num, "to be %s", error);
+				zend_argument_type_error(arg_num, "must be %s", error);
 				efree(error);
 			} else {
-				zend_argument_type_error(arg_num, "to be of type %s, %s given", expected_type, zend_zval_type_name(arg));
+				zend_argument_type_error(arg_num, "must be of type %s, %s given", expected_type, zend_zval_type_name(arg));
 			}
 		} else if (error) {
 			efree(error);
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
@@ -1388,7 +1388,7 @@ ZEND_FUNCTION(set_error_handler)
 	if (Z_TYPE_P(error_handler) != IS_NULL) { /* NULL == unset */
 		if (!zend_is_callable(error_handler, 0, NULL)) {
 			zend_string *error_handler_name = zend_get_callable_name(error_handler);
-			zend_error(E_WARNING, "%s() expects argument #1 ($error_handler) to be a valid callback", get_active_function_name());
+			zend_error(E_WARNING, "Argument #1 ($error_handler) passed to %s() must be a valid callback", get_active_function_name());
 			zend_string_release_ex(error_handler_name, 0);
 			return;
 		}
@@ -1452,7 +1452,7 @@ ZEND_FUNCTION(set_exception_handler)
 	if (Z_TYPE_P(exception_handler) != IS_NULL) { /* NULL == unset */
 		if (!zend_is_callable(exception_handler, 0, NULL)) {
 		zend_string *exception_handler_name = zend_get_callable_name(exception_handler);
-			zend_error(E_WARNING, "%s() expects argument #1 ($exception_handler) to be a valid callback", get_active_function_name());
+			zend_error(E_WARNING, "Argument #1 ($exception_handler) passed to %s() must be a valid callback", get_active_function_name());
 			zend_string_release_ex(exception_handler_name, 0);
 			return;
 		}
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
@@ -692,16 +692,20 @@ ZEND_API ZEND_COLD void zend_verify_arg_error(
 
 		if (zf->common.type == ZEND_USER_FUNCTION) {
 			if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) {
-				zend_type_error("%s%s%s() expects argument #%d ($%s) to be of type %s, %s given, called in %s on line %d",
-						fclass, fsep, fname, arg_num, ZSTR_VAL(arg_info->name), ZSTR_VAL(need_msg), given_msg,
-						ZSTR_VAL(ptr->func->op_array.filename), ptr->opline->lineno);
+				zend_type_error("Argument #%d ($%s) passed to %s%s%s() must be of type %s, %s given, called in %s on line %d",
+					arg_num, ZSTR_VAL(arg_info->name),
+					fclass, fsep, fname, ZSTR_VAL(need_msg), given_msg,
+					ZSTR_VAL(ptr->func->op_array.filename), ptr->opline->lineno
+				);
 			} else {
-				zend_type_error("%s%s%s() expects argument #%d ($%s) to be of type %s, %s given",
-					fclass, fsep, fname, arg_num, ZSTR_VAL(arg_info->name), ZSTR_VAL(need_msg), given_msg);
+				zend_type_error("Argument #%d ($%s) passed to %s%s%s() must be of type %s, %s given",
+					arg_num, ZSTR_VAL(arg_info->name), fclass, fsep, fname, ZSTR_VAL(need_msg), given_msg
+				);
 			}
 		} else {
-			zend_type_error("%s%s%s() expects argument #%d ($%s) to be of type %s, %s given",
-				fclass, fsep, fname, arg_num, ((zend_internal_arg_info*) arg_info)->name, ZSTR_VAL(need_msg), given_msg);
+			zend_type_error("Argument #%d ($%s) passed to %s%s%s() must be of type %s, %s given",
+				arg_num, ((zend_internal_arg_info*) arg_info)->name, fclass, fsep, fname, ZSTR_VAL(need_msg), given_msg
+			);
 		}
 
 		zend_string_release(need_msg);
@@ -1925,14 +1929,14 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_param_must_be_ref(con
 {
 	const char *arg_name = get_function_arg_name(func, arg_num);
 
-	zend_error(E_WARNING, "%s%s%s() expects argument #%d%s%s%s to be passed by reference, value given",
-		func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
-		func->common.scope ? "::" : "",
-		ZSTR_VAL(func->common.function_name),
+	zend_error(E_WARNING, "Argument #%d%s%s%s passed to %s%s%s() must be a reference, value given",
 		arg_num,
 		arg_name ? " ($" : "",
 		arg_name ? arg_name : "",
-		arg_name ? ")" : ""
+		arg_name ? ")" : "",
+		func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
+		func->common.scope ? "::" : "",
+		ZSTR_VAL(func->common.function_name)
 	);
 }
 
@@ -2550,8 +2554,9 @@ static ZEND_COLD void ZEND_FASTCALL zend_array_key_exists_error(
 		ZVAL_UNDEFINED_OP2();
 	}
 	if (!EG(exception)) {
-		zend_type_error("array_key_exists() expects argument #2 ($array) to be of type array, %s given",
-			zend_get_type_by_const(Z_TYPE_P(subject)));
+		zend_type_error("Argument #2 ($array) passed to array_key_exists() must be of type array, %s given",
+			zend_get_type_by_const(Z_TYPE_P(subject))
+		);
 	}
 }
 
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
@@ -751,14 +751,14 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /
 					const char *arg_name = get_function_arg_name(func, i + 1);
 
 					zend_error(E_WARNING,
-						"%s%s%s() expects argument #%d%s%s%s to be passed by reference, value given",
-						func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
-						func->common.scope ? "::" : "",
-						ZSTR_VAL(func->common.function_name),
+						"Argument #%d%s%s%s passed to %s%s%s() must be a reference, value given",
 						i+1,
 						arg_name ? " ($" : "",
 						arg_name ? arg_name : "",
-						arg_name ? ")" : ""
+						arg_name ? ")" : "",
+						func->common.scope ? ZSTR_VAL(func->common.scope->name) : "",
+						func->common.scope ? "::" : "",
+						ZSTR_VAL(func->common.function_name)
 					);
 					if (UNEXPECTED(EG(exception))) {
 						ZEND_CALL_NUM_ARGS(call) = i;
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -3775,7 +3775,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM)
 			init_func_run_time_cache(&func->op_array);
 		}
 	} else {
-		zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
+		zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
 		efree(error);
 		FREE_OP2();
 		HANDLE_EXCEPTION();
@@ -4938,7 +4938,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM)
 				ZEND_VM_C_GOTO(send_array);
 			}
 		}
-		zend_type_error("call_user_func_array() expects argument #2 ($args) to be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+		zend_type_error("Argument #2 ($args) passed to call_user_func_array() must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
 		FREE_UNFETCHED_OP2();
 		FREE_OP1();
 		HANDLE_EXCEPTION();
@@ -7909,7 +7909,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY)
 				zval_ptr_dtor(&tmp);
 			}
 			if (!EG(exception)) {
-				zend_type_error("strlen() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+				zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
 			}
 			ZVAL_UNDEF(EX_VAR(opline->result.var));
 		} while (0);
@@ -8517,7 +8517,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() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+				zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 				ZVAL_UNDEF(EX_VAR(opline->result.var));
 			}
 			break;
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
@@ -1981,7 +1981,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() expects argument #2 ($args) to be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
+		zend_type_error("Argument #2 ($args) passed to call_user_func_array() must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));
 		FREE_UNFETCHED_OP(opline->op2_type, opline->op2.var);
 		FREE_OP(opline->op1_type, opline->op1.var);
 		HANDLE_EXCEPTION();
@@ -4464,7 +4464,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() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+				zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
 			}
 			ZVAL_UNDEF(EX_VAR(opline->result.var));
 		} while (0);
@@ -5889,7 +5889,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS
 			init_func_run_time_cache(&func->op_array);
 		}
 	} else {
-		zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
+		zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
 		efree(error);
 
 		HANDLE_EXCEPTION();
@@ -8065,7 +8065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV
 			init_func_run_time_cache(&func->op_array);
 		}
 	} else {
-		zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
+		zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
 		efree(error);
 		zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 		HANDLE_EXCEPTION();
@@ -9333,7 +9333,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() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+				zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 				ZVAL_UNDEF(EX_VAR(opline->result.var));
 			}
 			break;
@@ -10320,7 +10320,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H
 			init_func_run_time_cache(&func->op_array);
 		}
 	} else {
-		zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
+		zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
 		efree(error);
 
 		HANDLE_EXCEPTION();
@@ -13305,7 +13305,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() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+				zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
 			}
 			ZVAL_UNDEF(EX_VAR(opline->result.var));
 		} while (0);
@@ -16412,7 +16412,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() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+				zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 				ZVAL_UNDEF(EX_VAR(opline->result.var));
 			}
 			break;
@@ -33308,7 +33308,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() expects argument 1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+				zend_type_error("Argument 1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 				ZVAL_UNDEF(EX_VAR(opline->result.var));
 			}
 			break;
@@ -36702,7 +36702,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() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
+				zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));
 			}
 			ZVAL_UNDEF(EX_VAR(opline->result.var));
 		} while (0);
@@ -45260,7 +45260,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() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
+				zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 				ZVAL_UNDEF(EX_VAR(opline->result.var));
 			}
 			break;
diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c
@@ -353,7 +353,7 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */
 				option = PHP_STREAM_META_GROUP_NAME;
 				value = Z_STRVAL_P(group);
 			} else {
-				zend_type_error("chgrp() expects argument #2 ($group) to be of type string|int, %s given", zend_zval_type_name(group));
+				zend_type_error("Argument #2 ($group) passed to chgrp() must be of type string|int, %s given", zend_zval_type_name(group));
 				RETURN_THROWS();
 			}
 			if(wrapper->wops->stream_metadata(wrapper, filename, option, value, NULL)) {
@@ -382,7 +382,7 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */
 			RETURN_FALSE;
 		}
 	} else {
-		zend_type_error("chgrp() expects argument #2 ($group) to be of type string|int, %s given", zend_zval_type_name(group));
+		zend_type_error("Argument #2 ($group) passed to chgrp() must be of type string|int, %s given", zend_zval_type_name(group));
 		RETURN_THROWS();
 	}
 
diff --git a/ext/standard/string.c b/ext/standard/string.c
@@ -1276,15 +1276,15 @@ PHP_FUNCTION(implode)
 
 	if (pieces == NULL) {
 		if (arg1_array == NULL) {
-			zend_type_error("%s() expects argument #1 ($pieces) to be of type array, string given", get_active_function_name());
+			zend_type_error("Argument #1 ($pieces) passed to %s() must be of type array, string given", get_active_function_name());
 			RETURN_THROWS();
 		}
 
 		arg1_str = ZSTR_EMPTY_ALLOC();
 		pieces = arg1_array;
 	} else {
 		if (arg1_str == NULL) {
-			zend_type_error("%s() expects argument #1 ($glue) to be of type string, array given", get_active_function_name());
+			zend_type_error("Argument #1 ($glue) passed to %s() must be of type string, array given", get_active_function_name());
 			RETURN_THROWS();
 		}
 	}

Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(int num, z`
`216`	`216`	`return;`
`217`	`217`	`}`
`218`	`218`
`219`		`- zend_argument_type_error(num, "to be %s, %s given", expected_error[expected_type], zend_zval_type_name(arg));`
	`219`	`+ zend_argument_type_error(num, "must be %s, %s given", expected_error[expected_type], zend_zval_type_name(arg));`
`220`	`220`	`}`
`221`	`221`	`/* }}} */`
`222`	`222`
`@@ -226,7 +226,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_error(int num,`
`226`	`226`	`return;`
`227`	`227`	`}`
`228`	`228`
`229`		`- zend_argument_type_error(num, "to be of type %s, %s given", name, zend_zval_type_name(arg));`
	`229`	`+ zend_argument_type_error(num, "must be of type %s, %s given", name, zend_zval_type_name(arg));`
`230`	`230`	`}`
`231`	`231`	`/* }}} */`
`232`	`232`
`@@ -236,7 +236,7 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(int num, char *e`
`236`	`236`	`return;`
`237`	`237`	`}`
`238`	`238`
`239`		`- zend_argument_type_error(num, "to be a valid callback, %s", error);`
	`239`	`+ zend_argument_type_error(num, "must be a valid callback, %s", error);`
`240`	`240`	`efree(error);`
`241`	`241`	`}`
`242`	`242`	`/* }}} */`
`@@ -259,9 +259,9 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error(zend_class_entry *erro`
`259`	`259`	`zend_vspprintf(&message, 0, format, va);`
`260`	`260`	`va_end(va);`
`261`	`261`
`262`		`- zend_throw_error(error_ce, "%s%s%s() expects argument #%d%s%s%s %s",`
`263`		`- class_name, space, get_active_function_name(), arg_num,`
`264`		`- arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "", message`
	`262`	`+ zend_throw_error(error_ce, "Argument #%d%s%s%s passed to %s%s%s() %s",`
	`263`	`+ arg_num, arg_name ? " ($" : "", arg_name ? arg_name : "", arg_name ? ")" : "",`
	`264`	`+ class_name, space, get_active_function_name(), message`
`265`	`265`	`);`
`266`	`266`	`efree(message);`
`267`	`267`	`}`
`@@ -283,13 +283,13 @@ ZEND_API int ZEND_FASTCALL zend_parse_arg_class(zval arg, zend_class_entry *pc`
`283`	`283`	`*pce = zend_lookup_class(Z_STR_P(arg));`
`284`	`284`	`if (ce_base) {`
`285`	`285`	`if ((!pce \|\| !instanceof_function(pce, ce_base))) {`
`286`		`- zend_argument_type_error(num, "to be a class name derived from %s, '%s' given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));`
	`286`	`+ zend_argument_type_error(num, "must be a class name derived from %s, '%s' given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));`
`287`	`287`	`*pce = NULL;`
`288`	`288`	`return 0;`
`289`	`289`	`}`
`290`	`290`	`}`
`291`	`291`	`if (!*pce) {`
`292`		`- zend_argument_type_error(num, "to be a valid class name, '%s' given", Z_STRVAL_P(arg));`
	`292`	`+ zend_argument_type_error(num, "must be a valid class name, '%s' given", Z_STRVAL_P(arg));`
`293`	`293`	`return 0;`
`294`	`294`	`}`
`295`	`295`	`return 1;`
`@@ -745,10 +745,10 @@ static int zend_parse_arg(int arg_num, zval arg, va_list va, const char **spec`
`745`	`745`	`}`
`746`	`746`	`if (!(flags & ZEND_PARSE_PARAMS_QUIET) && (*expected_type \|\| error)) {`
`747`	`747`	`if (error) {`
`748`		`- zend_argument_type_error(arg_num, "to be %s", error);`
	`748`	`+ zend_argument_type_error(arg_num, "must be %s", error);`
`749`	`749`	`efree(error);`
`750`	`750`	`} else {`
`751`		`- zend_argument_type_error(arg_num, "to be of type %s, %s given", expected_type, zend_zval_type_name(arg));`
	`751`	`+ zend_argument_type_error(arg_num, "must be of type %s, %s given", expected_type, zend_zval_type_name(arg));`
`752`	`752`	`}`
`753`	`753`	`} else if (error) {`
`754`	`754`	`efree(error);`
Original file line number	Diff line number	Diff line change
`@@ -3775,7 +3775,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST\|TMPVAR\|CV, NUM)`
`3775`	`3775`	`init_func_run_time_cache(&func->op_array);`
`3776`	`3776`	`}`
`3777`	`3777`	`} else {`
`3778`		`- zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
	`3778`	`+ zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
`3779`	`3779`	`efree(error);`
`3780`	`3780`	`FREE_OP2();`
`3781`	`3781`	`HANDLE_EXCEPTION();`
`@@ -4938,7 +4938,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY, NUM)`
`4938`	`4938`	`ZEND_VM_C_GOTO(send_array);`
`4939`	`4939`	`}`
`4940`	`4940`	`}`
`4941`		`- zend_type_error("call_user_func_array() expects argument #2 ($args) to be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));`
	`4941`	`+ zend_type_error("Argument #2 ($args) passed to call_user_func_array() must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));`
`4942`	`4942`	`FREE_UNFETCHED_OP2();`
`4943`	`4943`	`FREE_OP1();`
`4944`	`4944`	`HANDLE_EXCEPTION();`
`@@ -7909,7 +7909,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST\|TMPVAR\|CV, ANY)`
`7909`	`7909`	`zval_ptr_dtor(&tmp);`
`7910`	`7910`	`}`
`7911`	`7911`	`if (!EG(exception)) {`
`7912`		`- zend_type_error("strlen() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
	`7912`	`+ zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
`7913`	`7913`	`}`
`7914`	`7914`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`7915`	`7915`	`} while (0);`
`@@ -8517,7 +8517,7 @@ ZEND_VM_COLD_CONST_HANDLER(191, ZEND_GET_CLASS, UNUSED\|CONST\|TMPVAR\|CV, UNUSED)`
`8517`	`8517`	`if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`8518`	`8518`	`ZVAL_UNDEFINED_OP1();`
`8519`	`8519`	`}`
`8520`		`- zend_type_error("get_class() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
	`8520`	`+ zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
`8521`	`8521`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`8522`	`8522`	`}`
`8523`	`8523`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -1981,7 +1981,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O`
`1981`	`1981`	`goto send_array;`
`1982`	`1982`	`}`
`1983`	`1983`	`}`
`1984`		`- zend_type_error("call_user_func_array() expects argument #2 ($args) to be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));`
	`1984`	`+ zend_type_error("Argument #2 ($args) passed to call_user_func_array() must be of type array, %s given", zend_get_type_by_const(Z_TYPE_P(args)));`
`1985`	`1985`	`FREE_UNFETCHED_OP(opline->op2_type, opline->op2.var);`
`1986`	`1986`	`FREE_OP(opline->op1_type, opline->op1.var);`
`1987`	`1987`	`HANDLE_EXCEPTION();`
`@@ -4464,7 +4464,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST`
`4464`	`4464`	`zval_ptr_dtor(&tmp);`
`4465`	`4465`	`}`
`4466`	`4466`	`if (!EG(exception)) {`
`4467`		`- zend_type_error("strlen() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
	`4467`	`+ zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
`4468`	`4468`	`}`
`4469`	`4469`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`4470`	`4470`	`} while (0);`
`@@ -5889,7 +5889,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS`
`5889`	`5889`	`init_func_run_time_cache(&func->op_array);`
`5890`	`5890`	`}`
`5891`	`5891`	`} else {`
`5892`		`- zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
	`5892`	`+ zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
`5893`	`5893`	`efree(error);`
`5894`	`5894`
`5895`	`5895`	`HANDLE_EXCEPTION();`
`@@ -8065,7 +8065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV`
`8065`	`8065`	`init_func_run_time_cache(&func->op_array);`
`8066`	`8066`	`}`
`8067`	`8067`	`} else {`
`8068`		`- zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
	`8068`	`+ zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
`8069`	`8069`	`efree(error);`
`8070`	`8070`	`zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));`
`8071`	`8071`	`HANDLE_EXCEPTION();`
`@@ -9333,7 +9333,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CO`
`9333`	`9333`	`if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`9334`	`9334`	`ZVAL_UNDEFINED_OP1();`
`9335`	`9335`	`}`
`9336`		`- zend_type_error("get_class() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
	`9336`	`+ zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
`9337`	`9337`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`9338`	`9338`	`}`
`9339`	`9339`	`break;`
`@@ -10320,7 +10320,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H`
`10320`	`10320`	`init_func_run_time_cache(&func->op_array);`
`10321`	`10321`	`}`
`10322`	`10322`	`} else {`
`10323`		`- zend_type_error("%s() expects argument #1 ($function) to be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
	`10323`	`+ zend_type_error("Argument #1 ($function) passed to %s() must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);`
`10324`	`10324`	`efree(error);`
`10325`	`10325`
`10326`	`10326`	`HANDLE_EXCEPTION();`
`@@ -13305,7 +13305,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN`
`13305`	`13305`	`zval_ptr_dtor(&tmp);`
`13306`	`13306`	`}`
`13307`	`13307`	`if (!EG(exception)) {`
`13308`		`- zend_type_error("strlen() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
	`13308`	`+ zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
`13309`	`13309`	`}`
`13310`	`13310`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`13311`	`13311`	`} while (0);`
`@@ -16412,7 +16412,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_H`
`16412`	`16412`	`if ((IS_TMP_VAR\|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`16413`	`16413`	`ZVAL_UNDEFINED_OP1();`
`16414`	`16414`	`}`
`16415`		`- zend_type_error("get_class() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
	`16415`	`+ zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
`16416`	`16416`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`16417`	`16417`	`}`
`16418`	`16418`	`break;`
`@@ -33308,7 +33308,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_H`
`33308`	`33308`	`if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`33309`	`33309`	`ZVAL_UNDEFINED_OP1();`
`33310`	`33310`	`}`
`33311`		`- zend_type_error("get_class() expects argument 1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
	`33311`	`+ zend_type_error("Argument 1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
`33312`	`33312`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`33313`	`33313`	`}`
`33314`	`33314`	`break;`
`@@ -36702,7 +36702,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP`
`36702`	`36702`	`zval_ptr_dtor(&tmp);`
`36703`	`36703`	`}`
`36704`	`36704`	`if (!EG(exception)) {`
`36705`		`- zend_type_error("strlen() expects argument #1 ($str) to be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
	`36705`	`+ zend_type_error("Argument #1 ($str) passed to strlen() must be of type string, %s given", zend_get_type_by_const(Z_TYPE_P(value)));`
`36706`	`36706`	`}`
`36707`	`36707`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`36708`	`36708`	`} while (0);`
`@@ -45260,7 +45260,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDL`
`45260`	`45260`	`if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {`
`45261`	`45261`	`ZVAL_UNDEFINED_OP1();`
`45262`	`45262`	`}`
`45263`		`- zend_type_error("get_class() expects argument #1 ($object) to be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
	`45263`	`+ zend_type_error("Argument #1 ($object) passed to get_class() must be of type object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));`
`45264`	`45264`	`ZVAL_UNDEF(EX_VAR(opline->result.var));`
`45265`	`45265`	`}`
`45266`	`45266`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -353,7 +353,7 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */`
`353`	`353`	`option = PHP_STREAM_META_GROUP_NAME;`
`354`	`354`	`value = Z_STRVAL_P(group);`
`355`	`355`	`} else {`
`356`		`- zend_type_error("chgrp() expects argument #2 ($group) to be of type string\|int, %s given", zend_zval_type_name(group));`
	`356`	`+ zend_type_error("Argument #2 ($group) passed to chgrp() must be of type string\|int, %s given", zend_zval_type_name(group));`
`357`	`357`	`RETURN_THROWS();`
`358`	`358`	`}`
`359`	`359`	`if(wrapper->wops->stream_metadata(wrapper, filename, option, value, NULL)) {`
`@@ -382,7 +382,7 @@ static void php_do_chgrp(INTERNAL_FUNCTION_PARAMETERS, int do_lchgrp) /* {{{ */`
`382`	`382`	`RETURN_FALSE;`
`383`	`383`	`}`
`384`	`384`	`} else {`
`385`		`- zend_type_error("chgrp() expects argument #2 ($group) to be of type string\|int, %s given", zend_zval_type_name(group));`
	`385`	`+ zend_type_error("Argument #2 ($group) passed to chgrp() must be of type string\|int, %s given", zend_zval_type_name(group));`
`386`	`386`	`RETURN_THROWS();`
`387`	`387`	`}`
`388`	`388`
Original file line number	Diff line number	Diff line change
`@@ -1276,15 +1276,15 @@ PHP_FUNCTION(implode)`
`1276`	`1276`
`1277`	`1277`	`if (pieces == NULL) {`
`1278`	`1278`	`if (arg1_array == NULL) {`
`1279`		`- zend_type_error("%s() expects argument #1 ($pieces) to be of type array, string given", get_active_function_name());`
	`1279`	`+ zend_type_error("Argument #1 ($pieces) passed to %s() must be of type array, string given", get_active_function_name());`
`1280`	`1280`	`RETURN_THROWS();`
`1281`	`1281`	`}`
`1282`	`1282`
`1283`	`1283`	`arg1_str = ZSTR_EMPTY_ALLOC();`
`1284`	`1284`	`pieces = arg1_array;`
`1285`	`1285`	`} else {`
`1286`	`1286`	`if (arg1_str == NULL) {`
`1287`		`- zend_type_error("%s() expects argument #1 ($glue) to be of type string, array given", get_active_function_name());`
	`1287`	`+ zend_type_error("Argument #1 ($glue) passed to %s() must be of type string, array given", get_active_function_name());`
`1288`	`1288`	`RETURN_THROWS();`
`1289`	`1289`	`}`
`1290`	`1290`	`}`