Add partial support for first-class callable syntax in constant expressions

Author: pevdh

Zend/tests/constexpr/callable.phpt

@@ -0,0 +1,28 @@
+--TEST--
+First-class callable syntax in constant expressions
+--FILE--
+<?php
+
+static $staticFn = strlen(...);
+
+#[Attribute]
+class MyAttribute {
+    public function __construct(public readonly Closure $fn) {}
+}
+
+#[MyAttribute(fn: strlen(...))]
+class X {
+ const FN = strlen(...);
+}
+
+$ref = new ReflectionClass(X::class);
+$attr = $ref->getAttributes()[0]->newInstance();
+
+var_dump($staticFn('test123'));
+var_dump(($attr->fn)('test123'));
+var_dump((X::FN)('test123'));
+?>
+--EXPECT--
+int(7)
+int(7)
+int(7)

Zend/zend_ast.c

@@ -25,6 +25,7 @@
 #include "zend_exceptions.h"
 #include "zend_constants.h"
 #include "zend_enum.h"
+#include "zend_closures.h"
 
 ZEND_API zend_ast_process_t zend_ast_process = NULL;
 
@@ -976,6 +977,27 @@ static zend_result ZEND_FASTCALL zend_ast_evaluate_ex(zval *result, zend_ast *as
 			zval_ptr_dtor_nogc(&op2);
 			return SUCCESS;
 		}
+    case ZEND_AST_CALL:
+    {
+      zend_function *function_ptr;
+      zval *function_name;
+
+      ZEND_ASSERT(ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT);
+
+      function_name = zend_ast_get_zval(ast->child[0]);
+
+      zend_fcall_info_cache fcc;
+      char *error = NULL;
+      if (!zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
+        return FAILURE;
+      }
+
+      function_ptr = fcc.function_handler;
+
+      zend_create_fake_closure(result, function_ptr, function_ptr->common.scope, fcc.called_scope, NULL);
+
+      return SUCCESS;
+    }
 		default:
 			zend_throw_error(NULL, "Unsupported constant expression");
 			ret = FAILURE;

Zend/zend_compile.c

@@ -9750,8 +9750,13 @@ static void zend_compile_magic_const(znode *result, zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
-static bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */
+static bool zend_is_allowed_in_const_expr(zend_ast *ast) /* {{{ */
 {
+  zend_ast_kind kind = ast->kind;
+  if (kind == ZEND_AST_CALL && ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT) {
+    return true;
+  }
+
 	return kind == ZEND_AST_ZVAL || kind == ZEND_AST_BINARY_OP
 		|| kind == ZEND_AST_GREATER || kind == ZEND_AST_GREATER_EQUAL
 		|| kind == ZEND_AST_AND || kind == ZEND_AST_OR
@@ -9766,7 +9771,8 @@ static bool zend_is_allowed_in_const_expr(zend_ast_kind kind) /* {{{ */
 		|| kind == ZEND_AST_CONST_ENUM_INIT
 		|| kind == ZEND_AST_NEW || kind == ZEND_AST_ARG_LIST
 		|| kind == ZEND_AST_NAMED_ARG
-		|| kind == ZEND_AST_PROP || kind == ZEND_AST_NULLSAFE_PROP;
+		|| kind == ZEND_AST_PROP || kind == ZEND_AST_NULLSAFE_PROP
+    || kind == ZEND_AST_CALLABLE_CONVERT;
 }
 /* }}} */
 
@@ -9930,7 +9936,7 @@ static void zend_compile_const_expr(zend_ast **ast_ptr, void *context) /* {{{ */
 		return;
 	}
 
-	if (!zend_is_allowed_in_const_expr(ast->kind)) {
+	if (!zend_is_allowed_in_const_expr(ast)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
 	}
 
@@ -10634,6 +10640,20 @@ static void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */
 			zend_eval_const_expr(&ast->child[0]);
 			zend_eval_const_expr(&ast->child[1]);
 			return;
+    case ZEND_AST_CALL:
+    {
+      zend_ast *func_ast;
+
+      if (ast->child[1]->kind != ZEND_AST_CALLABLE_CONVERT) {
+        zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
+      }
+
+      zend_eval_const_expr(&ast->child[0]);
+      func_ast = ast->child[0];
+
+      ZEND_ASSERT(func_ast->kind == ZEND_AST_ZVAL);
+      return;
+    }
 		default:
 			return;
 	}