Attributes v2

Zend/tests/attributes/001_placement.phpt

@@ -0,0 +1,112 @@
+--TEST--
+Attributes can be placed on all supported elements.
+--FILE--
+<?php
+
+<<A1(1)>>
+class Foo
+{
+    <<A1(2)>>
+    public const FOO = 'foo', BAR = 'bar';
+
+    <<A1(3)>>
+    public $x, $y;
+
+    <<A1(4)>>
+    public function foo(<<A1(5)>> $a, <<A1(6)>> $b) { }
+}
+
+$object = new <<A1(7)>> class () { };
+
+<<A1(8)>>
+function f1() { }
+
+$f2 = <<A1(9)>> function () { };
+
+$f3 = <<A1(10)>> 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) {
+    foreach ($r->getAttributes() as $attr) {
+        var_dump($attr->getName(), $attr->getArguments());
+    }
+}
+
+?>
+--EXPECT--
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(1)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(2)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(2)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(3)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(3)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(4)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(5)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(6)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(7)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(8)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(9)
+}
+string(2) "A1"
+array(1) {
+  [0]=>
+  int(10)
+}

Zend/tests/attributes/002_rfcexample.phpt

@@ -0,0 +1,41 @@
+--TEST--
+Attributes: RFC Example
+--FILE--
+<?php
+namespace My\Attributes {
+    use PhpAttribute;
+
+    <<PhpAttribute>>
+    class SingleArgument {
+        public $argumentValue;
+
+        public function __construct($argumentValue) {
+             $this->argumentValue = $argumentValue;
+        }
+    }
+}
+
+namespace {
+    use My\Attributes\SingleArgument;
+
+    <<SingleArgument("Hello World")>>
+    class Foo {
+    }
+
+    $reflectionClass = new \ReflectionClass(Foo::class);
+    $attributes = $reflectionClass->getAttributes();
+
+    var_dump($attributes[0]->getName());
+    var_dump($attributes[0]->getArguments());
+    var_dump($attributes[0]->getAsObject());
+}
+--EXPECTF--
+string(28) "My\Attributes\SingleArgument"
+array(1) {
+  [0]=>
+  string(11) "Hello World"
+}
+object(My\Attributes\SingleArgument)#3 (1) {
+  ["argumentValue"]=>
+  string(11) "Hello World"
+}

Zend/tests/attributes/003_ast_nodes.phpt

@@ -0,0 +1,68 @@
+--TEST--
+Attributes can deal with AST nodes.
+--FILE--
+<?php
+
+define('V1', strtoupper(php_sapi_name()));
+
+<<A1([V1 => 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";
+
+<<A1(V1, 1 + 2, C1::class)>>
+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";
+
+<<A1(self::FOO, C1::BAR)>>
+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);
+
+?>
+--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)

Zend/tests/attributes/004_name_resolution.phpt

@@ -0,0 +1,39 @@
+--TEST--
+Resolve attribute names
+--FILE--
+<?php
+function dump_attributes($attributes) {
+    $arr = [];
+    foreach ($attributes as $attribute) {
+        $arr[$attribute->getName()] = $attribute->getArguments();
+    }
+    var_dump($arr);
+}
+
+namespace Doctrine\ORM\Mapping {
+    class Entity {
+    }
+}
+
+namespace Foo {
+    use Doctrine\ORM\Mapping\Entity;
+
+    <<Entity(["foo" => "bar"])>>
+    function foo() {
+    }
+}
+
+namespace {
+    dump_attributes((new ReflectionFunction('Foo\foo'))->getAttributes());
+}
+--EXPECTF--
+array(1) {
+  ["Doctrine\ORM\Mapping\Entity"]=>
+  array(1) {
+    [0]=>
+    array(1) {
+      ["foo"]=>
+      string(3) "bar"
+    }
+  }
+}

Zend/tests/attributes/005_objects.phpt

@@ -0,0 +1,102 @@
+--TEST--
+Attributes can be converted into objects.
+--FILE--
+<?php
+
+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(<<A1('test')>> function () { });
+
+foreach ($ref->getAttributes() as $attr) {
+	$obj = $attr->getAsObject();
+
+	var_dump(get_class($obj), $obj->name, $obj->ttl);
+}
+
+echo "\n";
+
+$ref = new \ReflectionFunction(<<A1>> function () { });
+
+try {
+	$ref->getAttributes()[0]->getAsObject();
+} catch (\ArgumentCountError $e) {
+	var_dump('ERROR 1', $e->getMessage());
+}
+
+echo "\n";
+
+$ref = new \ReflectionFunction(<<A1([])>> function () { });
+
+try {
+	$ref->getAttributes()[0]->getAsObject();
+} catch (\TypeError $e) {
+	var_dump('ERROR 2', $e->getMessage());
+}
+
+echo "\n";
+
+$ref = new \ReflectionFunction(<<A2>> function () { });
+
+try {
+	$ref->getAttributes()[0]->getAsObject();
+} catch (\Error $e) {
+	var_dump('ERROR 3', $e->getMessage());
+}
+
+echo "\n";
+
+class A3
+{
+	private function __construct() { }
+}
+
+$ref = new \ReflectionFunction(<<A3>> function () { });
+
+try {
+	$ref->getAttributes()[0]->getAsObject();
+} catch (\Error $e) {
+	var_dump('ERROR 4', $e->getMessage());
+}
+
+echo "\n";
+
+class A4 { }
+
+$ref = new \ReflectionFunction(<<A4(1)>> function () { });
+
+try {
+	$ref->getAttributes()[0]->getAsObject();
+} catch (\Error $e) {
+	var_dump('ERROR 5', $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"