RFC: https://wiki.php.net/rfc/mixed_type_v2
. Added support for Attributes
RFC: https://wiki.php.net/rfc/attributes_v2
+ . Added support for constructor property promotion (declaring properties in
+ the constructor signature).
+ RFC: https://wiki.php.net/rfc/constructor_promotion
- Date:
. Added DateTime::createFromInterface() and
--- /dev/null
+--TEST--
+Constructor promotion cannot be used inside an abstract constructor
+--FILE--
+<?php
+
+abstract class Test {
+ abstract public function __construct(public int $x);
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot declare promoted property in an abstract constructor in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotion only permits visibility modifiers
+--FILE--
+<?php
+
+class Test {
+ public function __construct(public static $x) {}
+}
+
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected 'static' (T_STATIC), expecting variable (T_VARIABLE) in %s on line %d
--- /dev/null
+--TEST--
+Attributes on promoted properties are assigned to both the property and parameter
+--FILE--
+<?php
+
+class Test {
+ public function __construct(
+ <<NonNegative>>
+ public int $num,
+ ) {}
+}
+
+$prop = new ReflectionProperty(Test::class, 'num');
+var_dump($prop->getAttributes()[0]->getName());
+
+$param = new ReflectionParameter([Test::class, '__construct'], 'num');
+var_dump($param->getAttributes()[0]->getName());
+
+?>
+--EXPECT--
+string(11) "NonNegative"
+string(11) "NonNegative"
--- /dev/null
+--TEST--
+Constructor promotion (basic example)
+--FILE--
+<?php
+
+class Point {
+ public function __construct(public int $x, public int $y, public int $z) {}
+}
+
+$point = new Point(1, 2, 3);
+
+// Check that properties really are typed.
+try {
+ $point->x = "foo";
+} catch (TypeError $e) {
+ echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+Cannot assign string to property Point::$x of type int
--- /dev/null
+--TEST--
+Constructor promotion of by-ref parameter
+--FILE--
+<?php
+
+class Ary {
+ public function __construct(public array &$array) {}
+}
+
+$array = [];
+$ary = new Ary($array);
+$array[] = 42;
+var_dump($ary->array);
+
+?>
+--EXPECT--
+array(1) {
+ [0]=>
+ int(42)
+}
--- /dev/null
+--TEST--
+Type of promoted property may not be callable
+--FILE--
+<?php
+
+class Test {
+ public function __construct(public callable $callable) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Property Test::$callable cannot have type callable in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotion with default values
+--FILE--
+<?php
+
+class Point {
+ public function __construct(
+ public float $x = 0.0,
+ public float $y = 1.0,
+ public float $z = 2.0
+ ) {}
+}
+
+var_dump(new Point(10.0));
+var_dump(new Point(10.0, 11.0));
+var_dump(new Point(10.0, 11.0, 12.0));
+
+?>
+--EXPECT--
+object(Point)#1 (3) {
+ ["x"]=>
+ float(10)
+ ["y"]=>
+ float(1)
+ ["z"]=>
+ float(2)
+}
+object(Point)#1 (3) {
+ ["x"]=>
+ float(10)
+ ["y"]=>
+ float(11)
+ ["z"]=>
+ float(2)
+}
+object(Point)#1 (3) {
+ ["x"]=>
+ float(10)
+ ["y"]=>
+ float(11)
+ ["z"]=>
+ float(12)
+}
--- /dev/null
+--TEST--
+Constructor promotion cannot be used in a free function
+--FILE--
+<?php
+
+function __construct(public $prop) {}
+
+?>
+--EXPECTF--
+Fatal error: Cannot declare promoted property outside a constructor in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotion cannot be used inside an abstract constructor (interface variant)
+--FILE--
+<?php
+
+interface Test {
+ public function __construct(public int $x);
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot declare promoted property in an abstract constructor in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotiong mixed with other properties, parameters and code
+--FILE--
+<?php
+
+class Test {
+ public string $prop2;
+
+ public function __construct(public string $prop1 = "", $param2 = "") {
+ $this->prop2 = $prop1 . $param2;
+ }
+}
+
+var_dump(new Test("Foo", "Bar"));
+echo "\n";
+echo new ReflectionClass(Test::class), "\n";
+
+?>
+--EXPECTF--
+object(Test)#1 (2) {
+ ["prop2"]=>
+ string(6) "FooBar"
+ ["prop1"]=>
+ string(3) "Foo"
+}
+
+Class [ <user> class Test ] {
+ @@ %s
+
+ - Constants [0] {
+ }
+
+ - Static properties [0] {
+ }
+
+ - Static methods [0] {
+ }
+
+ - Properties [2] {
+ Property [ public string $prop2 ]
+ Property [ public string $prop1 ]
+ }
+
+ - Methods [1] {
+ Method [ <user, ctor> public method __construct ] {
+ @@ %s
+
+ - Parameters [2] {
+ Parameter #0 [ <optional> string $prop1 = '' ]
+ Parameter #1 [ <optional> $param2 = '' ]
+ }
+ }
+ }
+}
--- /dev/null
+--TEST--
+Constructor promotion can only be used in constructors ... duh
+--FILE--
+<?php
+
+class Test {
+ public function foobar(public int $x, public int $y) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot declare promoted property outside a constructor in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotion with null default, requires an explicitly nullable type
+--FILE--
+<?php
+
+class Test {
+ public function __construct(public int $x = null) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use null as default value for parameter $x of type int in %s on line %d
--- /dev/null
+--TEST--
+Clash between promoted and explicit property
+--FILE--
+<?php
+
+class Test {
+ public $prop;
+
+ public function __construct(public $prop) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot redeclare Test::$prop in %s on line %d
--- /dev/null
+--TEST--
+Constructor promotion can be used inside a trait
+--FILE--
+<?php
+
+trait Test {
+ public function __construct(public $prop) {}
+}
+
+class Test2 {
+ use Test;
+}
+
+var_dump(new Test2(42));
+
+?>
+--EXPECT--
+object(Test2)#1 (1) {
+ ["prop"]=>
+ int(42)
+}
--- /dev/null
+--TEST--
+Cannot use constructor promotion with variadic parameter
+--FILE--
+<?php
+
+class Test {
+ public function __construct(public string ...$strings) {}
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot declare variadic promoted property in %s on line %d
return ast;
}
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_5(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4, zend_ast *child5) {
+ zend_ast *ast;
+ uint32_t lineno;
+
+ ZEND_ASSERT(kind >> ZEND_AST_NUM_CHILDREN_SHIFT == 5);
+ ast = zend_ast_alloc(zend_ast_size(5));
+ ast->kind = kind;
+ ast->attr = 0;
+ ast->child[0] = child1;
+ ast->child[1] = child2;
+ ast->child[2] = child3;
+ ast->child[3] = child4;
+ ast->child[4] = child5;
+ if (child1) {
+ lineno = zend_ast_get_lineno(child1);
+ } else if (child2) {
+ lineno = zend_ast_get_lineno(child2);
+ } else if (child3) {
+ lineno = zend_ast_get_lineno(child3);
+ } else if (child4) {
+ lineno = zend_ast_get_lineno(child4);
+ } else if (child5) {
+ lineno = zend_ast_get_lineno(child5);
+ } else {
+ lineno = CG(zend_lineno);
+ }
+ ast->lineno = lineno;
+
+ return ast;
+}
+
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_0(zend_ast_kind kind) {
zend_ast *ast;
zend_ast_list *list;
/* 4 child nodes */
ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT,
ZEND_AST_FOREACH,
- ZEND_AST_PARAM,
+
+ /* 5 child nodes */
+ ZEND_AST_PARAM = 5 << ZEND_AST_NUM_CHILDREN_SHIFT,
};
typedef uint16_t zend_ast_kind;
#if ZEND_AST_SPEC
# define ZEND_AST_SPEC_CALL(name, ...) \
- ZEND_EXPAND_VA(ZEND_AST_SPEC_CALL_(name, __VA_ARGS__, _4, _3, _2, _1, _0)(__VA_ARGS__))
-# define ZEND_AST_SPEC_CALL_(name, _, _4, _3, _2, _1, suffix, ...) \
+ ZEND_EXPAND_VA(ZEND_AST_SPEC_CALL_(name, __VA_ARGS__, _5, _4, _3, _2, _1, _0)(__VA_ARGS__))
+# define ZEND_AST_SPEC_CALL_(name, _, _5, _4, _3, _2, _1, suffix, ...) \
name ## suffix
# define ZEND_AST_SPEC_CALL_EX(name, ...) \
- ZEND_EXPAND_VA(ZEND_AST_SPEC_CALL_EX_(name, __VA_ARGS__, _4, _3, _2, _1, _0)(__VA_ARGS__))
-# define ZEND_AST_SPEC_CALL_EX_(name, _, _5, _4, _3, _2, _1, suffix, ...) \
+ ZEND_EXPAND_VA(ZEND_AST_SPEC_CALL_EX_(name, __VA_ARGS__, _5, _4, _3, _2, _1, _0)(__VA_ARGS__))
+# define ZEND_AST_SPEC_CALL_EX_(name, _, _6, _5, _4, _3, _2, _1, suffix, ...) \
name ## suffix
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_0(zend_ast_kind kind);
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_2(zend_ast_kind kind, zend_ast *child1, zend_ast *child2);
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_3(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3);
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_4(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4);
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_5(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4, zend_ast *child5);
static zend_always_inline zend_ast * zend_ast_create_ex_0(zend_ast_kind kind, zend_ast_attr attr) {
zend_ast *ast = zend_ast_create_0(kind);
ast->attr = attr;
return ast;
}
+static zend_always_inline zend_ast * zend_ast_create_ex_5(zend_ast_kind kind, zend_ast_attr attr, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4, zend_ast *child5) {
+ zend_ast *ast = zend_ast_create_5(kind, child1, child2, child3, child4, child5);
+ ast->attr = attr;
+ return ast;
+}
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_0(zend_ast_kind kind);
ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_1(zend_ast_kind kind, zend_ast *child);
zend_ast *var_ast = param_ast->child[1];
zend_ast *default_ast = param_ast->child[2];
zend_ast *attributes_ast = param_ast->child[3];
+ zend_ast *doc_comment_ast = param_ast->child[4];
zend_string *name = zval_make_interned_string(zend_ast_get_zval(var_ast));
zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0;
zend_bool is_variadic = (param_ast->attr & ZEND_PARAM_VARIADIC) != 0;
+ uint32_t visibility =
+ param_ast->attr & (ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE);
znode var_node, default_node;
zend_uchar opcode;
if (type_ast) {
uint32_t default_type = default_ast ? Z_TYPE(default_node.u.constant) : IS_UNDEF;
+ zend_bool force_nullable = default_type == IS_NULL && !visibility;
op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
- arg_info->type = zend_compile_typename(
- type_ast, default_type == IS_NULL, /* use_arena */ 0);
+ arg_info->type = zend_compile_typename(type_ast, force_nullable, /* use_arena */ 0);
if (ZEND_TYPE_FULL_MASK(arg_info->type) & MAY_BE_VOID) {
zend_error_noreturn(E_COMPILE_ERROR, "void cannot be used as a parameter type");
}
- if (default_type > IS_NULL && default_type != IS_CONSTANT_AST
+ if (default_type != IS_UNDEF && default_type != IS_CONSTANT_AST && !force_nullable
&& !zend_is_valid_default_value(arg_info->type, &default_node.u.constant)) {
zend_string *type_str = zend_type_to_string(arg_info->type);
zend_error_noreturn(E_COMPILE_ERROR,
zend_alloc_cache_slots(zend_type_get_num_classes(arg_info->type));
}
- ZEND_TYPE_FULL_MASK(arg_info->type) |= _ZEND_ARG_INFO_FLAGS(is_ref, is_variadic);
+ uint32_t arg_info_flags = _ZEND_ARG_INFO_FLAGS(is_ref, is_variadic)
+ | (visibility ? _ZEND_IS_PROMOTED_BIT : 0);
+ ZEND_TYPE_FULL_MASK(arg_info->type) |= arg_info_flags;
if (opcode == ZEND_RECV) {
opline->op2.num = type_ast ?
ZEND_TYPE_FULL_MASK(arg_info->type) : MAY_BE_ANY;
}
+
+ if (visibility) {
+ zend_op_array *op_array = CG(active_op_array);
+ zend_class_entry *scope = op_array->scope;
+ zend_bool is_ctor =
+ scope && zend_string_equals_literal_ci(op_array->function_name, "__construct");
+ if (!is_ctor) {
+ zend_error_noreturn(E_COMPILE_ERROR,
+ "Cannot declare promoted property outside a constructor");
+ }
+ if ((op_array->fn_flags & ZEND_ACC_ABSTRACT)
+ || (scope->ce_flags & ZEND_ACC_INTERFACE)) {
+ zend_error_noreturn(E_COMPILE_ERROR,
+ "Cannot declare promoted property in an abstract constructor");
+ }
+ if (is_variadic) {
+ zend_error_noreturn(E_COMPILE_ERROR,
+ "Cannot declare variadic promoted property");
+ }
+ if (zend_hash_exists(&scope->properties_info, name)) {
+ zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s",
+ ZSTR_VAL(scope->name), ZSTR_VAL(name));
+ }
+ if (ZEND_TYPE_FULL_MASK(arg_info->type) & MAY_BE_CALLABLE) {
+ zend_string *str = zend_type_to_string(arg_info->type);
+ zend_error_noreturn(E_COMPILE_ERROR,
+ "Property %s::$%s cannot have type %s",
+ ZSTR_VAL(scope->name), ZSTR_VAL(name), ZSTR_VAL(str));
+ }
+
+ /* Always use uninitialized as the default. */
+ zval default_value;
+ ZVAL_UNDEF(&default_value);
+
+ /* Recompile the type, as it has different memory management requirements. */
+ zend_type type = ZEND_TYPE_INIT_NONE(0);
+ if (type_ast) {
+ type = zend_compile_typename(type_ast, /* force_allow_null */ 0, /* use_arena */ 1);
+ }
+
+ zend_string *doc_comment =
+ doc_comment_ast ? zend_string_copy(zend_ast_get_str(doc_comment_ast)) : NULL;
+ zend_property_info *prop = zend_declare_typed_property(
+ scope, name, &default_value, visibility | ZEND_ACC_PROMOTED, doc_comment, type);
+ if (attributes_ast) {
+ zend_compile_attributes(
+ &prop->attributes, attributes_ast, 0, ZEND_ATTRIBUTE_TARGET_PROPERTY);
+ }
+ }
}
/* These are assigned at the end to avoid uninitialized memory in case of an error */
op_array->num_args--;
}
zend_set_function_arg_flags((zend_function*)op_array);
+
+ for (i = 0; i < list->children; i++) {
+ zend_ast *param_ast = list->child[i];
+ zend_bool is_ref = (param_ast->attr & ZEND_PARAM_REF) != 0;
+ uint32_t visibility =
+ param_ast->attr & (ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE);
+ if (!visibility) {
+ continue;
+ }
+
+ /* Emit $this->prop = $prop for promoted properties. */
+ zend_string *name = zend_ast_get_str(param_ast->child[1]);
+ znode name_node, value_node;
+ name_node.op_type = IS_CONST;
+ ZVAL_STR_COPY(&name_node.u.constant, name);
+ value_node.op_type = IS_CV;
+ value_node.u.op.var = lookup_cv(name);
+
+ zend_op *opline = zend_emit_op(NULL,
+ is_ref ? ZEND_ASSIGN_OBJ_REF : ZEND_ASSIGN_OBJ, NULL, &name_node);
+ opline->extended_value = zend_alloc_cache_slots(3);
+ zend_emit_op_data(&value_node);
+ }
}
/* }}} */
/* Static method or property | | | */
#define ZEND_ACC_STATIC (1 << 4) /* | X | X | */
/* | | | */
+/* Promoted property / parameter | | | */
+#define ZEND_ACC_PROMOTED (1 << 5) /* | | X | X */
+/* | | | */
/* Final class or method | | | */
#define ZEND_ACC_FINAL (1 << 5) /* X | X | | */
/* | | | */
#define ZEND_FETCH_CLASS_ALLOW_UNLINKED 0x0400
#define ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED 0x0800
-#define ZEND_PARAM_REF (1<<0)
-#define ZEND_PARAM_VARIADIC (1<<1)
+/* These should not clash with ZEND_ACC_(PUBLIC|PROTECTED|PRIVATE) */
+#define ZEND_PARAM_REF (1<<3)
+#define ZEND_PARAM_VARIADIC (1<<4)
#define ZEND_NAME_FQ 0
#define ZEND_NAME_NOT_FQ 1
/* The send mode and is_variadic flag are stored as part of zend_type */
#define _ZEND_SEND_MODE_SHIFT _ZEND_TYPE_EXTRA_FLAGS_SHIFT
#define _ZEND_IS_VARIADIC_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 2))
+#define _ZEND_IS_PROMOTED_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 3))
#define ZEND_ARG_SEND_MODE(arg_info) \
((ZEND_TYPE_FULL_MASK((arg_info)->type) >> _ZEND_SEND_MODE_SHIFT) & 3)
#define ZEND_ARG_IS_VARIADIC(arg_info) \
((ZEND_TYPE_FULL_MASK((arg_info)->type) & _ZEND_IS_VARIADIC_BIT) != 0)
+#define ZEND_ARG_IS_PROMOTED(arg_info) \
+ ((ZEND_TYPE_FULL_MASK((arg_info)->type) & _ZEND_IS_PROMOTED_BIT) != 0)
#define ZEND_DIM_IS (1 << 0) /* isset fetch needed for null coalesce */
#define ZEND_DIM_ALTERNATIVE_SYNTAX (1 << 1) /* deprecated curly brace usage */
%type <ast> attribute_arguments attribute_decl attribute attributes
%type <num> returns_ref function fn is_reference is_variadic variable_modifiers
-%type <num> method_modifiers non_empty_member_modifiers member_modifier
+%type <num> method_modifiers non_empty_member_modifiers member_modifier optional_visibility_modifier
%type <num> class_modifiers class_modifier use_type backup_fn_flags
%type <ptr> backup_lex_pos
| parameter { $$ = $1; }
;
+optional_visibility_modifier:
+ %empty { $$ = 0; }
+ | T_PUBLIC { $$ = ZEND_ACC_PUBLIC; }
+ | T_PROTECTED { $$ = ZEND_ACC_PROTECTED; }
+ | T_PRIVATE { $$ = ZEND_ACC_PRIVATE; }
+;
+
parameter:
- optional_type_without_static is_reference is_variadic T_VARIABLE
- { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $2 | $3, $1, $4, NULL, NULL); }
- | optional_type_without_static is_reference is_variadic T_VARIABLE '=' expr
- { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $2 | $3, $1, $4, $6, NULL); }
+ optional_visibility_modifier optional_type_without_static
+ is_reference is_variadic T_VARIABLE backup_doc_comment
+ { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $1 | $3 | $4, $2, $5, NULL,
+ NULL, $6 ? zend_ast_create_zval_from_str($6) : NULL); }
+ | optional_visibility_modifier optional_type_without_static
+ is_reference is_variadic T_VARIABLE backup_doc_comment '=' expr
+ { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $1 | $3 | $4, $2, $5, $8,
+ NULL, $6 ? zend_ast_create_zval_from_str($6) : NULL); }
;
{ $$ = zend_ast_create_decl(ZEND_AST_CLOSURE, $2 | $13, $1, $3,
zend_string_init("{closure}", sizeof("{closure}") - 1, 0),
$5, $7, $11, $8, NULL); CG(extra_fn_flags) = $9; }
- | fn returns_ref '(' parameter_list ')' return_type backup_doc_comment T_DOUBLE_ARROW backup_fn_flags backup_lex_pos expr backup_fn_flags
- { $$ = zend_ast_create_decl(ZEND_AST_ARROW_FUNC, $2 | $12, $1, $7,
- zend_string_init("{closure}", sizeof("{closure}") - 1, 0), $4, NULL,
- zend_ast_create(ZEND_AST_RETURN, $11), $6, NULL);
+ | fn returns_ref backup_doc_comment '(' parameter_list ')' return_type
+ T_DOUBLE_ARROW backup_fn_flags backup_lex_pos expr backup_fn_flags
+ { $$ = zend_ast_create_decl(ZEND_AST_ARROW_FUNC, $2 | $12, $1, $3,
+ zend_string_init("{closure}", sizeof("{closure}") - 1, 0), $5, NULL,
+ zend_ast_create(ZEND_AST_RETURN, $11), $7, NULL);
((zend_ast_decl *) $$)->lex_pos = $10;
CG(extra_fn_flags) = $9; }
;
}
/* }}} */
+/* {{{ proto public bool ReflectionParameter::isPromoted()
+ Returns this constructor parameter has been promoted to a property */
+ZEND_METHOD(ReflectionParameter, isPromoted)
+{
+ reflection_object *intern;
+ parameter_reference *param;
+
+ if (zend_parse_parameters_none() == FAILURE) {
+ RETURN_THROWS();
+ }
+ GET_REFLECTION_OBJECT_PTR(param);
+
+ RETVAL_BOOL(ZEND_ARG_IS_PROMOTED(param->arg_info));
+}
+/* }}} */
+
/* {{{ proto public bool ReflectionType::allowsNull()
Returns whether parameter MAY be null */
ZEND_METHOD(ReflectionType, allowsNull)
}
/* }}} */
+/* {{{ proto public bool ReflectionProperty::isPromoted()
+ Returns whether this property has been promoted from a constructor */
+ZEND_METHOD(ReflectionProperty, isPromoted)
+{
+ _property_check_flag(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_ACC_PROMOTED);
+}
+/* }}} */
+
/* {{{ proto public int ReflectionProperty::getModifiers()
Returns a bitfield of the access modifiers for this property */
ZEND_METHOD(ReflectionProperty, getModifiers)
/** @return bool */
public function isDefault() {}
+ public function isPromoted(): bool {}
+
/** @return int */
public function getModifiers() {}
/** @return bool */
public function isVariadic() {}
+ public function isPromoted(): bool {}
+
/** @return ReflectionAttribute[] */
public function getAttributes(?string $name = null, int $flags = 0): array {}
}
#define arginfo_class_ReflectionProperty_isDefault arginfo_class_ReflectionFunctionAbstract___clone
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ReflectionProperty_isPromoted, 0, 0, _IS_BOOL, 0)
+ZEND_END_ARG_INFO()
+
#define arginfo_class_ReflectionProperty_getModifiers arginfo_class_ReflectionFunctionAbstract___clone
#define arginfo_class_ReflectionProperty_getDeclaringClass arginfo_class_ReflectionFunctionAbstract___clone
#define arginfo_class_ReflectionProperty_hasType arginfo_class_ReflectionFunctionAbstract___clone
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ReflectionProperty_hasDefaultValue, 0, 0, _IS_BOOL, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_class_ReflectionProperty_hasDefaultValue arginfo_class_ReflectionProperty_isPromoted
#define arginfo_class_ReflectionProperty_getDefaultValue arginfo_class_ReflectionFunctionAbstract___clone
#define arginfo_class_ReflectionParameter_isVariadic arginfo_class_ReflectionFunctionAbstract___clone
+#define arginfo_class_ReflectionParameter_isPromoted arginfo_class_ReflectionProperty_isPromoted
+
#define arginfo_class_ReflectionParameter_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes
#define arginfo_class_ReflectionType___clone arginfo_class_ReflectionFunctionAbstract___clone
ZEND_METHOD(ReflectionProperty, isProtected);
ZEND_METHOD(ReflectionProperty, isStatic);
ZEND_METHOD(ReflectionProperty, isDefault);
+ZEND_METHOD(ReflectionProperty, isPromoted);
ZEND_METHOD(ReflectionProperty, getModifiers);
ZEND_METHOD(ReflectionProperty, getDeclaringClass);
ZEND_METHOD(ReflectionProperty, getDocComment);
ZEND_METHOD(ReflectionParameter, isDefaultValueConstant);
ZEND_METHOD(ReflectionParameter, getDefaultValueConstantName);
ZEND_METHOD(ReflectionParameter, isVariadic);
+ZEND_METHOD(ReflectionParameter, isPromoted);
ZEND_METHOD(ReflectionParameter, getAttributes);
ZEND_METHOD(ReflectionType, allowsNull);
ZEND_METHOD(ReflectionType, __toString);
ZEND_ME(ReflectionProperty, isProtected, arginfo_class_ReflectionProperty_isProtected, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionProperty, isStatic, arginfo_class_ReflectionProperty_isStatic, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionProperty, isDefault, arginfo_class_ReflectionProperty_isDefault, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionProperty, isPromoted, arginfo_class_ReflectionProperty_isPromoted, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionProperty, getModifiers, arginfo_class_ReflectionProperty_getModifiers, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionProperty, getDeclaringClass, arginfo_class_ReflectionProperty_getDeclaringClass, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionProperty, getDocComment, arginfo_class_ReflectionProperty_getDocComment, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionParameter, isDefaultValueConstant, arginfo_class_ReflectionParameter_isDefaultValueConstant, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionParameter, getDefaultValueConstantName, arginfo_class_ReflectionParameter_getDefaultValueConstantName, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionParameter, isVariadic, arginfo_class_ReflectionParameter_isVariadic, ZEND_ACC_PUBLIC)
+ ZEND_ME(ReflectionParameter, isPromoted, arginfo_class_ReflectionParameter_isPromoted, ZEND_ACC_PUBLIC)
ZEND_ME(ReflectionParameter, getAttributes, arginfo_class_ReflectionParameter_getAttributes, ZEND_ACC_PUBLIC)
ZEND_FE_END
};
) {
};
+/** Correct docblock */
+$func2 = fn(
+ /** wrong docblock */
+ $arg
+) => null;
+
$reflectionFunction = new ReflectionFunction('foo');
$reflectionClass = new ReflectionClass(Foo::class);
$reflectionClosure = new ReflectionFunction($func);
+$reflectionArrowFn = new ReflectionFunction($func2);
echo $reflectionFunction->getDocComment() . PHP_EOL;
echo $reflectionClass->getMethod('bar')->getDocComment() . PHP_EOL;
echo $reflectionClosure->getDocComment() . PHP_EOL;
+echo $reflectionArrowFn->getDocComment() . PHP_EOL;
echo "Done\n";
?>
/** Correct docblock */
/** Correct docblock */
/** Correct docblock */
+/** Correct docblock */
Done
--- /dev/null
+--TEST--
+Using Reflection on promoted properties
+--FILE--
+<?php
+
+class Test {
+ public $z;
+ public function __construct(
+ public int $x,
+ /** @SomeAnnotation() */
+ public string $y = "123",
+ string $z = "abc",
+ ) {}
+}
+
+$rc = new ReflectionClass(Test::class);
+echo $rc, "\n";
+
+$y = $rc->getProperty('y');
+var_dump($y->isPromoted());
+var_dump($y->getDocComment());
+$z = $rc->getProperty('z');
+var_dump($z->isPromoted());
+
+echo "\n";
+
+$rp = new ReflectionParameter([Test::class, '__construct'], 'y');
+var_dump($rp->isPromoted());
+$rp = new ReflectionParameter([Test::class, '__construct'], 'z');
+var_dump($rp->isPromoted());
+
+?>
+--EXPECTF--
+Class [ <user> class Test ] {
+ @@ %s 3-11
+
+ - Constants [0] {
+ }
+
+ - Static properties [0] {
+ }
+
+ - Static methods [0] {
+ }
+
+ - Properties [3] {
+ Property [ public $z = NULL ]
+ Property [ public int $x ]
+ Property [ public string $y ]
+ }
+
+ - Methods [1] {
+ Method [ <user, ctor> public method __construct ] {
+ @@ %s 5 - 10
+
+ - Parameters [3] {
+ Parameter #0 [ <required> int $x ]
+ Parameter #1 [ <optional> string $y = '123' ]
+ Parameter #2 [ <optional> string $z = 'abc' ]
+ }
+ }
+ }
+}
+
+bool(true)
+string(24) "/** @SomeAnnotation() */"
+bool(false)
+
+bool(true)
+bool(false)
projects / php / commitdiff