Use the same AST for FCCs and PFAs

Author: arnaud-lb

Zend/tests/partial_application/compile_errors_006.phpt

@@ -5,5 +5,5 @@ Partial application compile errors: mix application with unpack (placeholder aft
 foo(...["foo" => "bar"], ...);
 ?>
 --EXPECTF--
-Fatal error: Cannot use positional argument after argument unpacking %s on line %d
+Fatal error: Cannot combine partial application and unpacking in %s on line %d
 

Zend/zend_ast.c

@@ -61,6 +61,7 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_fcc(void) {
 	ast->kind = ZEND_AST_CALLABLE_CONVERT;
 	ast->attr = 0;
 	ast->lineno = CG(zend_lineno);
+	ast->args = NULL;
 	ZEND_MAP_PTR_INIT(ast->fptr, NULL);
 
 	return (zend_ast *) ast;
@@ -508,6 +509,41 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_list_add(zend_ast *ast, zend_ast *op)
 	return (zend_ast *) list;
 }
 
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list(zend_ast *arg) {
+	zend_ast *list = zend_ast_create_list(1, ZEND_AST_ARG_LIST, arg);
+
+	if (arg->kind == ZEND_AST_PLACEHOLDER_ARG
+			|| (arg->kind == ZEND_AST_NAMED_ARG
+				&& arg->child[1]->kind == ZEND_AST_PLACEHOLDER_ARG)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = zend_ast_create_list(1, ZEND_AST_ARG_LIST, arg);
+		return (zend_ast*)fcc_ast;
+	}
+
+	return list;
+}
+
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_arg_list_add(zend_ast *list, zend_ast *arg)
+{
+	if (list->kind == ZEND_AST_CALLABLE_CONVERT) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)list;
+		fcc_ast->args = zend_ast_list_add(fcc_ast->args, arg);
+		return (zend_ast*)fcc_ast;
+	}
+
+	ZEND_ASSERT(list->kind == ZEND_AST_ARG_LIST);
+
+	if (arg->kind == ZEND_AST_PLACEHOLDER_ARG
+			|| (arg->kind == ZEND_AST_NAMED_ARG
+				&& arg->child[1]->kind == ZEND_AST_PLACEHOLDER_ARG)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = zend_ast_list_add(list, arg);
+		return (zend_ast*)fcc_ast;
+	}
+
+	return zend_ast_list_add(list, arg);
+}
+
 static zend_result zend_ast_add_array_element(zval *result, zval *offset, zval *expr)
 {
 	if (Z_TYPE_P(offset) == IS_UNDEF) {
@@ -1058,6 +1094,14 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 				case ZEND_AST_CALL: {
 					ZEND_ASSERT(ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT);
 					zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast->child[1];
+
+					zend_ast_list *args = zend_ast_get_list(fcc_ast->args);
+					ZEND_ASSERT(args->children > 0);
+					if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+						/* TODO: PFAs */
+						return FAILURE;
+					}
+
 					fptr = ZEND_MAP_PTR_GET(fcc_ast->fptr);
 
 					if (!fptr) {
@@ -1085,6 +1129,13 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 					ZEND_ASSERT(ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT);
 					zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast->child[2];
 
+					zend_ast_list *args = zend_ast_get_list(fcc_ast->args);
+					ZEND_ASSERT(args->children > 0);
+					if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+						/* TODO: PFAs */
+						return FAILURE;
+					}
+
 					fptr = ZEND_MAP_PTR_GET(fcc_ast->fptr);
 
 					if (!fptr) {
@@ -1246,7 +1297,8 @@ static size_t ZEND_FASTCALL zend_ast_tree_size(zend_ast *ast)
 	} else if (ast->kind == ZEND_AST_OP_ARRAY) {
 		size = sizeof(zend_ast_op_array);
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
-		size = sizeof(zend_ast_fcc);
+		zend_ast *args_ast = ((zend_ast_fcc*)ast)->args;
+		size = sizeof(zend_ast_fcc) + zend_ast_tree_size(args_ast);
 	} else if (zend_ast_is_list(ast)) {
 		uint32_t i;
 		zend_ast_list *list = zend_ast_get_list(ast);
@@ -1323,6 +1375,8 @@ static void* ZEND_FASTCALL zend_ast_tree_copy(zend_ast *ast, void *buf)
 		new->lineno = old->lineno;
 		ZEND_MAP_PTR_INIT(new->fptr, ZEND_MAP_PTR(old->fptr));
 		buf = (void*)((char*)buf + sizeof(zend_ast_fcc));
+		new->args = buf;
+		buf = zend_ast_tree_copy(old->args, buf);
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
 		ZEND_UNREACHABLE();
@@ -1406,6 +1460,10 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 		zend_ast_destroy(decl->child[3]);
 		ast = decl->child[4];
 		goto tail_call;
+	} else if (EXPECTED(ast->kind == ZEND_AST_CALLABLE_CONVERT)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*) ast;
+
+		zend_ast_destroy(fcc_ast->args);
 	}
 }
 
@@ -2451,9 +2509,10 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio
 			zend_ast_export_ex(str, ast->child[1], 0, indent);
 			smart_str_appendc(str, ')');
 			break;
-		case ZEND_AST_CALLABLE_CONVERT:
-			smart_str_appends(str, "...");
-			break;
+		case ZEND_AST_CALLABLE_CONVERT:;
+			zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast;
+			ast = fcc_ast->args;
+			goto simple_list;
 		case ZEND_AST_CLASS_CONST:
 			zend_ast_export_ns_name(str, ast->child[0], 0, indent);
 			smart_str_appends(str, "::");
@@ -2970,16 +3029,12 @@ zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr)
 	return ast;
 }
 
-zend_ast_list * ZEND_FASTCALL zend_ast_call_get_arg_list(zend_ast *ast)
+zend_ast * ZEND_FASTCALL zend_ast_call_get_args(zend_ast *ast)
 {
 	if (ast->kind == ZEND_AST_CALL) {
-		if (ast->child[1]->kind == ZEND_AST_ARG_LIST) {
-			return zend_ast_get_list(ast->child[1]);
-		}
+		return ast->child[1];
 	} else if (ast->kind == ZEND_AST_STATIC_CALL || ast->kind == ZEND_AST_METHOD_CALL) {
-		if (ast->child[2]->kind == ZEND_AST_ARG_LIST) {
-			return zend_ast_get_list(ast->child[2]);
-		}
+		return ast->child[2];
 	}
 
 	return NULL;

Zend/zend_ast.h

@@ -231,10 +231,12 @@ typedef struct _zend_ast_decl {
 	zend_ast *child[5];
 } zend_ast_decl;
 
+// TODO: rename
 typedef struct _zend_ast_fcc {
 	zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */
 	zend_ast_attr attr; /* Additional attribute, use depending on node type */
 	uint32_t lineno;    /* Line number */
+	zend_ast *args;
 	ZEND_MAP_PTR_DEF(zend_function *, fptr);
 } zend_ast_fcc;
 
@@ -324,6 +326,15 @@ ZEND_API zend_ast *zend_ast_create_list(uint32_t init_children, zend_ast_kind ki
 
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_list_add(zend_ast *list, zend_ast *op);
 
+/* Wraps the list into a ZEND_AST_CALLABLE_CONVERT if arg is a
+ * ZEND_AST_PLACEHOLDER_ARG. */
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list(zend_ast *arg);
+
+/* Like zend_ast_list_add(), but wraps the list into a ZEND_AST_CALLABLE_CONVERT
+ * if any arg is a ZEND_AST_PLACEHOLDER_ARG. list can be a zend_ast_list, or a
+ * zend_ast_fcc. */
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_arg_list_add(zend_ast *list, zend_ast *arg);
+
 ZEND_API zend_ast *zend_ast_create_decl(
 	zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
 	zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4
@@ -427,6 +438,6 @@ static zend_always_inline zend_ast *zend_ast_list_rtrim(zend_ast *ast) {
 
 zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr);
 
-zend_ast_list * ZEND_FASTCALL zend_ast_call_get_arg_list(zend_ast *ast);
+zend_ast * ZEND_FASTCALL zend_ast_call_get_args(zend_ast *ast);
 
 #endif

Zend/zend_compile.c

@@ -3696,8 +3696,8 @@ static uint32_t zend_get_arg_num(zend_function *fn, zend_string *arg_name) {
 }
 
 static uint32_t zend_compile_args(
-		zend_ast *ast, zend_function *fbc, bool *may_have_extra_named_args,
-		bool *is_call_partial) /* {{{ */
+		zend_ast *ast, zend_function *fbc, bool is_call_partial,
+		bool *may_have_extra_named_args) /* {{{ */
 {
 	zend_ast_list *args = zend_ast_get_list(ast);
 	uint32_t i;
@@ -3712,8 +3712,6 @@ static uint32_t zend_compile_args(
 	bool may_have_undef = 0;
 	/* Whether there may be any extra named arguments collected into a variadic. */
 	*may_have_extra_named_args = 0;
-	/* Whether this is a partial call */
-	*is_call_partial = false;
 
 	for (i = 0; i < args->children; ++i) {
 		zend_ast *arg = args->child[i];
@@ -3730,7 +3728,7 @@ static uint32_t zend_compile_args(
 					"Cannot use argument unpacking after named arguments");
 			}
 
-			if (*is_call_partial) {
+			if (is_call_partial) {
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Cannot combine partial application and unpacking");
 			}
@@ -3824,7 +3822,6 @@ static uint32_t zend_compile_args(
 				opline->result.var = EX_NUM_TO_VAR(arg_num - 1);
 			}
 
-			*is_call_partial = true;
 			continue;
 		}
 
@@ -3938,7 +3935,7 @@ static uint32_t zend_compile_args(
 		}
 	}
 
-	if (!*is_call_partial) {
+	if (!is_call_partial) {
 		if (may_have_undef) {
 			zend_emit_op(NULL, ZEND_CHECK_UNDEF_ARGS, NULL, NULL);
 		}
@@ -4010,27 +4007,38 @@ static bool zend_compile_call_common(znode *result, zend_ast *args_ast, zend_fun
 {
 	zend_op *opline;
 	uint32_t opnum_init = get_next_op_number() - 1;
+	bool is_partial_call = false;
 
 	if (args_ast->kind == ZEND_AST_CALLABLE_CONVERT) {
+		is_partial_call = true;
+
 		opline = &CG(active_op_array)->opcodes[opnum_init];
 		opline->extended_value = 0;
 
 		if (opline->opcode == ZEND_NEW) {
 		    zend_error_noreturn(E_COMPILE_ERROR, "Cannot create Closure for new expression");
 		}
 
-		if (opline->opcode == ZEND_INIT_FCALL) {
-			opline->op1.num = zend_vm_calc_used_stack(0, fbc);
+		zend_ast_list *fcc_args = zend_ast_get_list(((zend_ast_fcc*)args_ast)->args);
+
+		/* FCCs are a special case of PFAs with a single variadic placeholder */
+		if (fcc_args->children == 1 && fcc_args->child[0]->attr == _IS_PLACEHOLDER_VARIADIC) {
+
+			if (opline->opcode == ZEND_INIT_FCALL) {
+				opline->op1.num = zend_vm_calc_used_stack(0, fbc);
+			}
+
+			zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT, NULL, NULL);
+
+			return true;
 		}
 
-		zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT, NULL, NULL);
-		return true;
+		args_ast = ((zend_ast_fcc*)args_ast)->args;
 	}
 
 	bool may_have_extra_named_args;
-	bool is_partial_call;
 	uint32_t arg_count = zend_compile_args(args_ast, fbc,
-			&may_have_extra_named_args, &is_partial_call);
+			is_partial_call, &may_have_extra_named_args);
 
 	if (is_partial_call) {
 		zend_compile_call_partial(result, arg_count, may_have_extra_named_args, opnum_init, fbc);
@@ -6519,11 +6527,13 @@ static zend_ast *zend_partial_apply(zend_ast *callable_ast, zend_ast *pipe_arg)
 		return NULL;
 	}
 
-	zend_ast_list *arg_list = zend_ast_call_get_arg_list(callable_ast);
-	if (!arg_list) {
+	zend_ast *args_ast = zend_ast_call_get_args(callable_ast);
+	if (!args_ast || args_ast->kind != ZEND_AST_CALLABLE_CONVERT) {
 		return NULL;
 	}
 
+	zend_ast_list *arg_list = zend_ast_get_list(((zend_ast_fcc*)args_ast)->args);
+
 	zend_ast *first_placeholder = NULL;
 	bool uses_variadic_placeholder = false;
 
@@ -6557,10 +6567,7 @@ static zend_ast *zend_partial_apply(zend_ast *callable_ast, zend_ast *pipe_arg)
 		}
 	}
 
-	if (first_placeholder == NULL) {
-		/* Not a PFA */
-		return NULL;
-	}
+	ZEND_ASSERT(first_placeholder);
 
 	zend_ast *new_arg_list = zend_ast_create_list(0, arg_list->kind);
 	for (uint32_t i = 0; i < arg_list->children; i++) {
@@ -6601,30 +6608,14 @@ static void zend_compile_pipe(znode *result, zend_ast *ast)
 
 	/* Turn the operand into a function parameter list. */
 	zend_ast *arg = zend_ast_create_znode(&wrapped_operand_result);
-	zend_ast *arg_list_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, arg);
 
 	zend_ast *fcall_ast;
 	znode callable_result;
 
 	zend_ast *pfa_arg_list_ast = NULL;
 
-	/* Turn $foo |> bar(...) into bar($foo). */
-	if (callable_ast->kind == ZEND_AST_CALL
-		&& callable_ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT) {
-		fcall_ast = zend_ast_create(ZEND_AST_CALL,
-				callable_ast->child[0], arg_list_ast);
-	/* Turn $foo |> bar::baz(...) into bar::baz($foo). */
-	} else if (callable_ast->kind == ZEND_AST_STATIC_CALL
-			&& callable_ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT) {
-		fcall_ast = zend_ast_create(ZEND_AST_STATIC_CALL,
-			callable_ast->child[0], callable_ast->child[1], arg_list_ast);
-	/* Turn $foo |> $bar->baz(...) into $bar->baz($foo). */
-	} else if (callable_ast->kind == ZEND_AST_METHOD_CALL
-			&& callable_ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT) {
-		fcall_ast = zend_ast_create(ZEND_AST_METHOD_CALL,
-			callable_ast->child[0], callable_ast->child[1], arg_list_ast);
 	/* Turn $foo |> PFA into plain function call if possible */
-	} else if ((pfa_arg_list_ast = zend_partial_apply(callable_ast, arg))) {
+	if ((pfa_arg_list_ast = zend_partial_apply(callable_ast, arg))) {
 		switch (callable_ast->kind) {
 			case ZEND_AST_CALL:
 				fcall_ast = zend_ast_create(ZEND_AST_CALL,
@@ -6644,6 +6635,7 @@ static void zend_compile_pipe(znode *result, zend_ast *ast)
 		}
 	/* Turn $foo |> $expr into ($expr)($foo) */
 	} else {
+		zend_ast *arg_list_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, arg);
 		zend_compile_expr(&callable_result, callable_ast);
 		callable_ast = zend_ast_create_znode(&callable_result);
 		fcall_ast = zend_ast_create(ZEND_AST_CALL,
@@ -11570,6 +11562,13 @@ static void zend_compile_const_expr_fcc(zend_ast **ast_ptr)
 	if ((*args_ast)->kind != ZEND_AST_CALLABLE_CONVERT) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
 	}
+
+	zend_ast_list *args = zend_ast_get_list(((zend_ast_fcc*)*args_ast)->args);
+	if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+		// TODO: PFAs
+		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
+	}
+
 	ZEND_MAP_PTR_NEW(((zend_ast_fcc *)*args_ast)->fptr);
 
 	switch ((*ast_ptr)->kind) {

Zend/zend_fibers.c

@@ -583,6 +583,9 @@ static ZEND_STACK_ALIGNED void zend_fiber_execute(zend_fiber_transfer *transfer)
 		EG(vm_stack_page_size) = ZEND_FIBER_VM_STACK_SIZE;
 
 		fiber->execute_data = (zend_execute_data *) stack->top;
+#ifdef __SANITIZE_ADDRESS__
+		__asan_unpoison_memory_region(stack->top, sizeof(zend_execute_data));
+#endif
 		fiber->stack_bottom = fiber->execute_data;
 
 		memset(fiber->execute_data, 0, sizeof(zend_execute_data));