Partial attributes support

First need some APIs for internal calls with named attributes.

Author: nikic

Zend/tests/named_params/attributes.phpt

@@ -0,0 +1,39 @@
+--TEST--
+Named params in attributes
+--FILE--
+<?php
+
+<<Attribute>>
+class MyAttribute {
+    public function __construct(
+        public $a = 'a',
+        public $b = 'b',
+        public $c = 'c',
+    ) {}
+}
+
+<<MyAttribute('A', c: 'C')>>
+class Test {}
+
+$attr = (new ReflectionClass(Test::class))->getAttributes()[0];
+var_dump($attr->getName());
+var_dump($attr->getArguments());
+var_dump($attr->newInstance());
+
+?>
+--EXPECT--
+string(11) "MyAttribute"
+array(2) {
+  [0]=>
+  string(1) "A"
+  ["c"]=>
+  string(1) "C"
+}
+object(MyAttribute)#1 (3) {
+  ["a"]=>
+  string(1) "A"
+  ["b"]=>
+  string(1) "C"
+  ["c"]=>
+  string(1) "c"
+}

Zend/tests/named_params/attributes_duplicate_named_param.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Named params in attributes: Duplicate named parameter error
+--FILE--
+<?php
+
+<<MyAttribute(a: 'A', a: 'A')>>
+class Test {}
+
+?>
+--EXPECTF--
+Fatal error: Duplicate named parameter $a in %s on line %d

Zend/tests/named_params/attributes_positional_after_named.phpt

@@ -0,0 +1,14 @@
+--TEST--
+Named params in attributes: Positional after named error
+--FILE--
+<?php
+
+<<Attribute>>
+class MyAttribute { }
+
+<<MyAttribute(a: 'A', 'B')>>
+class Test {}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use positional argument after named argument in %s on line %d

Zend/zend_attributes.c

@@ -121,7 +121,8 @@ ZEND_API int zend_get_attribute_value(zval *ret, zend_attribute *attr, uint32_t
 		return FAILURE;
 	}
 
-	ZVAL_COPY_OR_DUP(ret, &attr->argv[i]);
+	// TODO: Named args.
+	ZVAL_COPY_OR_DUP(ret, &attr->args[i].value);
 
 	if (Z_TYPE_P(ret) == IS_CONSTANT_AST) {
 		if (SUCCESS != zval_update_constant_ex(ret, scope)) {
@@ -182,7 +183,10 @@ static zend_always_inline void free_attribute(zend_attribute *attr, int persiste
 	zend_string_release(attr->lcname);
 
 	for (i = 0; i < attr->argc; i++) {
-		zval_ptr_dtor(&attr->argv[i]);
+		if (attr->args[i].name) {
+			zend_string_release(attr->args[i].name);
+		}
+		zval_ptr_dtor(&attr->args[i].value);
 	}
 
 	pefree(attr, persistent);
@@ -219,7 +223,8 @@ ZEND_API zend_attribute *zend_add_attribute(HashTable **attributes, zend_bool pe
 
 	/* Initialize arguments to avoid partial initialization in case of fatal errors. */
 	for (uint32_t i = 0; i < argc; i++) {
-		ZVAL_UNDEF(&attr->argv[i]);
+		attr->args[i].name = NULL;
+		ZVAL_UNDEF(&attr->args[i].value);
 	}
 
 	zend_hash_next_index_insert_ptr(*attributes, attr);

Zend/zend_attributes.h

@@ -30,19 +30,25 @@
 #define ZEND_ATTRIBUTE_IS_REPEATABLE		(1<<6)
 #define ZEND_ATTRIBUTE_FLAGS				((1<<7) - 1)
 
-#define ZEND_ATTRIBUTE_SIZE(argc) (sizeof(zend_attribute) + sizeof(zval) * (argc) - sizeof(zval))
+#define ZEND_ATTRIBUTE_SIZE(argc) \
+	(sizeof(zend_attribute) + sizeof(zend_attribute_arg) * (argc) - sizeof(zend_attribute_arg))
 
 BEGIN_EXTERN_C()
 
 extern ZEND_API zend_class_entry *zend_ce_attribute;
 
+typedef struct {
+	zend_string *name;
+	zval value;
+} zend_attribute_arg;
+
 typedef struct _zend_attribute {
 	zend_string *name;
 	zend_string *lcname;
 	/* Parameter offsets start at 1, everything else uses 0. */
 	uint32_t offset;
 	uint32_t argc;
-	zval argv[1];
+	zend_attribute_arg args[1];
 } zend_attribute;
 
 typedef struct _zend_internal_attribute {

Zend/zend_compile.c

@@ -5812,13 +5812,33 @@ static void zend_compile_attributes(HashTable **attributes, zend_ast *ast, uint3
 		if (args) {
 			ZEND_ASSERT(args->kind == ZEND_AST_ARG_LIST);
 
+			zend_bool uses_named_args = 0;
 			for (j = 0; j < args->children; j++) {
-				if (args->child[j]->kind == ZEND_AST_UNPACK) {
+				zend_ast *arg_ast = args->child[j];
+
+				if (arg_ast->kind == ZEND_AST_UNPACK) {
 					zend_error_noreturn(E_COMPILE_ERROR,
 						"Cannot use unpacking in attribute argument list");
 				}
 
-				zend_const_expr_to_zval(&attr->argv[j], args->child[j]);
+				if (arg_ast->kind == ZEND_AST_NAMED_ARG) {
+					attr->args[j].name = zend_string_copy(zend_ast_get_str(arg_ast->child[0]));
+					arg_ast = arg_ast->child[1];
+					uses_named_args = 1;
+
+					for (uint32_t k = 0; k < j; k++) {
+						if (attr->args[k].name &&
+								zend_string_equals(attr->args[k].name, attr->args[j].name)) {
+							zend_error_noreturn(E_COMPILE_ERROR, "Duplicate named parameter $%s",
+								ZSTR_VAL(attr->args[j].name));
+						}
+					}
+				} else if (uses_named_args) {
+					zend_error_noreturn(E_COMPILE_ERROR,
+						"Cannot use positional argument after named argument");
+				}
+
+				zend_const_expr_to_zval(&attr->args[j].value, arg_ast);
 			}
 		}
 	}

ext/opcache/zend_file_cache.c

@@ -415,7 +415,8 @@ static void zend_file_cache_serialize_attribute(zval                     *zv,
 	SERIALIZE_STR(attr->lcname);
 
 	for (i = 0; i < attr->argc; i++) {
-		zend_file_cache_serialize_zval(&attr->argv[i], script, info, buf);
+		SERIALIZE_STR(attr->args[i].name);
+		zend_file_cache_serialize_zval(&attr->args[i].value, script, info, buf);
 	}
 }
 
@@ -1178,7 +1179,8 @@ static void zend_file_cache_unserialize_attribute(zval *zv, zend_persistent_scri
 	UNSERIALIZE_STR(attr->lcname);
 
 	for (i = 0; i < attr->argc; i++) {
-		zend_file_cache_unserialize_zval(&attr->argv[i], script, buf);
+		UNSERIALIZE_STR(attr->args[i].name);
+		zend_file_cache_unserialize_zval(&attr->args[i].value, script, buf);
 	}
 }
 

ext/opcache/zend_persist.c

@@ -278,7 +278,8 @@ static HashTable *zend_persist_attributes(HashTable *attributes)
 			zend_accel_store_interned_string(copy->lcname);
 
 			for (i = 0; i < copy->argc; i++) {
-				zend_persist_zval(&copy->argv[i]);
+				zend_accel_store_interned_string(copy->args[i].name);
+				zend_persist_zval(&copy->args[i].value);
 			}
 
 			ZVAL_PTR(v, copy);

ext/opcache/zend_persist_calc.c

@@ -165,7 +165,8 @@ static void zend_persist_attributes_calc(HashTable *attributes)
 			ADD_INTERNED_STRING(attr->lcname);
 
 			for (i = 0; i < attr->argc; i++) {
-				zend_persist_zval_calc(&attr->argv[i]);
+				ADD_INTERNED_STRING(attr->args[i].name);
+				zend_persist_zval_calc(&attr->args[i].value);
 			}
 		} ZEND_HASH_FOREACH_END();
 	}

ext/reflection/php_reflection.c

@@ -6494,7 +6494,12 @@ ZEND_METHOD(ReflectionAttribute, getArguments)
 			RETURN_THROWS();
 		}
 
-		add_next_index_zval(return_value, &tmp);
+		if (attr->data->args[i].name) {
+			/* We ensured at compile-time that there are no duplicate parameter names. */
+			zend_hash_add_new(Z_ARRVAL_P(return_value), attr->data->args[i].name, &tmp);
+		} else {
+			add_next_index_zval(return_value, &tmp);
+		}
 	}
 }
 /* }}} */