diff --git a/Zend/tests/attributes/001_placement.phpt b/Zend/tests/attributes/001_placement.phpt new file mode 100644 index 0000000000000..02e6c27aa415c --- /dev/null +++ b/Zend/tests/attributes/001_placement.phpt @@ -0,0 +1,127 @@ +--TEST-- +Attributes can be placed on all supported elements. +--FILE-- +> +class Foo +{ + <> + public const FOO = 'foo', BAR = 'bar'; + + <> + public $x, $y; + + <> + public function foo(<> $a, <> $b) { } +} + +$object = new <> class () { }; + +<> +function f1() { } + +$f2 = <> function () { }; + +$f3 = <> fn () => 1; + +$ref = new \ReflectionClass(Foo::class); + +$sources = [ + $ref, + $ref->getReflectionConstant('FOO'), + $ref->getReflectionConstant('BAR'), + $ref->getProperty('x'), + $ref->getProperty('y'), + $ref->getMethod('foo'), + $ref->getMethod('foo')->getParameters()[0], + $ref->getMethod('foo')->getParameters()[1], + new \ReflectionObject($object), + new \ReflectionFunction('f1'), + new \ReflectionFunction($f2), + new \ReflectionFunction($f3) +]; + +foreach ($sources as $r) { + $attr = $r->getAttributes(); + var_dump(count($attr)); + + foreach ($attr as $a) { + var_dump($a->getName(), $a->getArguments()); + } +} + +?> +--EXPECT-- +int(1) +string(2) "A1" +array(1) { + [0]=> + int(1) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(2) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(2) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(3) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(3) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(4) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(5) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(6) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(7) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(8) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(9) +} +int(1) +string(2) "A1" +array(1) { + [0]=> + int(10) +} diff --git a/Zend/tests/attributes/002_rfcexample.phpt b/Zend/tests/attributes/002_rfcexample.phpt new file mode 100644 index 0000000000000..0d3879877e9d9 --- /dev/null +++ b/Zend/tests/attributes/002_rfcexample.phpt @@ -0,0 +1,43 @@ +--TEST-- +Attributes: Example from Attributes RFC +--FILE-- +> + class SingleArgument { + public $argumentValue; + + public function __construct($argumentValue) { + $this->argumentValue = $argumentValue; + } + } +} + +namespace { + use My\Attributes\SingleArgument; + + <> + class Foo { + } + + $reflectionClass = new \ReflectionClass(Foo::class); + $attributes = $reflectionClass->getAttributes(); + + var_dump($attributes[0]->getName()); + var_dump($attributes[0]->getArguments()); + var_dump($attributes[0]->newInstance()); +} +?> +--EXPECTF-- +string(28) "My\Attributes\SingleArgument" +array(1) { + [0]=> + string(11) "Hello World" +} +object(My\Attributes\SingleArgument)#3 (1) { + ["argumentValue"]=> + string(11) "Hello World" +} diff --git a/Zend/tests/attributes/003_ast_nodes.phpt b/Zend/tests/attributes/003_ast_nodes.phpt new file mode 100644 index 0000000000000..cf43e663d5197 --- /dev/null +++ b/Zend/tests/attributes/003_ast_nodes.phpt @@ -0,0 +1,109 @@ +--TEST-- +Attributes can deal with AST nodes. +--FILE-- + V1])>> +class C1 +{ + public const BAR = 'bar'; +} + +$ref = new \ReflectionClass(C1::class); +$attr = $ref->getAttributes(); +var_dump(count($attr)); + +$args = $attr[0]->getArguments(); +var_dump(count($args), $args[0][V1] === V1); + +echo "\n"; + +<> +class C2 { } + +$ref = new \ReflectionClass(C2::class); +$attr = $ref->getAttributes(); +var_dump(count($attr)); + +$args = $attr[0]->getArguments(); +var_dump(count($args)); +var_dump($args[0] === V1); +var_dump($args[1] === 3); +var_dump($args[2] === C1::class); + +echo "\n"; + +<> +class C3 +{ + private const FOO = 'foo'; +} + +$ref = new \ReflectionClass(C3::class); +$attr = $ref->getAttributes(); +var_dump(count($attr)); + +$args = $attr[0]->getArguments(); +var_dump(count($args)); +var_dump($args[0] === 'foo'); +var_dump($args[1] === C1::BAR); + +echo "\n"; + +<> 1)>> +class C4 {} +$ref = new \ReflectionClass(C4::class); +var_dump($ref->getAttributes()[0]->getArguments()); + +echo "\n"; + +<> +class C5 +{ + public function __construct() { } +} + +$ref = new \ReflectionFunction(<> function () { }); +$attr = $ref->getAttributes(); +var_dump(count($attr)); + +try { + $attr[0]->getArguments(); +} catch (\Error $e) { + var_dump($e->getMessage()); +} + +try { + $attr[0]->newInstance(); +} catch (\Error $e) { + var_dump($e->getMessage()); +} + +?> +--EXPECT-- +int(1) +int(1) +bool(true) + +int(1) +int(3) +bool(true) +bool(true) +bool(true) + +int(1) +int(2) +bool(true) +bool(true) + +array(1) { + [0]=> + int(2) +} + +int(1) +string(30) "Class 'MissingClass' not found" +string(30) "Class 'MissingClass' not found" + diff --git a/Zend/tests/attributes/004_name_resolution.phpt b/Zend/tests/attributes/004_name_resolution.phpt new file mode 100644 index 0000000000000..a2284e2c433c8 --- /dev/null +++ b/Zend/tests/attributes/004_name_resolution.phpt @@ -0,0 +1,78 @@ +--TEST-- +Resolve attribute names +--FILE-- + $attribute->getName(), 'args' => $attribute->getArguments()]; + } + var_dump($arr); +} + +namespace Doctrine\ORM\Mapping { + class Entity { + } +} + +namespace Foo { + use Doctrine\ORM\Mapping\Entity; + use Doctrine\ORM\Mapping as ORM; + + <> + <> + <<\Doctrine\ORM\Mapping\Entity("absolute from namespace")>> + <<\Entity("import absolute from global")>> + function foo() { + } +} + +namespace { + class Entity {} + + dump_attributes((new ReflectionFunction('Foo\foo'))->getAttributes()); +} +?> +--EXPECTF-- +array(4) { + [0]=> + array(2) { + ["name"]=> + string(27) "Doctrine\ORM\Mapping\Entity" + ["args"]=> + array(1) { + [0]=> + string(14) "imported class" + } + } + [1]=> + array(2) { + ["name"]=> + string(27) "Doctrine\ORM\Mapping\Entity" + ["args"]=> + array(1) { + [0]=> + string(18) "imported namespace" + } + } + [2]=> + array(2) { + ["name"]=> + string(27) "Doctrine\ORM\Mapping\Entity" + ["args"]=> + array(1) { + [0]=> + string(23) "absolute from namespace" + } + } + [3]=> + array(2) { + ["name"]=> + string(6) "Entity" + ["args"]=> + array(1) { + [0]=> + string(27) "import absolute from global" + } + } +} diff --git a/Zend/tests/attributes/005_objects.phpt b/Zend/tests/attributes/005_objects.phpt new file mode 100644 index 0000000000000..baf51af775bf2 --- /dev/null +++ b/Zend/tests/attributes/005_objects.phpt @@ -0,0 +1,120 @@ +--TEST-- +Attributes can be converted into objects. +--FILE-- +> +class A1 +{ + public string $name; + public int $ttl; + + public function __construct(string $name, int $ttl = 50) + { + $this->name = $name; + $this->ttl = $ttl; + } +} + +$ref = new \ReflectionFunction(<> function () { }); + +foreach ($ref->getAttributes() as $attr) { + $obj = $attr->newInstance(); + + var_dump(get_class($obj), $obj->name, $obj->ttl); +} + +echo "\n"; + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\ArgumentCountError $e) { + var_dump('ERROR 1', $e->getMessage()); +} + +echo "\n"; + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\TypeError $e) { + var_dump('ERROR 2', $e->getMessage()); +} + +echo "\n"; + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\Error $e) { + var_dump('ERROR 3', $e->getMessage()); +} + +echo "\n"; + +<> +class A3 +{ + private function __construct() { } +} + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\Error $e) { + var_dump('ERROR 4', $e->getMessage()); +} + +echo "\n"; + +<> +class A4 { } + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\Error $e) { + var_dump('ERROR 5', $e->getMessage()); +} + +echo "\n"; + +class A5 { } + +$ref = new \ReflectionFunction(<> function () { }); + +try { + $ref->getAttributes()[0]->newInstance(); +} catch (\Error $e) { + var_dump('ERROR 6', $e->getMessage()); +} + +?> +--EXPECT-- +string(2) "A1" +string(4) "test" +int(50) + +string(7) "ERROR 1" +string(81) "Too few arguments to function A1::__construct(), 0 passed and at least 1 expected" + +string(7) "ERROR 2" +string(74) "A1::__construct(): Argument #1 ($name) must be of type string, array given" + +string(7) "ERROR 3" +string(30) "Attribute class 'A2' not found" + +string(7) "ERROR 4" +string(50) "Attribute constructor of class 'A3' must be public" + +string(7) "ERROR 5" +string(71) "Attribute class 'A4' does not have a constructor, cannot pass arguments" + +string(7) "ERROR 6" +string(78) "Attempting to use class 'A5' as attribute that does not have <>." diff --git a/Zend/tests/attributes/006_filter.phpt b/Zend/tests/attributes/006_filter.phpt new file mode 100644 index 0000000000000..78f5b9709f50b --- /dev/null +++ b/Zend/tests/attributes/006_filter.phpt @@ -0,0 +1,112 @@ +--TEST-- +Attributes can be filtered by name and base type. +--FILE-- +> <> function () { }); +$attr = $ref->getAttributes(A3::class); + +var_dump(count($attr)); + +$ref = new \ReflectionFunction(<> <> function () { }); +$attr = $ref->getAttributes(A2::class); + +var_dump(count($attr), $attr[0]->getName()); + +$ref = new \ReflectionFunction(<> <> <> function () { }); +$attr = $ref->getAttributes(A2::class); + +var_dump(count($attr), $attr[0]->getName(), $attr[1]->getName()); + +echo "\n"; + +interface Base { } +class A1 implements Base { } +class A2 implements Base { } +class A3 extends A2 { } + +$ref = new \ReflectionFunction(<> <> <> function () { }); +$attr = $ref->getAttributes(\stdClass::class, \ReflectionAttribute::IS_INSTANCEOF); +var_dump(count($attr)); +print_r(array_map(fn ($a) => $a->getName(), $attr)); + +$ref = new \ReflectionFunction(<> <> function () { }); +$attr = $ref->getAttributes(A1::class, \ReflectionAttribute::IS_INSTANCEOF); +var_dump(count($attr)); +print_r(array_map(fn ($a) => $a->getName(), $attr)); + +$ref = new \ReflectionFunction(<> <> function () { }); +$attr = $ref->getAttributes(Base::class, \ReflectionAttribute::IS_INSTANCEOF); +var_dump(count($attr)); +print_r(array_map(fn ($a) => $a->getName(), $attr)); + +$ref = new \ReflectionFunction(<> <> <> function () { }); +$attr = $ref->getAttributes(A2::class, \ReflectionAttribute::IS_INSTANCEOF); +var_dump(count($attr)); +print_r(array_map(fn ($a) => $a->getName(), $attr)); + +$ref = new \ReflectionFunction(<> <> <> function () { }); +$attr = $ref->getAttributes(Base::class, \ReflectionAttribute::IS_INSTANCEOF); +var_dump(count($attr)); +print_r(array_map(fn ($a) => $a->getName(), $attr)); + +echo "\n"; + +$ref = new \ReflectionFunction(function () { }); + +try { + $ref->getAttributes(A1::class, 3); +} catch (\Error $e) { + var_dump('ERROR 1', $e->getMessage()); +} + +$ref = new \ReflectionFunction(function () { }); + +try { + $ref->getAttributes(SomeMissingClass::class, \ReflectionAttribute::IS_INSTANCEOF); +} catch (\Error $e) { + var_dump('ERROR 2', $e->getMessage()); +} + +?> +--EXPECT-- +int(0) +int(1) +string(2) "A2" +int(2) +string(2) "A2" +string(2) "A2" + +int(0) +Array +( +) +int(1) +Array +( + [0] => A1 +) +int(2) +Array +( + [0] => A1 + [1] => A2 +) +int(2) +Array +( + [0] => A2 + [1] => A3 +) +int(3) +Array +( + [0] => A1 + [1] => A2 + [2] => A3 +) + +string(7) "ERROR 1" +string(39) "Invalid attribute filter flag specified" +string(7) "ERROR 2" +string(34) "Class 'SomeMissingClass' not found" diff --git a/Zend/tests/attributes/007_wrong_compiler_attributes.phpt b/Zend/tests/attributes/007_wrong_compiler_attributes.phpt new file mode 100644 index 0000000000000..2be4271c10e84 --- /dev/null +++ b/Zend/tests/attributes/007_wrong_compiler_attributes.phpt @@ -0,0 +1,14 @@ +--TEST-- +attributes: Add PhpCompilerAttribute +--FILE-- +> +class Foo +{ +} + +$ref = new ReflectionClass(Foo::class); +var_dump($ref->getAttributes()[0]->newInstance()); +--EXPECTF-- +Fatal error: The PhpCompilerAttribute can only be used by internal classes, use PhpAttribute instead in %s diff --git a/Zend/tests/attributes/008_wrong_attribution.phpt b/Zend/tests/attributes/008_wrong_attribution.phpt new file mode 100644 index 0000000000000..dcb0b6b51d0fe --- /dev/null +++ b/Zend/tests/attributes/008_wrong_attribution.phpt @@ -0,0 +1,9 @@ +--TEST-- +Attributes: Prevent PhpAttribute on non classes +--FILE-- +> +function foo() {} +--EXPECTF-- +Fatal error: Only classes can be marked with <> in %s diff --git a/Zend/tests/attributes/009_doctrine_annotations_example.phpt b/Zend/tests/attributes/009_doctrine_annotations_example.phpt new file mode 100644 index 0000000000000..38fc6389e070c --- /dev/null +++ b/Zend/tests/attributes/009_doctrine_annotations_example.phpt @@ -0,0 +1,159 @@ +--TEST-- +Doctrine-like attributes usage +--FILE-- +values = func_get_args(); } } + class Entity extends Annotation {} + class Id extends Annotation {} + class Column extends Annotation { const UNIQUE = 'unique'; const T_INTEGER = 'integer'; } + class GeneratedValue extends Annotation {} + class JoinTable extends Annotation {} + class ManyToMany extends Annotation {} + class JoinColumn extends Annotation { const UNIQUE = 'unique'; } + class InverseJoinColumn extends Annotation {} +} + +namespace Symfony\Component\Validator\Constraints { + class Annotation { public $values; public function construct() { $this->values = func_get_args(); } } + class Email extends Annotation {} + class Range extends Annotation {} +} + +namespace { +use Doctrine\ORM\Attributes as ORM; +use Symfony\Component\Validator\Constraints as Assert; + +<> +/** @ORM\Entity */ +class User +{ + /** @ORM\Id @ORM\Column(type="integer"*) @ORM\GeneratedValue */ + <><><> + private $id; + + /** + * @ORM\Column(type="string", unique=true) + * @Assert\Email(message="The email '{{ value }}' is not a valid email.") + */ + <> + < "The email '{{ value }}' is not a valid email."))>> + private $email; + + /** + * @ORM\Column(type="integer") + * @Assert\Range( + * min = 120, + * max = 180, + * minMessage = "You must be at least {{ limit }}cm tall to enter", + * maxMessage = "You cannot be taller than {{ limit }}cm to enter" + * ) + */ + < 120, "max" => 180, "minMessage" => "You must be at least {{ limit }}cm tall to enter"])>> + <> + protected $height; + + /** + * @ORM\ManyToMany(targetEntity="Phonenumber") + * @ORM\JoinTable(name="users_phonenumbers", + * joinColumns={@ORM\JoinColumn(name="user_id", referencedColumnName="id")}, + * inverseJoinColumns={@ORM\JoinColumn(name="phonenumber_id", referencedColumnName="id", unique=true)} + * ) + */ + <> + <> + <> + <> + private $phonenumbers; +} + +$class = new ReflectionClass(User::class); +$attributes = $class->getAttributes(); + +foreach ($attributes as $attribute) { + var_dump($attribute->getName(), $attribute->getArguments()); +} + +foreach ($class->getProperties() as $property) { + $attributes = $property->getAttributes(); + + foreach ($attributes as $attribute) { + var_dump($attribute->getName(), $attribute->getArguments()); + } +} +} +?> +--EXPECT-- +string(30) "Doctrine\ORM\Attributes\Entity" +array(0) { +} +string(26) "Doctrine\ORM\Attributes\Id" +array(0) { +} +string(30) "Doctrine\ORM\Attributes\Column" +array(1) { + [0]=> + string(7) "integer" +} +string(38) "Doctrine\ORM\Attributes\GeneratedValue" +array(0) { +} +string(30) "Doctrine\ORM\Attributes\Column" +array(2) { + [0]=> + string(6) "string" + [1]=> + string(6) "unique" +} +string(45) "Symfony\Component\Validator\Constraints\Email" +array(1) { + [0]=> + array(1) { + ["message"]=> + string(45) "The email '{{ value }}' is not a valid email." + } +} +string(45) "Symfony\Component\Validator\Constraints\Range" +array(1) { + [0]=> + array(3) { + ["min"]=> + int(120) + ["max"]=> + int(180) + ["minMessage"]=> + string(48) "You must be at least {{ limit }}cm tall to enter" + } +} +string(30) "Doctrine\ORM\Attributes\Column" +array(1) { + [0]=> + string(7) "integer" +} +string(34) "Doctrine\ORM\Attributes\ManyToMany" +array(1) { + [0]=> + string(11) "Phonenumber" +} +string(33) "Doctrine\ORM\Attributes\JoinTable" +array(1) { + [0]=> + string(18) "users_phonenumbers" +} +string(34) "Doctrine\ORM\Attributes\JoinColumn" +array(2) { + [0]=> + string(7) "user_id" + [1]=> + string(2) "id" +} +string(41) "Doctrine\ORM\Attributes\InverseJoinColumn" +array(3) { + [0]=> + string(14) "phonenumber_id" + [1]=> + string(2) "id" + [2]=> + string(6) "unique" +} diff --git a/Zend/tests/attributes/010_unsupported_const_expression.phpt b/Zend/tests/attributes/010_unsupported_const_expression.phpt new file mode 100644 index 0000000000000..50afa6c4f65c5 --- /dev/null +++ b/Zend/tests/attributes/010_unsupported_const_expression.phpt @@ -0,0 +1,11 @@ +--TEST-- +Attribute arguments support only const expressions. +--FILE-- +> +class C1 { } + +?> +--EXPECTF-- +Fatal error: Constant expression contains invalid operations in %s diff --git a/Zend/tests/attributes/011-inheritance.phpt b/Zend/tests/attributes/011-inheritance.phpt new file mode 100644 index 0000000000000..007cd5991e7d7 --- /dev/null +++ b/Zend/tests/attributes/011-inheritance.phpt @@ -0,0 +1,99 @@ +--TEST-- +Attributes comply with inheritance rules. +--FILE-- +> +class C1 +{ + <> + public function foo() { } +} + +class C2 extends C1 +{ + public function foo() { } +} + +class C3 extends C1 +{ + <> + public function bar() { } +} + +$ref = new \ReflectionClass(C1::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getAttributes())); +print_r(array_map(fn ($a) => $a->getName(), $ref->getMethod('foo')->getAttributes())); + +$ref = new \ReflectionClass(C2::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getAttributes())); +print_r(array_map(fn ($a) => $a->getName(), $ref->getMethod('foo')->getAttributes())); + +$ref = new \ReflectionClass(C3::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getAttributes())); +print_r(array_map(fn ($a) => $a->getName(), $ref->getMethod('foo')->getAttributes())); + +echo "\n"; + +trait T1 +{ + <> + public $a; +} + +class C4 +{ + use T1; +} + +class C5 +{ + use T1; + + public $a; +} + +$ref = new \ReflectionClass(T1::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getProperty('a')->getAttributes())); + +$ref = new \ReflectionClass(C4::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getProperty('a')->getAttributes())); + +$ref = new \ReflectionClass(C5::class); +print_r(array_map(fn ($a) => $a->getName(), $ref->getProperty('a')->getAttributes())); + +?> +--EXPECT-- +Array +( + [0] => A2 +) +Array +( + [0] => A1 +) +Array +( +) +Array +( +) +Array +( +) +Array +( + [0] => A1 +) + +Array +( + [0] => A2 +) +Array +( + [0] => A2 +) +Array +( +) diff --git a/Zend/tests/attributes/012-ast-export.phpt b/Zend/tests/attributes/012-ast-export.phpt new file mode 100644 index 0000000000000..47176b1b0d02d --- /dev/null +++ b/Zend/tests/attributes/012-ast-export.phpt @@ -0,0 +1,54 @@ +--TEST-- +Attributes AST can be exported. +--FILE-- +><> function ($a, <> $b) { })); + +assert(0 && ($a = <> fn () => 1)); + +assert(0 && ($a = new <> class() { + <><> const FOO = 'foo'; + <> public $x; + <> function a() { } +})); + +assert(0 && ($a = function () { + <> class Test1 { } + <> interface Test2 { } + <> trait Test3 { } +})); + +?> +--EXPECTF-- +Warning: assert(): assert(0 && ($a = <> <> function ($a, <> $b) { +})) failed in %s on line %d + +Warning: assert(): assert(0 && ($a = <> fn() => 1)) failed in %s on line %d + +Warning: assert(): assert(0 && ($a = new <> class { + <> + <> + const FOO = 'foo'; + <> + public $x; + <> + public function a() { + } + +})) failed in %s on line %d + +Warning: assert(): assert(0 && ($a = function () { + <> + class Test1 { + } + + <> + interface Test2 { + } + + <> + trait Test3 { + } + +})) failed in %s on line %d diff --git a/Zend/tests/attributes/deprecated_001.phpt b/Zend/tests/attributes/deprecated_001.phpt new file mode 100644 index 0000000000000..f25e0c62dac15 --- /dev/null +++ b/Zend/tests/attributes/deprecated_001.phpt @@ -0,0 +1,20 @@ +--TEST-- +<> attribute +--FILE-- +> +function test() { +} + +<> +function test2() { +} + + +test(); +test2(); +--EXPECTF-- +Deprecated: Function test() is deprecated in %s + +Deprecated: Function test2() is deprecated use test() instead in %s diff --git a/Zend/tests/attributes/deprecated_002.phpt b/Zend/tests/attributes/deprecated_002.phpt new file mode 100644 index 0000000000000..da21caf0e9e39 --- /dev/null +++ b/Zend/tests/attributes/deprecated_002.phpt @@ -0,0 +1,10 @@ +--TEST-- +<> attribute compile errors +--FILE-- +> +function test() { +} +--EXPECTF-- +Fatal error: <>: Argument #1 ($message) must be of type string, int given in %s diff --git a/Zend/tests/attributes/deprecated_003.phpt b/Zend/tests/attributes/deprecated_003.phpt new file mode 100644 index 0000000000000..f16a36f1d86d0 --- /dev/null +++ b/Zend/tests/attributes/deprecated_003.phpt @@ -0,0 +1,10 @@ +--TEST-- +<> attribute compile errors +--FILE-- +> +function test() { +} +--EXPECTF-- +Fatal error: <> requires at most one argument, 3 arguments given in %s diff --git a/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt index 6847c6f2ea7ab..ed04921f89470 100644 --- a/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt +++ b/Zend/tests/varSyntax/globalNonSimpleVariableError.phpt @@ -7,4 +7,4 @@ global $$foo->bar; ?> --EXPECTF-- -Parse error: syntax error, unexpected '->' (T_OBJECT_OPERATOR), expecting ';' or ',' in %s on line %d +Parse error: syntax error, unexpected '->' (T_OBJECT_OPERATOR), expecting ',' or ';' in %s on line %d diff --git a/Zend/zend.h b/Zend/zend.h index cd41cde5ef1b7..52a8ebcd15d9c 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -177,6 +177,7 @@ struct _zend_class_entry { uint32_t line_start; uint32_t line_end; zend_string *doc_comment; + HashTable *attributes; } user; struct { const struct _zend_function_entry *builtin_functions; diff --git a/Zend/zend_API.c b/Zend/zend_API.c index ea78c22a463c3..c11338723efd3 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -3513,7 +3513,7 @@ static zend_always_inline zend_bool is_persistent_class(zend_class_entry *ce) { && ce->info.internal.module->type == MODULE_PERSISTENT; } -ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type) /* {{{ */ +ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, HashTable *attributes, zend_type type) /* {{{ */ { zend_property_info *property_info, *property_info_ptr; @@ -3612,6 +3612,7 @@ ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name property_info->name = zend_new_interned_string(property_info->name); property_info->flags = access_type; property_info->doc_comment = doc_comment; + property_info->attributes = attributes; property_info->ce = ce; property_info->type = type; @@ -3748,16 +3749,16 @@ ZEND_API int zend_try_assign_typed_ref_zval_ex(zend_reference *ref, zval *zv, ze } /* }}} */ -ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment) /* {{{ */ +ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, HashTable *attributes) /* {{{ */ { - return zend_declare_typed_property(ce, name, property, access_type, doc_comment, (zend_type) ZEND_TYPE_INIT_NONE(0)); + return zend_declare_typed_property(ce, name, property, access_type, doc_comment, attributes, (zend_type) ZEND_TYPE_INIT_NONE(0)); } /* }}} */ ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type) /* {{{ */ { zend_string *key = zend_string_init(name, name_length, is_persistent_class(ce)); - int ret = zend_declare_property_ex(ce, key, property, access_type, NULL); + int ret = zend_declare_property_ex(ce, key, property, access_type, NULL, NULL); zend_string_release(key); return ret; } @@ -3817,7 +3818,7 @@ ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *nam } /* }}} */ -ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment) /* {{{ */ +ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment, HashTable *attributes) /* {{{ */ { zend_class_constant *c; @@ -3844,6 +3845,7 @@ ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *n ZVAL_COPY_VALUE(&c->value, value); Z_ACCESS_FLAGS(c->value) = access_type; c->doc_comment = doc_comment; + c->attributes = attributes; c->ce = ce; if (Z_TYPE_P(value) == IS_CONSTANT_AST) { ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED; @@ -3869,7 +3871,7 @@ ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, } else { key = zend_string_init(name, name_length, 0); } - ret = zend_declare_class_constant_ex(ce, key, value, ZEND_ACC_PUBLIC, NULL); + ret = zend_declare_class_constant_ex(ce, key, value, ZEND_ACC_PUBLIC, NULL, NULL); zend_string_release(key); return ret; } diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 44c24bbca17eb..feeea03bb5293 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -350,9 +350,9 @@ ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_nam ZEND_API const char *zend_get_module_version(const char *module_name); ZEND_API int zend_get_module_started(const char *module_name); -ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type); +ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, HashTable *attributes, zend_type type); -ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment); +ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, HashTable *attributes); ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type); ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type); ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type); @@ -361,7 +361,7 @@ ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, int access_type); ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, int access_type); -ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment); +ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment, HashTable *attributes); ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value); ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length); ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value); diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 7cfc0450fd84e..7bd732ea68088 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -126,6 +126,7 @@ ZEND_API zend_ast *zend_ast_create_decl( ast->flags = flags; ast->lex_pos = LANG_SCNG(yy_text); ast->doc_comment = doc_comment; + ast->attributes = NULL; ast->name = name; ast->child[0] = child0; ast->child[1] = child1; @@ -857,6 +858,9 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast) if (decl->doc_comment) { zend_string_release_ex(decl->doc_comment, 0); } + if (decl->attributes) { + zend_ast_destroy(decl->attributes); + } zend_ast_destroy(decl->child[0]); zend_ast_destroy(decl->child[1]); zend_ast_destroy(decl->child[2]); @@ -1313,6 +1317,41 @@ static ZEND_COLD void zend_ast_export_class_no_header(smart_str *str, zend_ast_d smart_str_appends(str, "}"); } +static ZEND_COLD void zend_ast_export_attributes(smart_str *str, zend_ast *ast, int indent, zend_bool newlines) { + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + for (i = 0; i < list->children; i++) { + zend_ast *attr = list->child[i]; + + smart_str_appends(str, "<<"); + smart_str_append(str, zend_ast_get_str(attr->child[0])); + + if (attr->child[1]) { + zend_ast_list *args = zend_ast_get_list(attr->child[1]); + uint32_t j; + + smart_str_appendc(str, '('); + for (j = 0; j < args->children; j++) { + if (j) { + smart_str_appends(str, ", "); + } + zend_ast_export_ex(str, args->child[j], 0, indent); + } + smart_str_appendc(str, ')'); + } + + smart_str_appends(str, ">>"); + + if (newlines) { + smart_str_appendc(str, '\n'); + zend_ast_export_indent(str, indent); + } else { + smart_str_appendc(str, ' '); + } + } +} + static ZEND_COLD void zend_ast_export_type(smart_str *str, zend_ast *ast, int indent) { if (ast->kind == ZEND_AST_TYPE_UNION) { zend_ast_list *list = zend_ast_get_list(ast); @@ -1406,6 +1445,10 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio case ZEND_AST_ARROW_FUNC: case ZEND_AST_METHOD: decl = (zend_ast_decl *) ast; + if (decl->attributes) { + zend_bool newlines = (ast->kind == ZEND_AST_CLOSURE || ast->kind == ZEND_AST_ARROW_FUNC) ? 0 : 1; + zend_ast_export_attributes(str, decl->attributes, indent, newlines); + } if (decl->flags & ZEND_ACC_PUBLIC) { smart_str_appends(str, "public "); } else if (decl->flags & ZEND_ACC_PROTECTED) { @@ -1462,6 +1505,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio break; case ZEND_AST_CLASS: decl = (zend_ast_decl *) ast; + if (decl->attributes) { + zend_ast_export_attributes(str, decl->attributes, indent, 1); + } if (decl->flags & ZEND_ACC_INTERFACE) { smart_str_appends(str, "interface "); } else if (decl->flags & ZEND_ACC_TRAIT) { @@ -1517,6 +1563,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio zend_ast *type_ast = ast->child[0]; zend_ast *prop_ast = ast->child[1]; + if (ast->child[2]) { + zend_ast_export_attributes(str, ast->child[2], indent, 1); + } if (ast->attr & ZEND_ACC_PUBLIC) { smart_str_appends(str, "public "); } else if (ast->attr & ZEND_ACC_PROTECTED) { @@ -1541,6 +1590,10 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio case ZEND_AST_CLASS_CONST_DECL: smart_str_appends(str, "const "); goto simple_list; + case ZEND_AST_CLASS_CONST_DECL_ATTRIBUTES: + zend_ast_export_attributes(str, ast->child[1], indent, 1); + zend_ast_export_ex(str, ast->child[0], 0, indent); + break; case ZEND_AST_NAME_LIST: zend_ast_export_name_list(str, (zend_ast_list*)ast, indent); break; @@ -1782,13 +1835,17 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio case ZEND_AST_NEW: smart_str_appends(str, "new "); if (ast->child[0]->kind == ZEND_AST_CLASS) { + zend_ast_decl *decl = (zend_ast_decl *) ast->child[0]; + if (decl->attributes) { + zend_ast_export_attributes(str, decl->attributes, indent, 0); + } smart_str_appends(str, "class"); if (zend_ast_get_list(ast->child[1])->children) { smart_str_appendc(str, '('); zend_ast_export_ex(str, ast->child[1], 0, indent); smart_str_appendc(str, ')'); } - zend_ast_export_class_no_header(str, (zend_ast_decl *) ast->child[0], indent); + zend_ast_export_class_no_header(str, decl, indent); } else { zend_ast_export_ns_name(str, ast->child[0], 0, indent); smart_str_appendc(str, '('); @@ -1999,6 +2056,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio zend_ast_export_indent(str, indent); break; case ZEND_AST_PARAM: + if (ast->child[3]) { + zend_ast_export_attributes(str, ast->child[3], indent, 0); + } if (ast->child[0]) { zend_ast_export_type(str, ast->child[0], indent); smart_str_appendc(str, ' '); @@ -2111,3 +2171,31 @@ ZEND_API ZEND_COLD zend_string *zend_ast_export(const char *prefix, zend_ast *as smart_str_0(&str); return str.s; } + +zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr) +{ + ZEND_ASSERT(attr->kind == ZEND_AST_ATTRIBUTE_LIST); + + switch (ast->kind) { + case ZEND_AST_FUNC_DECL: + case ZEND_AST_CLOSURE: + case ZEND_AST_METHOD: + case ZEND_AST_CLASS: + case ZEND_AST_ARROW_FUNC: + ((zend_ast_decl *) ast)->attributes = attr; + break; + case ZEND_AST_PROP_GROUP: + ast->child[2] = attr; + break; + case ZEND_AST_PARAM: + ast->child[3] = attr; + break; + case ZEND_AST_CLASS_CONST_DECL: + ast = zend_ast_create(ZEND_AST_CLASS_CONST_DECL_ATTRIBUTES, ast, attr); + ast->lineno = ast->child[0]->lineno; + break; + EMPTY_SWITCH_DEFAULT_CASE() + } + + return ast; +} diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 5b8aae6f96c25..97595b97b89d5 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -62,6 +62,7 @@ enum _zend_ast_kind { ZEND_AST_TRAIT_ADAPTATIONS, ZEND_AST_USE, ZEND_AST_TYPE_UNION, + ZEND_AST_ATTRIBUTE_LIST, /* 0 child nodes */ ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -138,7 +139,8 @@ enum _zend_ast_kind { ZEND_AST_USE_ELEM, ZEND_AST_TRAIT_ALIAS, ZEND_AST_GROUP_USE, - ZEND_AST_PROP_GROUP, + ZEND_AST_CLASS_CONST_DECL_ATTRIBUTES, + ZEND_AST_ATTRIBUTE, /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -147,13 +149,14 @@ enum _zend_ast_kind { ZEND_AST_TRY, ZEND_AST_CATCH, - ZEND_AST_PARAM, + ZEND_AST_PROP_GROUP, ZEND_AST_PROP_ELEM, ZEND_AST_CONST_ELEM, /* 4 child nodes */ ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT, ZEND_AST_FOREACH, + ZEND_AST_PARAM, }; typedef uint16_t zend_ast_kind; @@ -191,6 +194,7 @@ typedef struct _zend_ast_decl { uint32_t flags; unsigned char *lex_pos; zend_string *doc_comment; + zend_ast *attributes; zend_string *name; zend_ast *child[4]; } zend_ast_decl; @@ -311,6 +315,12 @@ static zend_always_inline zend_string *zend_ast_get_constant_name(zend_ast *ast) return Z_STR(((zend_ast_zval *) ast)->val); } +static zend_always_inline HashTable *zend_ast_get_hash(zend_ast *ast) { + zval *zv = zend_ast_get_zval(ast); + ZEND_ASSERT(Z_TYPE_P(zv) == IS_ARRAY); + return Z_ARR_P(zv); +} + static zend_always_inline uint32_t zend_ast_get_num_children(zend_ast *ast) { ZEND_ASSERT(!zend_ast_is_list(ast)); return ast->kind >> ZEND_AST_NUM_CHILDREN_SHIFT; @@ -324,6 +334,12 @@ static zend_always_inline uint32_t zend_ast_get_lineno(zend_ast *ast) { } } +static zend_always_inline zend_ast *zend_ast_create_zval_from_hash(HashTable *hash) { + zval zv; + ZVAL_ARR(&zv, hash); + return zend_ast_create_zval(&zv); +} + static zend_always_inline zend_ast *zend_ast_create_binary_op(uint32_t opcode, zend_ast *op0, zend_ast *op1) { return zend_ast_create_ex(ZEND_AST_BINARY_OP, opcode, op0, op1); } @@ -340,4 +356,7 @@ static zend_always_inline zend_ast *zend_ast_list_rtrim(zend_ast *ast) { } return ast; } + +zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr); + #endif diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c new file mode 100644 index 0000000000000..7dde3a080e857 --- /dev/null +++ b/Zend/zend_attributes.c @@ -0,0 +1,70 @@ +#include "zend.h" +#include "zend_API.h" +#include "zend_attributes.h" + +ZEND_API zend_class_entry *zend_ce_php_attribute; +ZEND_API zend_class_entry *zend_ce_php_compiler_attribute; +ZEND_API zend_class_entry *zend_ce_deprecated_attribute; + +static HashTable internal_validators; + +void zend_attribute_validate_phpattribute(zend_attribute *attr, int target) +{ + if (target != ZEND_ATTRIBUTE_TARGET_CLASS) { + zend_error(E_COMPILE_ERROR, "Only classes can be marked with <>"); + } +} + +void zend_attribute_validate_phpcompilerattribute(zend_attribute *attr, int target) +{ + zend_error(E_COMPILE_ERROR, "The PhpCompilerAttribute can only be used by internal classes, use PhpAttribute instead"); +} + +void zend_attribute_validate_deprecated_attribute(zend_attribute *attr, int target) +{ + if (attr->argc > 1) { + zend_error(E_COMPILE_ERROR, "<> requires at most one argument, %d arguments given", attr->argc); + } + + if (attr->argc == 1 && Z_TYPE(attr->argv[0]) != IS_STRING) { + zend_error(E_COMPILE_ERROR, "<>: Argument #1 ($message) must be of type string, %s given", zend_zval_type_name(&attr->argv[0])); + } +} + +ZEND_API zend_attributes_internal_validator zend_attribute_get_validator(zend_string *lcname) +{ + return zend_hash_find_ptr(&internal_validators, lcname); +} + +ZEND_API void zend_compiler_attribute_register(zend_class_entry *ce, zend_attributes_internal_validator validator) +{ + zend_string *lcname = zend_string_tolower_ex(ce->name, 1); + + zend_hash_update_ptr(&internal_validators, lcname, validator); + zend_string_release(lcname); +} + +void zend_register_attribute_ce(void) +{ + zend_hash_init(&internal_validators, 8, NULL, NULL, 1); + + zend_class_entry ce; + + INIT_CLASS_ENTRY(ce, "PhpAttribute", NULL); + zend_ce_php_attribute = zend_register_internal_class(&ce); + zend_ce_php_attribute->ce_flags |= ZEND_ACC_FINAL; + + zend_compiler_attribute_register(zend_ce_php_attribute, zend_attribute_validate_phpattribute); + + INIT_CLASS_ENTRY(ce, "PhpCompilerAttribute", NULL); + zend_ce_php_compiler_attribute = zend_register_internal_class(&ce); + zend_ce_php_compiler_attribute->ce_flags |= ZEND_ACC_FINAL; + + zend_compiler_attribute_register(zend_ce_php_compiler_attribute, zend_attribute_validate_phpcompilerattribute); + + INIT_CLASS_ENTRY(ce, "Deprecated", NULL); + zend_ce_deprecated_attribute = zend_register_internal_class(&ce); + zend_ce_php_compiler_attribute->ce_flags |= ZEND_ACC_FINAL; + + zend_compiler_attribute_register(zend_ce_deprecated_attribute, zend_attribute_validate_deprecated_attribute); +} diff --git a/Zend/zend_attributes.h b/Zend/zend_attributes.h new file mode 100644 index 0000000000000..19c32416acfaa --- /dev/null +++ b/Zend/zend_attributes.h @@ -0,0 +1,82 @@ +#ifndef ZEND_ATTRIBUTES_H +#define ZEND_ATTRIBUTES_H + +#define ZEND_ATTRIBUTE_TARGET_CLASS 1 +#define ZEND_ATTRIBUTE_TARGET_FUNCTION 2 +#define ZEND_ATTRIBUTE_TARGET_METHOD 4 +#define ZEND_ATTRIBUTE_TARGET_PROPERTY 8 +#define ZEND_ATTRIBUTE_TARGET_CLASS_CONST 16 +#define ZEND_ATTRIBUTE_TARGET_PARAMETER 32 +#define ZEND_ATTRIBUTE_TARGET_ALL 63 + +#define ZEND_ATTRIBUTE_SIZE(argc) (sizeof(zend_attribute) + sizeof(zval) * (argc) - sizeof(zval)) + +BEGIN_EXTERN_C() + +extern ZEND_API zend_class_entry *zend_ce_php_attribute; +extern ZEND_API zend_class_entry *zend_ce_php_compiler_attribute; + +typedef struct _zend_attribute { + zend_string *name; + zend_string *lcname; + uint32_t offset; + uint32_t argc; + zval argv[1]; +} zend_attribute; + +typedef void (*zend_attributes_internal_validator)(zend_attribute *attr, int target); + +static zend_always_inline void zend_attribute_free(zend_attribute *attr) +{ + uint32_t i; + + zend_string_release(attr->name); + zend_string_release(attr->lcname); + + for (i = 0; i < attr->argc; i++) { + zval_ptr_dtor(&attr->argv[i]); + } + + efree(attr); +} + +static zend_always_inline zend_attribute *zend_get_attribute(HashTable *attributes, zend_string *name, uint32_t offset) +{ + if (attributes) { + zend_attribute *attr; + + ZEND_HASH_FOREACH_PTR(attributes, attr) { + if (attr->offset == offset && zend_string_equals(attr->lcname, name)) { + return attr; + } + } ZEND_HASH_FOREACH_END(); + } + + return NULL; +} + +static zend_always_inline zend_attribute *zend_get_attribute_str(HashTable *attributes, const char *str, size_t len, uint32_t offset) +{ + if (attributes) { + zend_attribute *attr; + + ZEND_HASH_FOREACH_PTR(attributes, attr) { + if (attr->offset == offset && ZSTR_LEN(attr->lcname) == len) { + if (0 == memcmp(ZSTR_VAL(attr->lcname), str, len)) { + return attr; + } + } + } ZEND_HASH_FOREACH_END(); + } + + return NULL; +} + +ZEND_API void zend_compiler_attribute_register(zend_class_entry *ce, zend_attributes_internal_validator validator); +ZEND_API zend_attributes_internal_validator zend_attribute_get_validator(zend_string *lcname); + +void zend_register_attribute_ce(void); + +END_EXTERN_C() + +#endif diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 953bf6dfd59eb..dad1ae76d08ce 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -20,6 +20,7 @@ #include #include "zend.h" +#include "zend_attributes.h" #include "zend_compile.h" #include "zend_constants.h" #include "zend_llist.h" @@ -1057,6 +1058,10 @@ ZEND_API void function_add_ref(zend_function *function) /* {{{ */ ZEND_MAP_PTR_INIT(op_array->run_time_cache, zend_arena_alloc(&CG(arena), sizeof(void*))); ZEND_MAP_PTR_SET(op_array->run_time_cache, NULL); } + + if (op_array->attributes) { + GC_ADDREF(op_array->attributes); + } } if (function->common.function_name) { @@ -1822,6 +1827,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify } else { ZEND_MAP_PTR_INIT(ce->static_members_table, &ce->default_static_members_table); ce->info.user.doc_comment = NULL; + ce->info.user.attributes = NULL; } ce->default_properties_count = 0; @@ -5711,6 +5717,74 @@ static zend_bool zend_is_valid_default_value(zend_type type, zval *value) return 0; } +static zend_attribute *zend_compile_attribute(zend_ast *ast, uint32_t offset) /* {{{ */ +{ + ZEND_ASSERT(ast->kind == ZEND_AST_ATTRIBUTE); + + zend_ast_list *list = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL; + zend_attribute *attr = emalloc(ZEND_ATTRIBUTE_SIZE(list ? list->children : 0)); + + attr->name = zend_resolve_class_name_ast(ast->child[0]); + attr->lcname = zend_string_tolower(attr->name); + attr->offset = offset; + attr->argc = list ? list->children : 0; + + if (ast->child[1]) { + ZEND_ASSERT(ast->child[1]->kind == ZEND_AST_ARG_LIST); + + uint32_t i; + + for (i = 0; i < list->children; i++) { + zend_const_expr_to_zval(&attr->argv[i], list->child[i]); + } + } + + return attr; +} +/* }}} */ + +static void attribute_ptr_dtor(zval *v) /* {{{ */ +{ + zend_attribute_free((zend_attribute *) Z_PTR_P(v)); +} +/* }}} */ + +static zend_always_inline HashTable *create_attribute_array(uint32_t size) /* {{{ */ +{ + HashTable *attributes; + + ALLOC_HASHTABLE(attributes); + zend_hash_init(attributes, size, NULL, attribute_ptr_dtor, 0); + + return attributes; +} +/* }}} */ + +static void zend_compile_attributes(HashTable *attributes, zend_ast *ast, uint32_t offset, int target) /* {{{ */ +{ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t i; + + zval tmp; + + ZEND_ASSERT(ast->kind == ZEND_AST_ATTRIBUTE_LIST); + + for (i = 0; i < list->children; i++) { + zend_attribute *attr = zend_compile_attribute(list->child[i], offset); + + // Validate internal attribute + zend_attributes_internal_validator validator = zend_attribute_get_validator(attr->lcname); + + if (validator != NULL) { + validator(attr, target); + } + + ZVAL_PTR(&tmp, attr); + zend_hash_next_index_insert(attributes, &tmp); + } +} +/* }}} */ + void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fallback_return_type) /* {{{ */ { zend_ast_list *list = zend_ast_get_list(ast); @@ -5745,6 +5819,7 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall zend_ast *type_ast = param_ast->child[0]; 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_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; @@ -5814,6 +5889,14 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall arg_info->name = zend_string_copy(name); arg_info->type = (zend_type) ZEND_TYPE_INIT_NONE(0); + if (attributes_ast) { + if (!op_array->attributes) { + op_array->attributes = create_attribute_array(zend_ast_get_list(attributes_ast)->children); + } + + zend_compile_attributes(op_array->attributes, attributes_ast, i + 1, ZEND_ATTRIBUTE_TARGET_PARAMETER); + } + if (type_ast) { uint32_t default_type = default_ast ? Z_TYPE(default_node.u.constant) : IS_UNDEF; @@ -6235,6 +6318,50 @@ static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_as } /* }}} */ +static void zend_compile_deprecated_func_decl(zend_string *name, zend_op_array *op_array, zend_attribute *deprecated) /* {{{ */ +{ + zend_string *deprecation_message; + + znode result; + zval fn_name, message, type; + zend_ast *name_ast, *args_ast, *call_ast, *message_ast, *type_ast; + + if (op_array->scope) { + if (deprecated->argc == 0) { + deprecation_message = zend_strpprintf(0, "Method %s::%s() is deprecated", ZSTR_VAL(op_array->scope->name), ZSTR_VAL(name)); + } else if (deprecated->argc == 1) { + deprecation_message = zend_strpprintf(0, + "Method %s::%s() is deprecated %s", + ZSTR_VAL(op_array->scope->name), + ZSTR_VAL(name), + ZSTR_VAL(Z_STR(deprecated->argv[0])) + ); + } + } else { + if (deprecated->argc == 0) { + deprecation_message = zend_strpprintf(0, "Function %s() is deprecated", ZSTR_VAL(name)); + } else if (deprecated->argc == 1) { + deprecation_message = zend_strpprintf(0, "Function %s() is deprecated %s", ZSTR_VAL(name), ZSTR_VAL(Z_STR(deprecated->argv[0]))); + } + } + + ZVAL_STRING(&fn_name, "trigger_error"); + ZVAL_STR(&message, deprecation_message); + ZVAL_LONG(&type, E_USER_DEPRECATED); + + name_ast = zend_ast_create_zval(&fn_name); + message_ast = zend_ast_create_zval(&message); + type_ast = zend_ast_create_zval(&type); + + args_ast = zend_ast_create_list(2, ZEND_AST_ARG_LIST, message_ast, type_ast); + call_ast = zend_ast_create(ZEND_AST_CALL, name_ast, args_ast); + + zend_compile_expr(&result, call_ast); + + zval_ptr_dtor(&fn_name); + zval_ptr_dtor(&message); +} + void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /* {{{ */ { zend_ast_decl *decl = (zend_ast_decl *) ast; @@ -6269,6 +6396,15 @@ void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /* if (decl->doc_comment) { op_array->doc_comment = zend_string_copy(decl->doc_comment); } + if (decl->attributes) { + int target = ZEND_ATTRIBUTE_TARGET_FUNCTION; + + if (is_method) { + target = ZEND_ATTRIBUTE_TARGET_METHOD; + } + op_array->attributes = create_attribute_array(zend_ast_get_list(decl->attributes)->children); + zend_compile_attributes(op_array->attributes, decl->attributes, 0, target); + } if (decl->kind == ZEND_AST_CLOSURE || decl->kind == ZEND_AST_ARROW_FUNC) { op_array->fn_flags |= ZEND_ACC_CLOSURE; } @@ -6326,6 +6462,13 @@ void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /* } else if (uses_ast) { zend_compile_closure_uses(uses_ast); } + + zend_attribute *deprecated = zend_get_attribute_str(op_array->attributes, "deprecated", sizeof("deprecated")-1, 0); + + if (deprecated && stmt_ast != NULL) { + zend_compile_deprecated_func_decl(decl->name, op_array, deprecated); + } + zend_compile_stmt(stmt_ast); if (is_method) { @@ -6350,7 +6493,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /* } /* }}} */ -void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags) /* {{{ */ +void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags, HashTable *attributes) /* {{{ */ { zend_ast_list *list = zend_ast_get_list(ast); zend_class_entry *ce = CG(active_class_entry); @@ -6425,17 +6568,32 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags) / ZVAL_UNDEF(&value_zv); } - zend_declare_typed_property(ce, name, &value_zv, flags, doc_comment, type); + if (attributes) { + GC_ADDREF(attributes); + } + + zend_declare_typed_property(ce, name, &value_zv, flags, doc_comment, attributes, type); } } /* }}} */ void zend_compile_prop_group(zend_ast *list) /* {{{ */ { + HashTable *attributes = NULL; + zend_ast *type_ast = list->child[0]; zend_ast *prop_ast = list->child[1]; - zend_compile_prop_decl(prop_ast, type_ast, list->attr); + if (list->child[2]) { + attributes = create_attribute_array(zend_ast_get_list(list->child[2])->children); + zend_compile_attributes(attributes, list->child[2], 0, ZEND_ATTRIBUTE_TARGET_PROPERTY); + } + + zend_compile_prop_decl(prop_ast, type_ast, list->attr, attributes); + + if (attributes) { + zend_array_release(attributes); + } } /* }}} */ @@ -6451,10 +6609,11 @@ static void zend_check_const_and_trait_alias_attr(uint32_t attr, const char* ent } /* }}} */ -void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */ +void zend_compile_class_const_decl(zend_ast *ast, zend_ast *attr_ast) /* {{{ */ { zend_ast_list *list = zend_ast_get_list(ast); zend_class_entry *ce = CG(active_class_entry); + HashTable *attributes = NULL; uint32_t i; if ((ce->ce_flags & ZEND_ACC_TRAIT) != 0) { @@ -6462,6 +6621,11 @@ void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */ return; } + if (attr_ast) { + attributes = create_attribute_array(zend_ast_get_list(attr_ast)->children); + zend_compile_attributes(attributes, attr_ast, 0, ZEND_ATTRIBUTE_TARGET_CLASS_CONST); + } + for (i = 0; i < list->children; ++i) { zend_ast *const_ast = list->child[i]; zend_ast *name_ast = const_ast->child[0]; @@ -6475,8 +6639,16 @@ void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */ zend_check_const_and_trait_alias_attr(ast->attr, "constant"); } + if (attributes) { + GC_ADDREF(attributes); + } + zend_const_expr_to_zval(&value_zv, value_ast); - zend_declare_class_constant_ex(ce, name, &value_zv, ast->attr, doc_comment); + zend_declare_class_constant_ex(ce, name, &value_zv, ast->attr, doc_comment, attributes); + } + + if (attributes) { + zend_array_release(attributes); } } /* }}} */ @@ -6682,6 +6854,10 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ if (decl->doc_comment) { ce->info.user.doc_comment = zend_string_copy(decl->doc_comment); } + if (decl->attributes) { + ce->info.user.attributes = create_attribute_array(zend_ast_get_list(decl->attributes)->children); + zend_compile_attributes(ce->info.user.attributes, decl->attributes, 0, ZEND_ATTRIBUTE_TARGET_CLASS); + } if (UNEXPECTED((decl->flags & ZEND_ACC_ANON_CLASS))) { /* Serialization is not supported for anonymous classes */ @@ -8785,7 +8961,10 @@ void zend_compile_stmt(zend_ast *ast) /* {{{ */ zend_compile_prop_group(ast); break; case ZEND_AST_CLASS_CONST_DECL: - zend_compile_class_const_decl(ast); + zend_compile_class_const_decl(ast, NULL); + break; + case ZEND_AST_CLASS_CONST_DECL_ATTRIBUTES: + zend_compile_class_const_decl(ast->child[0], ast->child[1]); break; case ZEND_AST_USE_TRAIT: zend_compile_use_trait(ast); diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index b925c809db2e2..fa5f2183bc402 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -120,6 +120,7 @@ typedef struct _zend_file_context { typedef union _zend_parser_stack_elem { zend_ast *ast; zend_string *str; + HashTable *hash; zend_ulong num; unsigned char *ptr; } zend_parser_stack_elem; @@ -351,6 +352,7 @@ typedef struct _zend_property_info { uint32_t flags; zend_string *name; zend_string *doc_comment; + HashTable *attributes; zend_class_entry *ce; zend_type type; } zend_property_info; @@ -367,6 +369,7 @@ typedef struct _zend_property_info { typedef struct _zend_class_constant { zval value; /* access flags are stored in reserved: zval.u2.access_flags */ zend_string *doc_comment; + HashTable *attributes; zend_class_entry *ce; } zend_class_constant; @@ -430,6 +433,7 @@ struct _zend_op_array { uint32_t line_start; uint32_t line_end; zend_string *doc_comment; + HashTable *attributes; int last_literal; zval *literals; diff --git a/Zend/zend_default_classes.c b/Zend/zend_default_classes.c index 2c42763f0c5e5..63cdf66d580e8 100644 --- a/Zend/zend_default_classes.c +++ b/Zend/zend_default_classes.c @@ -19,6 +19,7 @@ #include "zend.h" #include "zend_API.h" +#include "zend_attributes.h" #include "zend_builtin_functions.h" #include "zend_interfaces.h" #include "zend_exceptions.h" @@ -34,4 +35,5 @@ ZEND_API void zend_register_default_classes(void) zend_register_closure_ce(); zend_register_generator_ce(); zend_register_weakref_ce(); + zend_register_attribute_ce(); } diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 1c10da561665f..424a1056e9ebb 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -1944,6 +1944,7 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent zval* prop_value; uint32_t flags; zend_string *doc_comment; + HashTable *attributes = NULL; /* In the following steps the properties are inserted into the property table * for that, a very strict approach is applied: @@ -2043,8 +2044,15 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent Z_TRY_ADDREF_P(prop_value); doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL; + if (property_info->attributes) { + attributes = property_info->attributes; + + if (!(GC_FLAGS(attributes) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(attributes); + } + } zend_type_copy_ctor(&property_info->type, /* persistent */ 0); - zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, property_info->type); + zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, attributes, property_info->type); zend_string_release_ex(prop_name, 0); } ZEND_HASH_FOREACH_END(); } diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index c1ced9a35aa21..b64f807615c13 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -257,6 +257,8 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type isset_variable type return_type type_expr type_without_static %type identifier type_expr_without_static union_type_without_static %type inline_function union_type +%type annotated_statement annotated_class_statement annotated_parameter +%type attribute_arguments attribute_decl attribute attributes %type returns_ref function fn is_reference is_variadic variable_modifiers %type method_modifiers non_empty_member_modifiers member_modifier @@ -311,12 +313,41 @@ name: | T_NS_SEPARATOR namespace_name { $$ = $2; $$->attr = ZEND_NAME_FQ; } ; -top_statement: - statement { $$ = $1; } - | function_declaration_statement { $$ = $1; } +attribute_arguments: + expr + { $$ = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $1); } + | attribute_arguments ',' expr + { $$ = zend_ast_list_add($1, $3); } +; + +attribute_decl: + class_name_reference + { $$ = zend_ast_create(ZEND_AST_ATTRIBUTE, $1, NULL); } + | class_name_reference '(' ')' + { $$ = zend_ast_create(ZEND_AST_ATTRIBUTE, $1, NULL); } + | class_name_reference '(' attribute_arguments ')' + { $$ = zend_ast_create(ZEND_AST_ATTRIBUTE, $1, $3); } +; + +attribute: + T_SL attribute_decl T_SR { $$ = $2; } +; + +attributes: + attribute { $$ = zend_ast_create_list(1, ZEND_AST_ATTRIBUTE_LIST, $1); } + | attributes attribute { $$ = zend_ast_list_add($1, $2); } +; + +annotated_statement: + function_declaration_statement { $$ = $1; } | class_declaration_statement { $$ = $1; } | trait_declaration_statement { $$ = $1; } | interface_declaration_statement { $$ = $1; } + +top_statement: + statement { $$ = $1; } + | annotated_statement { $$ = $1; } + | attributes annotated_statement { $$ = zend_ast_with_attributes($2, $1); } | T_HALT_COMPILER '(' ')' ';' { $$ = zend_ast_create(ZEND_AST_HALT_COMPILER, zend_ast_create_zval_from_long(zend_get_scanned_file_offset())); @@ -414,10 +445,8 @@ inner_statement_list: inner_statement: statement { $$ = $1; } - | function_declaration_statement { $$ = $1; } - | class_declaration_statement { $$ = $1; } - | trait_declaration_statement { $$ = $1; } - | interface_declaration_statement { $$ = $1; } + | annotated_statement { $$ = $1; } + | attributes annotated_statement { $$ = zend_ast_with_attributes($2, $1); } | T_HALT_COMPILER '(' ')' ';' { $$ = NULL; zend_throw_exception(zend_ce_compile_error, "__HALT_COMPILER() can only be used from the outermost scope", 0); YYERROR; } @@ -639,17 +668,22 @@ parameter_list: non_empty_parameter_list: - parameter + annotated_parameter { $$ = zend_ast_create_list(1, ZEND_AST_PARAM_LIST, $1); } - | non_empty_parameter_list ',' parameter + | non_empty_parameter_list ',' annotated_parameter { $$ = zend_ast_list_add($1, $3); } ; +annotated_parameter: + attributes parameter { $$ = zend_ast_with_attributes($2, $1); } + | parameter { $$ = $1; } +; + parameter: optional_type_without_static is_reference is_variadic T_VARIABLE - { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $2 | $3, $1, $4, NULL); } + { $$ = 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); } + { $$ = zend_ast_create_ex(ZEND_AST_PARAM, $2 | $3, $1, $4, $6, NULL); } ; @@ -739,7 +773,6 @@ static_var: | T_VARIABLE '=' expr { $$ = zend_ast_create(ZEND_AST_STATIC, $1, $3); } ; - class_statement_list: class_statement_list class_statement { $$ = zend_ast_list_add($1, $2); } @@ -748,18 +781,22 @@ class_statement_list: ; -class_statement: +annotated_class_statement: variable_modifiers optional_type_without_static property_list ';' - { $$ = zend_ast_create(ZEND_AST_PROP_GROUP, $2, $3); + { $$ = zend_ast_create(ZEND_AST_PROP_GROUP, $2, $3, NULL); $$->attr = $1; } | method_modifiers T_CONST class_const_list ';' { $$ = $3; $$->attr = $1; } - | T_USE class_name_list trait_adaptations - { $$ = zend_ast_create(ZEND_AST_USE_TRAIT, $2, $3); } | method_modifiers function returns_ref identifier backup_doc_comment '(' parameter_list ')' return_type backup_fn_flags method_body backup_fn_flags { $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1 | $12, $2, $5, zend_ast_get_str($4), $7, NULL, $11, $9); CG(extra_fn_flags) = $10; } + +class_statement: + annotated_class_statement { $$ = $1; } + | attributes annotated_class_statement { $$ = zend_ast_with_attributes($2, $1); } + | T_USE class_name_list trait_adaptations + { $$ = zend_ast_create(ZEND_AST_USE_TRAIT, $2, $3); } ; class_name_list: @@ -901,6 +938,8 @@ new_expr: { $$ = zend_ast_create(ZEND_AST_NEW, $2, $3); } | T_NEW anonymous_class { $$ = $2; } + | T_NEW attributes anonymous_class + { zend_ast_with_attributes($3->child[0], $2); $$ = $3; } ; expr: @@ -1020,7 +1059,10 @@ expr: | T_YIELD expr T_DOUBLE_ARROW expr { $$ = zend_ast_create(ZEND_AST_YIELD, $4, $2); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; } | T_YIELD_FROM expr { $$ = zend_ast_create(ZEND_AST_YIELD_FROM, $2); CG(extra_fn_flags) |= ZEND_ACC_GENERATOR; } | inline_function { $$ = $1; } + | attributes inline_function { $$ = zend_ast_with_attributes($2, $1); } | T_STATIC inline_function { $$ = $2; ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; } + | attributes T_STATIC inline_function + { $$ = zend_ast_with_attributes($3, $1); ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; } ; diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 49dedf5f963e4..4757a6905f4aa 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -63,6 +63,7 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz op_array->function_name = NULL; op_array->filename = zend_get_compiled_filename(); op_array->doc_comment = NULL; + op_array->attributes = NULL; op_array->arg_info = NULL; op_array->num_args = 0; @@ -317,6 +318,9 @@ ZEND_API void destroy_zend_class(zval *zv) if (prop_info->doc_comment) { zend_string_release_ex(prop_info->doc_comment, 0); } + if (prop_info->attributes) { + zend_array_release(prop_info->attributes); + } zend_type_release(prop_info->type, /* persistent */ 0); } } ZEND_HASH_FOREACH_END(); @@ -332,6 +336,9 @@ ZEND_API void destroy_zend_class(zval *zv) if (c->doc_comment) { zend_string_release_ex(c->doc_comment, 0); } + if (c->attributes) { + zend_array_release(c->attributes); + } } } ZEND_HASH_FOREACH_END(); } @@ -350,6 +357,9 @@ ZEND_API void destroy_zend_class(zval *zv) if (ce->info.user.doc_comment) { zend_string_release_ex(ce->info.user.doc_comment, 0); } + if (ce->info.user.attributes) { + zend_array_release(ce->info.user.attributes); + } if (ce->num_traits > 0) { _destroy_zend_class_traits_info(ce); @@ -401,6 +411,9 @@ ZEND_API void destroy_zend_class(zval *zv) if (c->doc_comment) { zend_string_release_ex(c->doc_comment, 1); } + if (c->attributes) { + zend_array_release(c->attributes); + } } free(c); } ZEND_HASH_FOREACH_END(); @@ -483,6 +496,9 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) if (op_array->doc_comment) { zend_string_release_ex(op_array->doc_comment, 0); } + if (op_array->attributes) { + zend_array_release(op_array->attributes); + } if (op_array->live_range) { efree(op_array->live_range); } diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h index bdee8b1879d5b..4199f75917713 100644 --- a/Zend/zend_variables.h +++ b/Zend/zend_variables.h @@ -48,6 +48,15 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr) } } +static zend_always_inline void zend_array_release(zend_array *array) +{ + if (!(GC_FLAGS(array) & IS_ARRAY_IMMUTABLE)) { + if (GC_DELREF(array) == 0) { + zend_array_destroy(array); + } + } +} + static zend_always_inline void zval_copy_ctor(zval *zvalue) { if (Z_TYPE_P(zvalue) == IS_ARRAY) { diff --git a/configure.ac b/configure.ac index 66d491c5f3623..bef6e68d8e485 100644 --- a/configure.ac +++ b/configure.ac @@ -1457,7 +1457,7 @@ PHP_ADD_SOURCES(Zend, \ zend_execute_API.c zend_highlight.c zend_llist.c \ zend_vm_opcodes.c zend_opcode.c zend_operators.c zend_ptr_stack.c zend_stack.c \ zend_variables.c zend.c zend_API.c zend_extensions.c zend_hash.c \ - zend_list.c zend_builtin_functions.c \ + zend_list.c zend_builtin_functions.c zend_attributes.c \ zend_ini.c zend_sort.c zend_multibyte.c zend_ts_hash.c zend_stream.c \ zend_iterators.c zend_interfaces.c zend_exceptions.c zend_strtod.c zend_gc.c \ zend_closures.c zend_weakrefs.c zend_float.c zend_string.c zend_signal.c zend_generators.c \ diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index eb74187e5d419..8e6dd30c93672 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -21,6 +21,7 @@ #include "zend_compile.h" #include "zend_vm.h" #include "zend_interfaces.h" +#include "zend_attributes.h" #include "php.h" #ifdef ZEND_WIN32 @@ -158,6 +159,25 @@ static int zend_file_cache_flock(int fd, int type) } \ } while (0) +#define SERIALIZE_ATTRIBUTES(attributes) do { \ + if ((attributes) && !IS_SERIALIZED(attributes)) { \ + HashTable *ht; \ + SERIALIZE_PTR(attributes); \ + ht = (attributes); \ + UNSERIALIZE_PTR(ht); \ + zend_file_cache_serialize_hash(ht, script, info, buf, zend_file_cache_serialize_attribute); \ + } \ +} while (0) + +#define UNSERIALIZE_ATTRIBUTES(attributes) do { \ + if ((attributes) && !IS_UNSERIALIZED(attributes)) { \ + HashTable *ht; \ + UNSERIALIZE_PTR(attributes); \ + ht = (attributes); \ + zend_file_cache_unserialize_hash(ht, script, buf, zend_file_cache_unserialize_attribute, NULL); \ + } \ +} while (0) + static const uint32_t uninitialized_bucket[-HT_MIN_MASK] = {HT_INVALID_IDX, HT_INVALID_IDX}; @@ -371,6 +391,33 @@ static void zend_file_cache_serialize_zval(zval *zv, } } +static void zend_file_cache_serialize_attribute(zval *zv, + zend_persistent_script *script, + zend_file_cache_metainfo *info, + void *buf) +{ + if (!IS_SERIALIZED(Z_PTR_P(zv))) { + zend_attribute *attr = Z_PTR_P(zv); + uint32_t i; + + SERIALIZE_PTR(Z_PTR_P(zv)); + attr = Z_PTR_P(zv); + UNSERIALIZE_PTR(attr); + + if (!IS_SERIALIZED(attr->name)) { + SERIALIZE_STR(attr->name); + } + + if (!IS_SERIALIZED(attr->lcname)) { + SERIALIZE_STR(attr->lcname); + } + + for (i = 0; i < attr->argc; i++) { + zend_file_cache_serialize_zval(&attr->argv[i], script, info, buf); + } + } +} + static void zend_file_cache_serialize_type( zend_type *type, zend_persistent_script *script, zend_file_cache_metainfo *info, void *buf) { @@ -421,6 +468,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra SERIALIZE_PTR(op_array->live_range); SERIALIZE_PTR(op_array->scope); SERIALIZE_STR(op_array->doc_comment); + SERIALIZE_ATTRIBUTES(op_array->attributes); SERIALIZE_PTR(op_array->try_catch_array); SERIALIZE_PTR(op_array->prototype); return; @@ -547,6 +595,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra SERIALIZE_PTR(op_array->live_range); SERIALIZE_PTR(op_array->scope); SERIALIZE_STR(op_array->doc_comment); + SERIALIZE_ATTRIBUTES(op_array->attributes); SERIALIZE_PTR(op_array->try_catch_array); SERIALIZE_PTR(op_array->prototype); @@ -591,6 +640,7 @@ static void zend_file_cache_serialize_prop_info(zval *zv, if (prop->doc_comment) { SERIALIZE_STR(prop->doc_comment); } + SERIALIZE_ATTRIBUTES(prop->attributes); zend_file_cache_serialize_type(&prop->type, script, info, buf); } } @@ -617,6 +667,8 @@ static void zend_file_cache_serialize_class_constant(zval *z if (c->doc_comment) { SERIALIZE_STR(c->doc_comment); } + + SERIALIZE_ATTRIBUTES(c->attributes); } } } @@ -674,6 +726,7 @@ static void zend_file_cache_serialize_class(zval *zv, zend_file_cache_serialize_hash(&ce->constants_table, script, info, buf, zend_file_cache_serialize_class_constant); SERIALIZE_STR(ce->info.user.filename); SERIALIZE_STR(ce->info.user.doc_comment); + SERIALIZE_ATTRIBUTES(ce->info.user.attributes); zend_file_cache_serialize_hash(&ce->properties_info, script, info, buf, zend_file_cache_serialize_prop_info); if (ce->properties_info_table) { @@ -1092,6 +1145,29 @@ static void zend_file_cache_unserialize_zval(zval *zv, } } +static void zend_file_cache_unserialize_attribute(zval *zv, zend_persistent_script *script, void *buf) +{ + if (!IS_UNSERIALIZED(Z_PTR_P(zv))) { + zend_attribute *attr; + uint32_t i; + + UNSERIALIZE_PTR(Z_PTR_P(zv)); + attr = Z_PTR_P(zv); + + if (!IS_UNSERIALIZED(attr->name)) { + UNSERIALIZE_STR(attr->name); + } + + if (!IS_UNSERIALIZED(attr->lcname)) { + UNSERIALIZE_STR(attr->lcname); + } + + for (i = 0; i < attr->argc; i++) { + zend_file_cache_unserialize_zval(&attr->argv[i], script, buf); + } + } +} + static void zend_file_cache_unserialize_type( zend_type *type, zend_persistent_script *script, void *buf) { @@ -1139,6 +1215,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr UNSERIALIZE_PTR(op_array->live_range); UNSERIALIZE_PTR(op_array->scope); UNSERIALIZE_STR(op_array->doc_comment); + UNSERIALIZE_ATTRIBUTES(op_array->attributes); UNSERIALIZE_PTR(op_array->try_catch_array); UNSERIALIZE_PTR(op_array->prototype); return; @@ -1254,6 +1331,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr UNSERIALIZE_PTR(op_array->live_range); UNSERIALIZE_PTR(op_array->scope); UNSERIALIZE_STR(op_array->doc_comment); + UNSERIALIZE_ATTRIBUTES(op_array->attributes); UNSERIALIZE_PTR(op_array->try_catch_array); UNSERIALIZE_PTR(op_array->prototype); @@ -1307,6 +1385,7 @@ static void zend_file_cache_unserialize_prop_info(zval *zv, if (prop->doc_comment) { UNSERIALIZE_STR(prop->doc_comment); } + UNSERIALIZE_ATTRIBUTES(prop->attributes); zend_file_cache_unserialize_type(&prop->type, script, buf); } } @@ -1331,6 +1410,7 @@ static void zend_file_cache_unserialize_class_constant(zval * if (c->doc_comment) { UNSERIALIZE_STR(c->doc_comment); } + UNSERIALIZE_ATTRIBUTES(c->attributes); } } } @@ -1385,6 +1465,7 @@ static void zend_file_cache_unserialize_class(zval *zv, script, buf, zend_file_cache_unserialize_class_constant, NULL); UNSERIALIZE_STR(ce->info.user.filename); UNSERIALIZE_STR(ce->info.user.doc_comment); + UNSERIALIZE_ATTRIBUTES(ce->info.user.attributes); zend_file_cache_unserialize_hash(&ce->properties_info, script, buf, zend_file_cache_unserialize_prop_info, NULL); diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 6a158e73f9e33..d8f063b5b2c13 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -28,6 +28,7 @@ #include "zend_constants.h" #include "zend_operators.h" #include "zend_interfaces.h" +#include "zend_attributes.h" #ifdef HAVE_JIT # include "jit/zend_jit.h" @@ -258,6 +259,39 @@ static void zend_persist_zval(zval *z) } } +static HashTable *zend_persist_attributes(HashTable *attributes) +{ + HashTable *ptr = zend_shared_alloc_get_xlat_entry(attributes); + + if (!ptr) { + uint32_t i; + zval *v; + + zend_hash_persist(attributes); + + ZEND_HASH_FOREACH_VAL(attributes, v) { + zend_attribute *attr = Z_PTR_P(v); + zend_attribute *copy = zend_shared_memdup(attr, ZEND_ATTRIBUTE_SIZE(attr->argc)); + + zend_accel_store_interned_string(copy->name); + zend_accel_store_interned_string(copy->lcname); + + for (i = 0; i < copy->argc; i++) { + zend_persist_zval(©->argv[i]); + } + + ZVAL_PTR(v, copy); + efree(attr); + } ZEND_HASH_FOREACH_END(); + + ptr = zend_shared_memdup_put_free(attributes, sizeof(HashTable)); + GC_SET_REFCOUNT(ptr, 2); + GC_TYPE_INFO(ptr) = IS_ARRAY | (IS_ARRAY_IMMUTABLE << GC_FLAGS_SHIFT); + } + + return ptr; +} + static void zend_persist_type(zend_type *type) { if (ZEND_TYPE_HAS_LIST(*type)) { zend_type *list_type; @@ -375,6 +409,10 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc op_array->doc_comment = NULL; } } + if (op_array->attributes) { + op_array->attributes = zend_persist_attributes(op_array->attributes); + } + if (op_array->try_catch_array) { op_array->try_catch_array = zend_shared_alloc_get_xlat_entry(op_array->try_catch_array); ZEND_ASSERT(op_array->try_catch_array != NULL); @@ -551,6 +589,10 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc } } + if (op_array->attributes) { + op_array->attributes = zend_persist_attributes(op_array->attributes); + } + if (op_array->try_catch_array) { op_array->try_catch_array = zend_shared_memdup_put_free(op_array->try_catch_array, sizeof(zend_try_catch_element) * op_array->last_try_catch); } @@ -693,6 +735,9 @@ static void zend_persist_property_info(zval *zv) prop->doc_comment = NULL; } } + if (prop->attributes) { + prop->attributes = zend_persist_attributes(prop->attributes); + } zend_persist_type(&prop->type); } @@ -732,6 +777,9 @@ static void zend_persist_class_constant(zval *zv) c->doc_comment = NULL; } } + if (c->attributes) { + c->attributes = zend_persist_attributes(c->attributes); + } } static void zend_persist_class_entry(zval *zv) @@ -818,6 +866,9 @@ static void zend_persist_class_entry(zval *zv) ce->info.user.doc_comment = NULL; } } + if (ce->info.user.attributes) { + ce->info.user.attributes = zend_persist_attributes(ce->info.user.attributes); + } zend_hash_persist(&ce->properties_info); ZEND_HASH_FOREACH_BUCKET(&ce->properties_info, p) { ZEND_ASSERT(p->key != NULL); diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 5de27b9efb006..9821aca4d5f98 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -25,6 +25,7 @@ #include "zend_extensions.h" #include "zend_shared_alloc.h" #include "zend_operators.h" +#include "zend_attributes.h" #define ADD_DUP_SIZE(m,s) ZCG(current_persistent_script)->size += zend_shared_memdup_size((void*)m, s) #define ADD_SIZE(m) ZCG(current_persistent_script)->size += ZEND_ALIGNED_SIZE(m) @@ -148,6 +149,28 @@ static void zend_persist_zval_calc(zval *z) } } +static void zend_persist_attributes_calc(HashTable *attributes) +{ + if (!zend_shared_alloc_get_xlat_entry(attributes)) { + zend_attribute *attr; + uint32_t i; + + zend_shared_alloc_register_xlat_entry(attributes, attributes); + ADD_SIZE(sizeof(HashTable)); + zend_hash_persist_calc(attributes); + + ZEND_HASH_FOREACH_PTR(attributes, attr) { + ADD_SIZE(ZEND_ATTRIBUTE_SIZE(attr->argc)); + ADD_INTERNED_STRING(attr->name); + ADD_INTERNED_STRING(attr->lcname); + + for (i = 0; i < attr->argc; i++) { + zend_persist_zval_calc(&attr->argv[i]); + } + } ZEND_HASH_FOREACH_END(); + } +} + static void zend_persist_type_calc(zend_type *type) { if (ZEND_TYPE_HAS_LIST(*type)) { @@ -249,6 +272,10 @@ static void zend_persist_op_array_calc_ex(zend_op_array *op_array) ADD_STRING(op_array->doc_comment); } + if (op_array->attributes) { + zend_persist_attributes_calc(op_array->attributes); + } + if (op_array->try_catch_array) { ADD_SIZE(sizeof(zend_try_catch_element) * op_array->last_try_catch); } @@ -325,6 +352,9 @@ static void zend_persist_property_info_calc(zval *zv) if (ZCG(accel_directives).save_comments && prop->doc_comment) { ADD_STRING(prop->doc_comment); } + if (prop->attributes) { + zend_persist_attributes_calc(prop->attributes); + } } } @@ -339,6 +369,9 @@ static void zend_persist_class_constant_calc(zval *zv) if (ZCG(accel_directives).save_comments && c->doc_comment) { ADD_STRING(c->doc_comment); } + if (c->attributes) { + zend_persist_attributes_calc(c->attributes); + } } } @@ -424,6 +457,9 @@ static void zend_persist_class_entry_calc(zval *zv) if (ZCG(accel_directives).save_comments && ce->info.user.doc_comment) { ADD_STRING(ce->info.user.doc_comment); } + if (ce->info.user.attributes) { + zend_persist_attributes_calc(ce->info.user.attributes); + } zend_hash_persist_calc(&ce->properties_info); ZEND_HASH_FOREACH_BUCKET(&ce->properties_info, p) { diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index e23f0076a9662..6cd48ec9dec3b 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -31,6 +31,8 @@ #include "zend.h" #include "zend_API.h" +#include "zend_ast.h" +#include "zend_attributes.h" #include "zend_exceptions.h" #include "zend_operators.h" #include "zend_constants.h" @@ -84,6 +86,7 @@ PHPAPI zend_class_entry *reflection_class_constant_ptr; PHPAPI zend_class_entry *reflection_extension_ptr; PHPAPI zend_class_entry *reflection_zend_extension_ptr; PHPAPI zend_class_entry *reflection_reference_ptr; +PHPAPI zend_class_entry *reflection_attribute_ptr; /* Exception throwing macro */ #define _DO_THROW(msg) \ @@ -109,6 +112,8 @@ PHPAPI zend_class_entry *reflection_reference_ptr; #define REGISTER_REFLECTION_CLASS_CONST_LONG(class_name, const_name, value) \ zend_declare_class_constant_long(reflection_ ## class_name ## _ptr, const_name, sizeof(const_name)-1, (zend_long)value); +#define REFLECTION_ATTRIBUTE_IS_INSTANCEOF (1 << 1) + /* {{{ Object structure */ /* Struct for properties */ @@ -132,6 +137,12 @@ typedef struct _type_reference { zend_bool legacy_behavior; } type_reference; +/* Struct for attributes */ +typedef struct _attribute_reference { + zend_attribute *data; + zend_class_entry *scope; +} attribute_reference; + typedef enum { REF_TYPE_OTHER, /* Must be 0 */ REF_TYPE_FUNCTION, @@ -139,7 +150,8 @@ typedef enum { REF_TYPE_PARAMETER, REF_TYPE_TYPE, REF_TYPE_PROPERTY, - REF_TYPE_CLASS_CONSTANT + REF_TYPE_CLASS_CONSTANT, + REF_TYPE_ATTRIBUTE } reflection_type_t; /* Struct for reflection objects */ @@ -238,6 +250,9 @@ static void reflection_free_objects_storage(zend_object *object) /* {{{ */ zend_string_release_ex(prop_reference->unmangled_name, 0); efree(intern->ptr); break; + case REF_TYPE_ATTRIBUTE: + efree(intern->ptr); + break; case REF_TYPE_GENERATOR: case REF_TYPE_CLASS_CONSTANT: case REF_TYPE_OTHER: @@ -1061,6 +1076,119 @@ static void _extension_string(smart_str *str, zend_module_entry *module, char *i } /* }}} */ +/* {{{ reflection_attribute_factory */ +static void reflection_attribute_factory(zval *object, zend_attribute *data, zend_class_entry *scope) +{ + reflection_object *intern; + attribute_reference *reference; + + reflection_instantiate(reflection_attribute_ptr, object); + intern = Z_REFLECTION_P(object); + reference = (attribute_reference*) emalloc(sizeof(attribute_reference)); + reference->data = data; + reference->scope = scope; + intern->ptr = reference; + intern->ref_type = REF_TYPE_ATTRIBUTE; +} +/* }}} */ + +static int read_attributes(zval *ret, HashTable *attributes, zend_class_entry *scope, + uint32_t offset, zend_string *name, zend_class_entry *base) /* {{{ */ +{ + zend_attribute *attr; + zval tmp; + + if (name) { + // Name based filtering using lowercased key. + zend_string *filter = zend_string_tolower(name); + + ZEND_HASH_FOREACH_PTR(attributes, attr) { + if (attr->offset == offset && zend_string_equals(attr->lcname, filter)) { + reflection_attribute_factory(&tmp, attr, scope); + add_next_index_zval(ret, &tmp); + } + } ZEND_HASH_FOREACH_END(); + + zend_string_release(filter); + return SUCCESS; + } + + ZEND_HASH_FOREACH_PTR(attributes, attr) { + if (attr->offset != offset) { + continue; + } + + if (base) { + // Base type filtering. + zend_class_entry *ce = zend_lookup_class_ex(attr->name, attr->lcname, 0); + + if (ce == NULL) { + // Bailout on error, otherwise ignore unavailable class. + if (EG(exception)) { + return FAILURE; + } + + continue; + } + + if (!instanceof_function(ce, base)) { + continue; + } + } + + reflection_attribute_factory(&tmp, attr, scope); + add_next_index_zval(ret, &tmp); + } ZEND_HASH_FOREACH_END(); + + return SUCCESS; +} +/* }}} */ + +static void reflect_attributes(INTERNAL_FUNCTION_PARAMETERS, HashTable *attributes, + uint32_t offset, zend_class_entry *scope) /* {{{ */ +{ + zval ret; + + zend_string *name = NULL; + zend_long flags = 0; + zend_class_entry *base = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "|Sl", &name, &flags) == FAILURE) { + RETURN_THROWS(); + } + + if (flags & ~REFLECTION_ATTRIBUTE_IS_INSTANCEOF) { + zend_throw_error(NULL, "Invalid attribute filter flag specified"); + RETURN_THROWS(); + } + + if (name && (flags & REFLECTION_ATTRIBUTE_IS_INSTANCEOF)) { + if (NULL == (base = zend_lookup_class(name))) { + if (!EG(exception)) { + zend_throw_error(NULL, "Class '%s' not found", ZSTR_VAL(name)); + } + + RETURN_THROWS(); + } + + name = NULL; + } + + if (!attributes) { + RETURN_EMPTY_ARRAY(); + } + + array_init(&ret); + + if (FAILURE == read_attributes(&ret, attributes, scope, offset, name, base)) { + zval_ptr_dtor(&ret); + RETURN_THROWS(); + } + + RETURN_ZVAL(&ret, 1, 1); +} +/* }}} */ + static void _zend_extension_string(smart_str *str, zend_extension *extension, char *indent) /* {{{ */ { smart_str_append_printf(str, "%sZend Extension [ %s ", indent, extension->name); @@ -1637,6 +1765,27 @@ ZEND_METHOD(ReflectionFunctionAbstract, getDocComment) } /* }}} */ +/* {{{ proto public array ReflectionFunction::getAttributes([ string name, int flags ]) + Returns the attributes of this function */ +ZEND_METHOD(ReflectionFunctionAbstract, getAttributes) +{ + reflection_object *intern; + zend_function *fptr; + + HashTable *attributes = NULL; + zend_class_entry *scope = NULL; + + GET_REFLECTION_OBJECT_PTR(fptr); + + if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.attributes) { + attributes = fptr->op_array.attributes; + scope = fptr->common.scope; + } + + reflect_attributes(INTERNAL_FUNCTION_PARAM_PASSTHRU, attributes, 0, scope); +} +/* }}} */ + /* {{{ proto public array ReflectionFunction::getStaticVariables() Returns an associative array containing this function's static variables and their values */ ZEND_METHOD(ReflectionFunctionAbstract, getStaticVariables) @@ -2562,7 +2711,27 @@ ZEND_METHOD(ReflectionParameter, canBePassedByValue) } /* }}} */ -/* {{{ proto public bool ReflectionParameter::getPosition() +/* {{{ proto public array ReflectionParameter::getAttributes([ string name, int flags ]) + Get parameter attributes. */ +ZEND_METHOD(ReflectionParameter, getAttributes) +{ + reflection_object *intern; + parameter_reference *param; + + HashTable *attributes = NULL; + zend_class_entry *scope = NULL; + + GET_REFLECTION_OBJECT_PTR(param); + + if (param->fptr->type == ZEND_USER_FUNCTION && param->fptr->op_array.attributes) { + attributes = param->fptr->op_array.attributes; + scope = param->fptr->common.scope; + } + + reflect_attributes(INTERNAL_FUNCTION_PARAM_PASSTHRU, attributes, param->offset + 1, scope); +} + +/* {{{ proto public int ReflectionParameter::getPosition() Returns whether this parameter is an optional parameter */ ZEND_METHOD(ReflectionParameter, getPosition) { @@ -3617,6 +3786,27 @@ ZEND_METHOD(ReflectionClassConstant, getDocComment) } /* }}} */ +/* {{{ proto public array ReflectionClassConstant::getAttributes([ string name, int flags ]) + Returns the attributes of this constant */ +ZEND_METHOD(ReflectionClassConstant, getAttributes) +{ + reflection_object *intern; + zend_class_constant *ref; + + HashTable *attributes = NULL; + zend_class_entry *scope = NULL; + + GET_REFLECTION_OBJECT_PTR(ref); + + if (ref->attributes) { + attributes = ref->attributes; + scope = ref->ce; + } + + reflect_attributes(INTERNAL_FUNCTION_PARAM_PASSTHRU, attributes, 0, scope); +} +/* }}} */ + /* {{{ reflection_class_object_ctor */ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_object) { @@ -3984,6 +4174,27 @@ ZEND_METHOD(ReflectionClass, getDocComment) } /* }}} */ +/* {{{ proto public array ReflectionClass::getAttributes([ string name, int flags ]) + Returns the attributes for this class */ +ZEND_METHOD(ReflectionClass, getAttributes) +{ + reflection_object *intern; + zend_class_entry *ce; + + HashTable *attributes = NULL; + zend_class_entry *scope = NULL; + + GET_REFLECTION_OBJECT_PTR(ce); + + if (ce->type == ZEND_USER_CLASS && ce->info.user.attributes) { + attributes = ce->info.user.attributes; + scope = ce; + } + + reflect_attributes(INTERNAL_FUNCTION_PARAM_PASSTHRU, attributes, 0, scope); +} +/* }}} */ + /* {{{ proto public ReflectionMethod ReflectionClass::getConstructor() Returns the class' constructor if there is one, NULL otherwise */ ZEND_METHOD(ReflectionClass, getConstructor) @@ -5484,6 +5695,27 @@ ZEND_METHOD(ReflectionProperty, getDocComment) } /* }}} */ +/* {{{ proto public array ReflectionProperty::getAttributes([ string name, int flags ]) + Returns the attributes of this property */ +ZEND_METHOD(ReflectionProperty, getAttributes) +{ + reflection_object *intern; + property_reference *ref; + + HashTable *attributes = NULL; + zend_class_entry *scope = NULL; + + GET_REFLECTION_OBJECT_PTR(ref); + + if (ref->prop->attributes) { + attributes = ref->prop->attributes; + scope = ref->prop->ce; + } + + reflect_attributes(INTERNAL_FUNCTION_PARAM_PASSTHRU, attributes, 0, scope); +} +/* }}} */ + /* {{{ proto public int ReflectionProperty::setAccessible(bool visible) Sets whether non-public properties can be requested */ ZEND_METHOD(ReflectionProperty, setAccessible) @@ -6195,6 +6427,208 @@ ZEND_METHOD(ReflectionReference, getId) } /* }}} */ +ZEND_METHOD(ReflectionAttribute, __construct) +{ +} + +ZEND_METHOD(ReflectionAttribute, __clone) +{ +} + +/* {{{ proto public string ReflectionAttribute::getName() + * Returns the name of the attribute */ +ZEND_METHOD(ReflectionAttribute, getName) +{ + reflection_object *intern; + attribute_reference *attr; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + GET_REFLECTION_OBJECT_PTR(attr); + + RETURN_STR_COPY(attr->data->name); +} +/* }}} */ + +static zend_always_inline int import_attribute_value(zval *ret, zval *val, zend_class_entry *scope) /* {{{ */ +{ + if (Z_TYPE_P(val) == IS_CONSTANT_AST) { + *ret = *val; + + if (FAILURE == zval_update_constant_ex(ret, scope)) { + return FAILURE; + } + } else { + ZVAL_COPY_OR_DUP(ret, val); + } + + return SUCCESS; +} +/* }}} */ + +/* {{{ proto public array ReflectionAttribute::getArguments() + * Returns the arguments passed to the attribute */ +ZEND_METHOD(ReflectionAttribute, getArguments) +{ + reflection_object *intern; + attribute_reference *attr; + + zval ret; + zval tmp; + uint32_t i; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + GET_REFLECTION_OBJECT_PTR(attr); + + array_init(&ret); + + for (i = 0; i < attr->data->argc; i++) { + if (FAILURE == import_attribute_value(&tmp, &attr->data->argv[i], attr->scope)) { + zval_ptr_dtor(&ret); + RETURN_THROWS(); + } + + add_next_index_zval(&ret, &tmp); + } + + RETURN_ZVAL(&ret, 1, 1); +} +/* }}} */ + +static int call_attribute_constructor(zend_class_entry *ce, zend_object *obj, zval *args, uint32_t argc) /* {{{ */ +{ + zend_fcall_info fci; + zend_fcall_info_cache fcc; + + zend_function *ctor; + zval retval; + int ret; + + ctor = ce->constructor; + + ZEND_ASSERT(ctor != NULL); + + if (!(ctor->common.fn_flags & ZEND_ACC_PUBLIC)) { + zend_throw_error(NULL, "Attribute constructor of class '%s' must be public", ZSTR_VAL(ce->name)); + return FAILURE; + } + + fci.size = sizeof(fci); + ZVAL_UNDEF(&fci.function_name); + fci.object = obj; + fci.retval = &retval; + fci.params = args; + fci.param_count = argc; + fci.no_separation = 1; + + fcc.function_handler = ctor; + fcc.called_scope = ce; + fcc.object = obj; + + ret = zend_call_function(&fci, &fcc); + + if (EG(exception)) { + zend_object_store_ctor_failed(obj); + } + + zval_ptr_dtor(&retval); + + if (ret != SUCCESS) { + zend_throw_error(NULL, "Failed to invoke constructor of attribute class '%s'", ZSTR_VAL(ce->name)); + } + + return EG(exception) ? FAILURE : SUCCESS; +} +/* }}} */ + +static void attribute_ctor_cleanup(zval *obj, zval *args, uint32_t argc) /* {{{ */ +{ + if (obj) { + zval_ptr_dtor(obj); + } + + if (args) { + uint32_t i; + + for (i = 0; i < argc; i++) { + zval_ptr_dtor(&args[i]); + } + + efree(args); + } +} +/* }}} */ + +/* {{{ proto public object ReflectionAttribute::newInstance() + * Returns the attribute as an object */ +ZEND_METHOD(ReflectionAttribute, newInstance) +{ + reflection_object *intern; + attribute_reference *attr; + + zend_class_entry *ce; + zval obj; + + zval *args = NULL; + uint32_t count; + uint32_t argc = 0; + + if (zend_parse_parameters_none() == FAILURE) { + RETURN_THROWS(); + } + + GET_REFLECTION_OBJECT_PTR(attr); + + if (NULL == (ce = zend_lookup_class(attr->data->name))) { + zend_throw_error(NULL, "Attribute class '%s' not found", ZSTR_VAL(attr->data->name)); + RETURN_THROWS(); + } + + if (ce->type == ZEND_USER_CLASS && !zend_get_attribute_str(ce->info.user.attributes, ZEND_STRL("phpattribute"), 0)) { + zend_throw_error(NULL, "Attempting to use class '%s' as attribute that does not have <>.", ZSTR_VAL(attr->data->name)); + RETURN_THROWS(); + } else if (ce->type == ZEND_INTERNAL_CLASS && !zend_attribute_get_validator(attr->data->lcname)) { + zend_throw_error(NULL, "Attempting to use internal class '%s' as attribute that does not have <>.", ZSTR_VAL(attr->data->name)); + RETURN_THROWS(); + } + + if (SUCCESS != object_init_ex(&obj, ce)) { + RETURN_THROWS(); + } + + count = attr->data->argc; + + if (count) { + args = emalloc(count * sizeof(zval)); + + for (argc = 0; argc < attr->data->argc; argc++) { + if (FAILURE == import_attribute_value(&args[argc], &attr->data->argv[argc], attr->scope)) { + attribute_ctor_cleanup(&obj, args, argc); + RETURN_THROWS(); + } + } + } + + if (ce->constructor) { + if (FAILURE == call_attribute_constructor(ce, Z_OBJ(obj), args, argc)) { + attribute_ctor_cleanup(&obj, args, argc); + RETURN_THROWS(); + } + } else if (argc) { + attribute_ctor_cleanup(&obj, args, argc); + zend_throw_error(NULL, "Attribute class '%s' does not have a constructor, cannot pass arguments", ZSTR_VAL(ce->name)); + RETURN_THROWS(); + } + + attribute_ctor_cleanup(NULL, args, argc); + + RETURN_ZVAL(&obj, 1, 1); +} +/* }}} */ + static const zend_function_entry reflection_ext_functions[] = { /* {{{ */ PHP_FE_END }; /* }}} */ @@ -6345,6 +6779,13 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ _reflection_entry.ce_flags |= ZEND_ACC_FINAL; reflection_reference_ptr = zend_register_internal_class(&_reflection_entry); + INIT_CLASS_ENTRY(_reflection_entry, "ReflectionAttribute", class_ReflectionAttribute_methods); + reflection_init_class_handlers(&_reflection_entry); + _reflection_entry.ce_flags |= ZEND_ACC_FINAL; + reflection_attribute_ptr = zend_register_internal_class(&_reflection_entry); + + REGISTER_REFLECTION_CLASS_CONST_LONG(attribute, "IS_INSTANCEOF", REFLECTION_ATTRIBUTE_IS_INSTANCEOF); + REFLECTION_G(key_initialized) = 0; return SUCCESS; diff --git a/ext/reflection/php_reflection.h b/ext/reflection/php_reflection.h index e4e08c16e60bc..654ba55256c8f 100644 --- a/ext/reflection/php_reflection.h +++ b/ext/reflection/php_reflection.h @@ -42,6 +42,7 @@ extern PHPAPI zend_class_entry *reflection_property_ptr; extern PHPAPI zend_class_entry *reflection_extension_ptr; extern PHPAPI zend_class_entry *reflection_zend_extension_ptr; extern PHPAPI zend_class_entry *reflection_reference_ptr; +extern PHPAPI zend_class_entry *reflection_attribute_ptr; PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object); diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php index be6269fe78ba1..f33bcf1801b43 100644 --- a/ext/reflection/php_reflection.stub.php +++ b/ext/reflection/php_reflection.stub.php @@ -95,6 +95,9 @@ public function hasReturnType() {} /** @return ReflectionType|null */ public function getReturnType() {} + + /** @return ReflectionAttribute[] */ + public function getAttributes(?string $name = null, int $flags = 0) {} } class ReflectionFunction extends ReflectionFunctionAbstract @@ -360,6 +363,9 @@ public function getNamespaceName() {} /** @return string */ public function getShortName() {} + + /** @return ReflectionAttribute[] */ + public function getAttributes(?string $name = null, int $flags = 0) {} } class ReflectionObject extends ReflectionClass @@ -426,6 +432,9 @@ public function hasDefaultValue(): bool {} /** @return mixed */ public function getDefaultValue() {} + + /** @return ReflectionAttribute[] */ + public function getAttributes(?string $name = null, int $flags = 0) {} } class ReflectionClassConstant implements Reflector @@ -461,6 +470,9 @@ public function getDeclaringClass() {} /** @return string|false */ public function getDocComment() {} + + /** @return ReflectionAttribute[] */ + public function getAttributes(?string $name = null, int $flags = 0) {} } class ReflectionParameter implements Reflector @@ -529,6 +541,9 @@ public function getDefaultValueConstantName() {} /** @return bool */ public function isVariadic() {} + + /** @return ReflectionAttribute[] */ + public function getAttributes(?string $name = null, int $flags = 0) {} } abstract class ReflectionType implements Stringable @@ -636,3 +651,14 @@ private function __clone() {} private function __construct() {} } + +final class ReflectionAttribute +{ + public function getName(): string {} + public function getArguments(): array {} + public function newInstance(): object {} + + private function __clone() {} + + private function __construct() {} +} diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h index a0a606295b7ac..733d3f80b5f16 100644 --- a/ext/reflection/php_reflection_arginfo.h +++ b/ext/reflection/php_reflection_arginfo.h @@ -57,6 +57,11 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionFunctionAbstract_getReturnType arginfo_class_ReflectionFunctionAbstract___clone +ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionFunctionAbstract_getAttributes, 0, 0, 0) + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, name, IS_STRING, 1, "null") + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0") +ZEND_END_ARG_INFO() + ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionFunction___construct, 0, 0, 1) ZEND_ARG_INFO(0, name) ZEND_END_ARG_INFO() @@ -267,6 +272,8 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionClass_getShortName arginfo_class_ReflectionFunctionAbstract___clone +#define arginfo_class_ReflectionClass_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes + ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionObject___construct, 0, 0, 1) ZEND_ARG_TYPE_INFO(0, argument, IS_OBJECT, 0) ZEND_END_ARG_INFO() @@ -320,6 +327,8 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionProperty_getDefaultValue arginfo_class_ReflectionFunctionAbstract___clone +#define arginfo_class_ReflectionProperty_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes + #define arginfo_class_ReflectionClassConstant___clone arginfo_class_ReflectionFunctionAbstract___clone #define arginfo_class_ReflectionClassConstant___construct arginfo_class_ReflectionProperty___construct @@ -342,6 +351,8 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionClassConstant_getDocComment arginfo_class_ReflectionFunctionAbstract___clone +#define arginfo_class_ReflectionClassConstant_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes + #define arginfo_class_ReflectionParameter___clone arginfo_class_ReflectionFunctionAbstract___clone ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionParameter___construct, 0, 0, 2) @@ -387,6 +398,8 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionParameter_isVariadic arginfo_class_ReflectionFunctionAbstract___clone +#define arginfo_class_ReflectionParameter_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes + #define arginfo_class_ReflectionType___clone arginfo_class_ReflectionFunctionAbstract___clone #define arginfo_class_ReflectionType_allowsNull arginfo_class_ReflectionFunctionAbstract___clone @@ -455,6 +468,17 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionReference___construct arginfo_class_ReflectionFunctionAbstract___clone +#define arginfo_class_ReflectionAttribute_getName arginfo_class_ReflectionFunction___toString + +#define arginfo_class_ReflectionAttribute_getArguments arginfo_class_ReflectionUnionType_getTypes + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ReflectionAttribute_newInstance, 0, 0, IS_OBJECT, 0) +ZEND_END_ARG_INFO() + +#define arginfo_class_ReflectionAttribute___clone arginfo_class_ReflectionFunctionAbstract___clone + +#define arginfo_class_ReflectionAttribute___construct arginfo_class_ReflectionFunctionAbstract___clone + ZEND_METHOD(Reflection, getModifierNames); ZEND_METHOD(ReflectionClass, __clone); @@ -483,6 +507,7 @@ ZEND_METHOD(ReflectionFunctionAbstract, getStaticVariables); ZEND_METHOD(ReflectionFunctionAbstract, returnsReference); ZEND_METHOD(ReflectionFunctionAbstract, hasReturnType); ZEND_METHOD(ReflectionFunctionAbstract, getReturnType); +ZEND_METHOD(ReflectionFunctionAbstract, getAttributes); ZEND_METHOD(ReflectionFunction, __construct); ZEND_METHOD(ReflectionFunction, __toString); ZEND_METHOD(ReflectionFunction, isDisabled); @@ -564,6 +589,7 @@ ZEND_METHOD(ReflectionClass, getExtensionName); ZEND_METHOD(ReflectionClass, inNamespace); ZEND_METHOD(ReflectionClass, getNamespaceName); ZEND_METHOD(ReflectionClass, getShortName); +ZEND_METHOD(ReflectionClass, getAttributes); ZEND_METHOD(ReflectionObject, __construct); ZEND_METHOD(ReflectionProperty, __construct); ZEND_METHOD(ReflectionProperty, __toString); @@ -584,6 +610,7 @@ ZEND_METHOD(ReflectionProperty, getType); ZEND_METHOD(ReflectionProperty, hasType); ZEND_METHOD(ReflectionProperty, hasDefaultValue); ZEND_METHOD(ReflectionProperty, getDefaultValue); +ZEND_METHOD(ReflectionProperty, getAttributes); ZEND_METHOD(ReflectionClassConstant, __construct); ZEND_METHOD(ReflectionClassConstant, __toString); ZEND_METHOD(ReflectionClassConstant, getName); @@ -594,6 +621,7 @@ ZEND_METHOD(ReflectionClassConstant, isProtected); ZEND_METHOD(ReflectionClassConstant, getModifiers); ZEND_METHOD(ReflectionClassConstant, getDeclaringClass); ZEND_METHOD(ReflectionClassConstant, getDocComment); +ZEND_METHOD(ReflectionClassConstant, getAttributes); ZEND_METHOD(ReflectionParameter, __construct); ZEND_METHOD(ReflectionParameter, __toString); ZEND_METHOD(ReflectionParameter, getName); @@ -614,6 +642,7 @@ ZEND_METHOD(ReflectionParameter, getDefaultValue); ZEND_METHOD(ReflectionParameter, isDefaultValueConstant); ZEND_METHOD(ReflectionParameter, getDefaultValueConstantName); ZEND_METHOD(ReflectionParameter, isVariadic); +ZEND_METHOD(ReflectionParameter, getAttributes); ZEND_METHOD(ReflectionType, allowsNull); ZEND_METHOD(ReflectionType, __toString); ZEND_METHOD(ReflectionNamedType, getName); @@ -642,6 +671,11 @@ ZEND_METHOD(ReflectionZendExtension, getCopyright); ZEND_METHOD(ReflectionReference, fromArrayElement); ZEND_METHOD(ReflectionReference, getId); ZEND_METHOD(ReflectionReference, __construct); +ZEND_METHOD(ReflectionAttribute, getName); +ZEND_METHOD(ReflectionAttribute, getArguments); +ZEND_METHOD(ReflectionAttribute, newInstance); +ZEND_METHOD(ReflectionAttribute, __clone); +ZEND_METHOD(ReflectionAttribute, __construct); static const zend_function_entry class_ReflectionException_methods[] = { @@ -687,6 +721,7 @@ static const zend_function_entry class_ReflectionFunctionAbstract_methods[] = { ZEND_ME(ReflectionFunctionAbstract, returnsReference, arginfo_class_ReflectionFunctionAbstract_returnsReference, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionFunctionAbstract, hasReturnType, arginfo_class_ReflectionFunctionAbstract_hasReturnType, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionFunctionAbstract, getReturnType, arginfo_class_ReflectionFunctionAbstract_getReturnType, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionFunctionAbstract, getAttributes, arginfo_class_ReflectionFunctionAbstract_getAttributes, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -790,6 +825,7 @@ static const zend_function_entry class_ReflectionClass_methods[] = { ZEND_ME(ReflectionClass, inNamespace, arginfo_class_ReflectionClass_inNamespace, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getShortName, arginfo_class_ReflectionClass_getShortName, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, getAttributes, arginfo_class_ReflectionClass_getAttributes, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -821,6 +857,7 @@ static const zend_function_entry class_ReflectionProperty_methods[] = { ZEND_ME(ReflectionProperty, hasType, arginfo_class_ReflectionProperty_hasType, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionProperty, hasDefaultValue, arginfo_class_ReflectionProperty_hasDefaultValue, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionProperty, getDefaultValue, arginfo_class_ReflectionProperty_getDefaultValue, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionProperty, getAttributes, arginfo_class_ReflectionProperty_getAttributes, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -837,6 +874,7 @@ static const zend_function_entry class_ReflectionClassConstant_methods[] = { ZEND_ME(ReflectionClassConstant, getModifiers, arginfo_class_ReflectionClassConstant_getModifiers, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClassConstant, getDeclaringClass, arginfo_class_ReflectionClassConstant_getDeclaringClass, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClassConstant, getDocComment, arginfo_class_ReflectionClassConstant_getDocComment, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClassConstant, getAttributes, arginfo_class_ReflectionClassConstant_getAttributes, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -863,6 +901,7 @@ static const zend_function_entry class_ReflectionParameter_methods[] = { 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, getAttributes, arginfo_class_ReflectionParameter_getAttributes, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -927,3 +966,13 @@ static const zend_function_entry class_ReflectionReference_methods[] = { ZEND_ME(ReflectionReference, __construct, arginfo_class_ReflectionReference___construct, ZEND_ACC_PRIVATE) ZEND_FE_END }; + + +static const zend_function_entry class_ReflectionAttribute_methods[] = { + ZEND_ME(ReflectionAttribute, getName, arginfo_class_ReflectionAttribute_getName, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionAttribute, getArguments, arginfo_class_ReflectionAttribute_getArguments, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionAttribute, newInstance, arginfo_class_ReflectionAttribute_newInstance, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionAttribute, __clone, arginfo_class_ReflectionAttribute___clone, ZEND_ACC_PRIVATE) + ZEND_ME(ReflectionAttribute, __construct, arginfo_class_ReflectionAttribute___construct, ZEND_ACC_PRIVATE) + ZEND_FE_END +}; diff --git a/ext/reflection/tests/ReflectionClass_toString_001.phpt b/ext/reflection/tests/ReflectionClass_toString_001.phpt index 367645d019d5d..3dff0725167c9 100644 --- a/ext/reflection/tests/ReflectionClass_toString_001.phpt +++ b/ext/reflection/tests/ReflectionClass_toString_001.phpt @@ -27,7 +27,7 @@ Class [ class ReflectionClass implements Reflector, String Property [ public $name = '' ] } - - Methods [53] { + - Methods [54] { Method [ final private method __clone ] { - Parameters [0] { @@ -365,5 +365,13 @@ Class [ class ReflectionClass implements Reflector, String - Parameters [0] { } } + + Method [ public method getAttributes ] { + + - Parameters [2] { + Parameter #0 [ ?string $name = null ] + Parameter #1 [ int $flags = 0 ] + } + } } } diff --git a/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt b/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt index 61a0d24b0887a..81d3c8d55b146 100644 --- a/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt +++ b/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt @@ -8,7 +8,7 @@ $ext = new ReflectionExtension('reflection'); var_dump($ext->getClasses()); ?> --EXPECT-- -array(18) { +array(19) { ["ReflectionException"]=> object(ReflectionClass)#2 (1) { ["name"]=> @@ -99,4 +99,9 @@ array(18) { ["name"]=> string(19) "ReflectionReference" } + ["ReflectionAttribute"]=> + object(ReflectionClass)#20 (1) { + ["name"]=> + string(19) "ReflectionAttribute" + } } diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c index db573232233a9..012a39f2d9c91 100644 --- a/ext/tokenizer/tokenizer.c +++ b/ext/tokenizer/tokenizer.c @@ -266,22 +266,22 @@ PHP_MINIT_FUNCTION(tokenizer) zend_class_implements(php_token_ce, 1, zend_ce_stringable); name = zend_string_init("id", sizeof("id") - 1, 1); - zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, + zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG)); zend_string_release(name); name = zend_string_init("text", sizeof("text") - 1, 1); - zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, + zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING)); zend_string_release(name); name = zend_string_init("line", sizeof("line") - 1, 1); - zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, + zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG)); zend_string_release(name); name = zend_string_init("pos", sizeof("pos") - 1, 1); - zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, + zend_declare_typed_property(php_token_ce, name, &default_val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG)); zend_string_release(name); diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index ab152e0a45602..cdbc22e135dfd 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -217,7 +217,7 @@ PHP_MINIT_FUNCTION(zend_test) zval val; ZVAL_LONG(&val, 123); zend_declare_typed_property( - zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, + zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_CODE(IS_LONG, 0, 0)); zend_string_release(name); } @@ -228,7 +228,7 @@ PHP_MINIT_FUNCTION(zend_test) zval val; ZVAL_NULL(&val); zend_declare_typed_property( - zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, + zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_CLASS(class_name, 1, 0)); zend_string_release(name); } @@ -244,7 +244,7 @@ PHP_MINIT_FUNCTION(zend_test) zend_type type = ZEND_TYPE_INIT_PTR(type_list, _ZEND_TYPE_LIST_BIT, 1, 0); zval val; ZVAL_NULL(&val); - zend_declare_typed_property(zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, type); + zend_declare_typed_property(zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, NULL, type); zend_string_release(name); } @@ -253,7 +253,7 @@ PHP_MINIT_FUNCTION(zend_test) zval val; ZVAL_LONG(&val, 123); zend_declare_typed_property( - zend_test_class, name, &val, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC, NULL, + zend_test_class, name, &val, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC, NULL, NULL, (zend_type) ZEND_TYPE_INIT_CODE(IS_LONG, 0, 0)); zend_string_release(name); } diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c index 3b9b07097e50b..2b90635a307e6 100644 --- a/ext/zip/php_zip.c +++ b/ext/zip/php_zip.c @@ -851,7 +851,7 @@ static void php_zip_register_prop_handler(HashTable *prop_handler, char *name, z /* Register for reflection */ ZVAL_NULL(&tmp); - zend_declare_property_ex(zip_class_entry, str, &tmp, ZEND_ACC_PUBLIC, NULL); + zend_declare_property_ex(zip_class_entry, str, &tmp, ZEND_ACC_PUBLIC, NULL, NULL); zend_string_release_ex(str, 1); } /* }}} */ diff --git a/win32/build/config.w32 b/win32/build/config.w32 index 62dbeb40d9b08..d90b757a798b5 100644 --- a/win32/build/config.w32 +++ b/win32/build/config.w32 @@ -230,7 +230,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \ zend_execute_API.c zend_highlight.c \ zend_llist.c zend_vm_opcodes.c zend_opcode.c zend_operators.c zend_ptr_stack.c \ zend_stack.c zend_variables.c zend.c zend_API.c zend_extensions.c \ - zend_hash.c zend_list.c zend_builtin_functions.c \ + zend_hash.c zend_list.c zend_builtin_functions.c zend_attributes.c \ zend_ini.c zend_sort.c zend_multibyte.c zend_ts_hash.c \ zend_stream.c zend_iterators.c zend_interfaces.c zend_objects.c \ zend_object_handlers.c zend_objects_API.c \