zend_compile: Optimize array_map() with callable convert callback into foreach

UPGRADING

@@ -151,6 +151,11 @@ PHP 8.6 UPGRADE NOTES
  parsing the format string.
  . Arguments are now passed more efficiently to known constructors (e.g. when
  using new self()).
+ . array_map() using a first-class callable or partial function application
+ callback will be compiled into the equivalent foreach-loop, avoiding the
+ creation of intermediate Closures, the overhead of calling userland
+ callbacks from internal functions and providing for better insight for the
+ JIT.
 
 - DOM:
  . Made splitText() faster and consume less memory.

Zend/tests/functions/zend_call_function_deprecated_frame.phpt

@@ -19,7 +19,6 @@ var_dump($a);
 --EXPECTF--
 Fatal error: Uncaught Exception: Function foo() is deprecated in %s:%d
 Stack trace:
-#0 [internal function]: {closure:%s:%d}(16384, 'Function foo() ...', '%s', %d)
-#1 %s(%d): array_map(Object(Closure), Array)
-#2 {main}
+#0 %s(%d): {closure:%s:%d}(16384, 'Function foo() ...', '%s', %d)
+#1 {main}
  thrown in %s on line %d

Zend/tests/gh14003.phpt

@@ -18,7 +18,6 @@ array_filter(
 --EXPECTF--
 Fatal error: Uncaught Exception: Test in %s:%d
 Stack trace:
-#0 [internal function]: foo('a')
-#1 %s(%d): array_map(Object(Closure), Array)
-#2 {main}
+#0 %s(%d): foo('a')
+#1 {main}
  thrown in %s on line %d

Zend/zend_compile.c

@@ -5027,7 +5027,115 @@ static zend_result zend_compile_func_clone(znode *result, const zend_ast_list *a
 	return SUCCESS;
 }
 
-static zend_result zend_try_compile_special_func_ex(znode *result, zend_string *lcname, zend_ast_list *args, uint32_t type) /* {{{ */
+static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno) /* {{{ */
+{
+	/* Bail out if we do not have exactly two parameters. */
+	if (args->children != 2) {
+ return FAILURE;
+	}
+
+	zend_ast *callback = args->child[0];
+
+	/* Bail out if the callback is not a FCC/PFA. */
+	zend_ast *args_ast;
+	switch (callback->kind) {
+ case ZEND_AST_CALL:
+ case ZEND_AST_STATIC_CALL:
+ args_ast = zend_ast_call_get_args(callback);
+ if (args_ast->kind != ZEND_AST_CALLABLE_CONVERT) {
+ return FAILURE;
+ }
+
+ break;
+ default:
+ return FAILURE;
+	}
+
+	/* Bail out if the callback is assert() due to the AST stringification logic
+ * breaking for the generated call.
+ */
+	if (callback->kind == ZEND_AST_CALL && zend_string_equals_literal_ci(zend_ast_get_str(callback->child[0]), "assert")) {
+ return FAILURE;
+	}
+
+	znode value;
+	value.op_type = IS_TMP_VAR;
+	value.u.op.var = get_temporary_variable();
+
+	zend_ast_list *callback_args = zend_ast_get_list(((zend_ast_fcc*)args_ast)->args);
+	zend_ast *call_args = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+	for (uint32_t i = 0; i < callback_args->children; i++) {
+ zend_ast *child = callback_args->child[i];
+ if (child->kind == ZEND_AST_PLACEHOLDER_ARG) {
+ call_args = zend_ast_list_add(call_args, zend_ast_create_znode(&value));
+ } else {
+ ZEND_ASSERT(0 && "not implemented");
+ call_args = zend_ast_list_add(call_args, child);
+ }
+	}
+
+	zend_op *opline;
+
+	znode array;
+	zend_compile_expr(&array, args->child[1]);
+	/* array is an argument to both ZEND_TYPE_ASSERT and to ZEND_FE_RESET_R. */
+	if (array.op_type == IS_CONST) {
+ Z_TRY_ADDREF(array.u.constant);
+	}
+
+	/* Verify that the input array actually is an array. */
+	znode name;
+	name.op_type = IS_CONST;
+	ZVAL_STR_COPY(&name.u.constant, lcname);
+	opline = zend_emit_op(NULL, ZEND_TYPE_ASSERT, &name, &array);
+	opline->lineno = lineno;
+	opline->extended_value = (2 << 16) | IS_ARRAY;
+	const zval *fbc_zv = zend_hash_find(CG(function_table), lcname);
+	const Bucket *fbc_bucket = (const Bucket*)((uintptr_t)fbc_zv - XtOffsetOf(Bucket, val));
+	Z_EXTRA_P(CT_CONSTANT(opline->op1)) = fbc_bucket - CG(function_table)->arData;
+
+	/* Initialize the result array. */
+	zend_emit_op_tmp(result, ZEND_INIT_ARRAY, NULL, NULL);
+
+	/* foreach loop starts here. */
+	znode key;
+
+	uint32_t opnum_reset = get_next_op_number();
+	znode reset_node;
+	zend_emit_op(&reset_node, ZEND_FE_RESET_R, &array, NULL);
+	zend_begin_loop(ZEND_FE_FREE, &reset_node, false);
+	uint32_t opnum_fetch = get_next_op_number();
+	zend_emit_op_tmp(&key, ZEND_FE_FETCH_R, &reset_node, &value);
+
+	/* loop body */
+	znode call_result;
+	switch (callback->kind) {
+ case ZEND_AST_CALL:
+ zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_CALL, callback->child[0], call_args));
+ break;
+ case ZEND_AST_STATIC_CALL:
+ zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_STATIC_CALL, callback->child[0], callback->child[1], call_args));
+ break;
+	}
+	opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT, &call_result, &key);
+	SET_NODE(opline->result, result);
+	/* end loop body */
+
+	zend_emit_jump(opnum_fetch);
+
+	uint32_t opnum_loop_end = get_next_op_number();
+	opline = &CG(active_op_array)->opcodes[opnum_reset];
+	opline->op2.opline_num = opnum_loop_end;
+	opline = &CG(active_op_array)->opcodes[opnum_fetch];
+	opline->extended_value = opnum_loop_end;
+
+	zend_end_loop(opnum_fetch, &reset_node);
+	zend_emit_op(NULL, ZEND_FE_FREE, &reset_node, NULL);
+
+	return SUCCESS;
+}
+
+static zend_result zend_try_compile_special_func_ex(znode *result, zend_string *lcname, zend_ast_list *args, uint32_t type, uint32_t lineno) /* {{{ */
 {
 	if (zend_string_equals_literal(lcname, "strlen")) {
  return zend_compile_func_strlen(result, args);
@@ -5099,12 +5207,14 @@ static zend_result zend_try_compile_special_func_ex(znode *result, zend_string *
  return zend_compile_func_printf(result, args);
 	} else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_CLONE))) {
  return zend_compile_func_clone(result, args);
+	} else if (zend_string_equals_literal(lcname, "array_map")) {
+ return zend_compile_func_array_map(result, args, lcname, lineno);
 	} else {
  return FAILURE;
 	}
 }
 
-static zend_result zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_list *args, const zend_function *fbc, uint32_t type) /* {{{ */
+static zend_result zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_list *args, const zend_function *fbc, uint32_t type, uint32_t lineno) /* {{{ */
 {
 	if (CG(compiler_options) & ZEND_COMPILE_NO_BUILTINS) {
  return FAILURE;
@@ -5120,7 +5230,7 @@ static zend_result zend_try_compile_special_func(znode *result, zend_string *lcn
  return FAILURE;
 	}
 
-	if (zend_try_compile_special_func_ex(result, lcname, args, type) == SUCCESS) {
+	if (zend_try_compile_special_func_ex(result, lcname, args, type, lineno) == SUCCESS) {
  return SUCCESS;
 	}
 
@@ -5263,7 +5373,7 @@ static void zend_compile_call(znode *result, const zend_ast *ast, uint32_t type)
 
  if (!is_callable_convert &&
  zend_try_compile_special_func(result, lcname,
- zend_ast_get_list(args_ast), fbc, type) == SUCCESS
+ zend_ast_get_list(args_ast), fbc, type, ast->lineno) == SUCCESS
  ) {
  zend_string_release_ex(lcname, 0);
  zval_ptr_dtor(&name_node.u.constant);

Zend/zend_vm_def.h

@@ -8846,6 +8846,38 @@ ZEND_VM_C_LABEL(type_check_resource):
 	}
 }
 
+ZEND_VM_HOT_HANDLER(211, ZEND_TYPE_ASSERT, CONST, ANY, NUM)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zval *value = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+
+	uint8_t actual_type = Z_TYPE_P(value);
+	uint8_t expected_type = opline->extended_value & 0xff;
+	/* Simple types can be checked directly. */
+	if (UNEXPECTED(actual_type != expected_type)) {
+ zend_function *fbc;
+ {
+ zval *fname = (zval*)RT_CONSTANT(opline, opline->op1);
+ ZEND_ASSERT(Z_EXTRA_P(fname) != 0);
+ fbc = Z_FUNC(EG(function_table)->arData[Z_EXTRA_P(fname)].val);
+ ZEND_ASSERT(fbc->type != ZEND_USER_FUNCTION);
+ }
+ uint16_t argno = opline->extended_value >> 16;
+ zend_arg_info *arginfo = &fbc->common.arg_info[argno - 1];
+
+ if (!zend_check_type(&arginfo->type, value, /* is_return_type */ false, /* is_internal */ true)) {
+ const char *param_name = get_function_arg_name(fbc, argno);
+ zend_string *expected = zend_type_to_string(arginfo->type);
+ zend_type_error("%s(): Argument #%d%s%s%s must be of type %s, %s given", ZSTR_VAL(fbc->common.function_name), argno, param_name ? " ($" : "", param_name ? param_name : "", param_name ? ")" : "", ZSTR_VAL(expected), zend_zval_value_name(value));
+ zend_string_release(expected);
+ }
+	}
+
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
 {
 	USE_OPLINE