Make type error messages more consistent

Closes GH-5092

1 files changed, 46 insertions, 42 deletions

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index ed8440f104..595208033b 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -207,8 +207,6 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameters_count_error(int min_
 
 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(int num, zend_expected_type expected_type, zval *arg) /* {{{ */
 {
-	const char *space;
-	const char *class_name;
 	static const char * const expected_error[] = {
 		Z_EXPECTED_TYPES(Z_EXPECTED_TYPE_STR)
 		NULL
@@ -217,38 +215,55 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_type_error(int num, z
 	if (EG(exception)) {
 		return;
 	}
-	class_name = get_active_class_name(&space);
-	zend_type_error("%s%s%s() expects parameter %d to be %s, %s given",
-		class_name, space, get_active_function_name(), num, expected_error[expected_type], zend_zval_type_name(arg));
+
+	zend_argument_type_error(num, "to be %s, %s given", expected_error[expected_type], zend_zval_type_name(arg));
 }
 /* }}} */
 
 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_parameter_class_error(int num, const char *name, zval *arg) /* {{{ */
 {
-	const char *space;
-	const char *class_name;
-
 	if (EG(exception)) {
 		return;
 	}
-	class_name = get_active_class_name(&space);
-	zend_type_error("%s%s%s() expects parameter %d to be %s, %s given",
-		class_name, space, get_active_function_name(), num, name, zend_zval_type_name(arg));
+
+	zend_argument_type_error(num, "to be of type %s, %s given", name, zend_zval_type_name(arg));
 }
 /* }}} */
 
 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_wrong_callback_error(int num, char *error) /* {{{ */
 {
+	if (EG(exception)) {
+		return;
+	}
+
+	zend_argument_type_error(num, "to be a valid callback, %s", error);
+	efree(error);
+}
+/* }}} */
+
+ZEND_API ZEND_COLD void ZEND_FASTCALL zend_argument_error(zend_class_entry *error_ce, uint32_t arg_num, const char *format, ...) /* {{{ */
+{
 	const char *space;
 	const char *class_name;
-
+	const char *arg_name;
+	char *message = NULL;
 	if (EG(exception)) {
 		return;
 	}
+
 	class_name = get_active_class_name(&space);
-	zend_type_error("%s%s%s() expects parameter %d to be a valid callback, %s",
-		class_name, space, get_active_function_name(), num, error);
-	efree(error);
+	arg_name = get_active_function_arg_name(arg_num);
+
+	va_list va;
+	va_start(va, format);
+	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
+    );
+	efree(message);
 }
 /* }}} */
 
@@ -268,23 +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))) {
-			const char *space;
-			const char *class_name = get_active_class_name(&space);
-
-			zend_type_error("%s%s%s() expects parameter %d to be a class name derived from %s, '%s' given",
-				class_name, space, get_active_function_name(), num,
-				ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));
+			zend_argument_type_error(num, "to be a class name derived from %s, '%s' given", ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));
 			*pce = NULL;
 			return 0;
 		}
 	}
 	if (!*pce) {
-		const char *space;
-		const char *class_name = get_active_class_name(&space);
-
-		zend_type_error("%s%s%s() expects parameter %d to be a valid class name, '%s' given",
-			class_name, space, get_active_function_name(), num,
-			Z_STRVAL_P(arg));
+		zend_argument_type_error(num, "to be a valid class name, '%s' given", Z_STRVAL_P(arg));
 		return 0;
 	}
 	return 1;
@@ -547,7 +552,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 				char **p = va_arg(*va, char **);
 				size_t *pl = va_arg(*va, size_t *);
 				if (!zend_parse_arg_path(arg, p, pl, check_null)) {
-					return "a valid path";
+					zend_spprintf(error, 0, "a valid path, %s given", zend_zval_type_name(arg));
+					return "";
 				}
 			}
 			break;
@@ -556,7 +562,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 			{
 				zend_string **str = va_arg(*va, zend_string **);
 				if (!zend_parse_arg_path_str(arg, str, check_null)) {
-					return "a valid path";
+					zend_spprintf(error, 0, "a valid path, %s given", zend_zval_type_name(arg));
+					return "";
 				}
 			}
 			break;
@@ -653,7 +660,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 				}
 				if (!try_convert_to_string(arg)) {
 					*pce = NULL;
-					return "valid class name";
+					return "a valid class name";
 				}
 
 				if ((lookup = zend_lookup_class(Z_STR_P(arg))) == NULL) {
@@ -663,14 +670,14 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 				}
 				if (ce_base) {
 					if ((!*pce || !instanceof_function(*pce, ce_base))) {
-						zend_spprintf(error, 0, "to be a class name derived from %s, '%s' given",
+						zend_spprintf(error, 0, "a class name derived from %s, '%s' given",
 							ZSTR_VAL(ce_base->name), Z_STRVAL_P(arg));
 						*pce = NULL;
 						return "";
 					}
 				}
 				if (!*pce) {
-					zend_spprintf(error, 0, "to be a valid class name, '%s' given",
+					zend_spprintf(error, 0, "a valid class name, '%s' given",
 						Z_STRVAL_P(arg));
 					return "";
 				}
@@ -697,11 +704,11 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 				}
 
 				if (is_callable_error) {
-					zend_spprintf(error, 0, "to be a valid callback, %s", is_callable_error);
+					zend_spprintf(error, 0, "a valid callback, %s", is_callable_error);
 					efree(is_callable_error);
 					return "";
 				} else {
-					return "valid callback";
+					return "a valid callback";
 				}
 			}
 
@@ -737,19 +744,16 @@ static int zend_parse_arg(int arg_num, zval *arg, va_list *va, const char **spec
 			return FAILURE;
 		}
 		if (!(flags & ZEND_PARSE_PARAMS_QUIET) && (*expected_type || error)) {
-			const char *space;
-			const char *class_name = get_active_class_name(&space);
-
 			if (error) {
-				zend_type_error("%s%s%s() expects parameter %d %s",
-						class_name, space, get_active_function_name(), arg_num, error);
+				zend_argument_type_error(arg_num, "to be %s", error);
 				efree(error);
 			} else {
-				zend_type_error("%s%s%s() expects parameter %d to be %s, %s given",
-						class_name, space, get_active_function_name(), arg_num, expected_type,
-						zend_zval_type_name(arg));
+				zend_argument_type_error(arg_num, "to be of type %s, %s given", expected_type, zend_zval_type_name(arg));
 			}
+		} else if (error) {
+			efree(error);
 		}
+
 		return FAILURE;
 	}