[pull] master from php:master

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_object_handlers.c

@@ -1391,6 +1391,8 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *zobj, zend_string *nam
 	uintptr_t property_offset;
 	const zend_property_info *prop_info = NULL;
 
+	ZEND_ASSERT(type != BP_VAR_R && type != BP_VAR_IS);
+
 #if DEBUG_OBJECT_HANDLERS
 	fprintf(stderr, "Ptr object #%d property: %s\n", zobj->handle, ZSTR_VAL(name));
 #endif
@@ -1412,7 +1414,7 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *zobj, zend_string *nam
 
 					return zend_std_get_property_ptr_ptr(zobj, name, type, cache_slot);
 				}
-				if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
+				if (UNEXPECTED(type == BP_VAR_RW)) {
 					if (prop_info) {
 						zend_typed_property_uninitialized_access(prop_info, name);
 						retval = &EG(error_zval);
@@ -1473,7 +1475,7 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *zobj, zend_string *nam
 			if (UNEXPECTED(!zobj->properties)) {
 				rebuild_object_properties_internal(zobj);
 			}
-			if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
+			if (UNEXPECTED(type == BP_VAR_RW)) {
 				zend_error(E_WARNING, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
 			}
 			retval = zend_hash_add(zobj->properties, name, &EG(uninitialized_zval));

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