added support for PHP 8 attributes

dg · dg · commit 1e896b3b1fce · 2020-11-02T17:16:58.000+01:00
diff --git a/readme.md b/readme.md
@@ -346,6 +346,44 @@ Result:
 fn ($a, $b) => $a + $b
 ```
 
+Attributes
+----------
+
+You can add PHP 8 attributes to all classes, methods, properties, constants, functions, closures and parameters.
+
+```php
+$class = new Nette\PhpGenerator\ClassType('Demo');
+$class->addAttribute('Deprecated');
+
+$class->addProperty('list')
+	->addAttribute('WithArguments', [1, 2]);
+
+$method = $class->addMethod('count')
+	->addAttribute('Foo\Cached', ['mode' => true]);
+
+$method->addParameter('items')
+	->addAttribute('Bar');
+
+echo $class;
+```
+
+Result:
+
+```php
+#[Deprecated]
+class Demo
+{
+	#[WithArguments(1, 2)]
+	public $list;
+
+
+	#[Foo\Cached(mode: true)]
+	public function count(#[Bar] $items)
+	{
+	}
+}
+```
+
 Method and Function Body Generator
 ----------------------------------
 
@@ -468,7 +506,7 @@ Class Names Resolving
 ---------------------
 
 **When the class is part of the namespace, it is rendered slightly differently**: all types (ie. type hints, return types, parent class name,
-implemented interfaces and used traits) are automatically *resolved* (unless you turn it off, see below).
+implemented interfaces, used traits and attributes) are automatically *resolved* (unless you turn it off, see below).
 It means that you have to **use full class names** in definitions and they will be replaced
 with aliases (according to the use-statements) or fully qualified names in the resulting code:
 
diff --git a/src/PhpGenerator/Attribute.php b/src/PhpGenerator/Attribute.php
@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette\PhpGenerator;
+
+use Nette;
+
+
+/**
+ * PHP Attribute.
+ */
+final class Attribute
+{
+	use Nette\SmartObject;
+
+	/** @var string */
+	private $name;
+
+	/** @var array */
+	private $args;
+
+
+	public function __construct(string $name, array $args)
+	{
+		if (!Helpers::isNamespaceIdentifier($name)) {
+			throw new Nette\InvalidArgumentException("Value '$name' is not valid attribute name.");
+		}
+		$this->name = $name;
+		$this->args = $args;
+	}
+
+
+	public function getName(): string
+	{
+		return $this->name;
+	}
+
+
+	public function getArguments(): array
+	{
+		return $this->args;
+	}
+}
diff --git a/src/PhpGenerator/ClassType.php b/src/PhpGenerator/ClassType.php
@@ -22,6 +22,7 @@ final class ClassType
 {
 	use Nette\SmartObject;
 	use Traits\CommentAware;
+	use Traits\AttributeAware;
 
 	public const
 		TYPE_CLASS = 'class',
diff --git a/src/PhpGenerator/Closure.php b/src/PhpGenerator/Closure.php
@@ -21,6 +21,7 @@ final class Closure
 {
 	use Nette\SmartObject;
 	use Traits\FunctionLike;
+	use Traits\AttributeAware;
 
 	/** @var Parameter[] */
 	private $uses = [];
diff --git a/src/PhpGenerator/Constant.php b/src/PhpGenerator/Constant.php
@@ -21,6 +21,7 @@ final class Constant
 	use Traits\NameAware;
 	use Traits\VisibilityAware;
 	use Traits\CommentAware;
+	use Traits\AttributeAware;
 
 	/** @var mixed */
 	private $value;
diff --git a/src/PhpGenerator/GlobalFunction.php b/src/PhpGenerator/GlobalFunction.php
@@ -23,6 +23,7 @@ final class GlobalFunction
 	use Traits\FunctionLike;
 	use Traits\NameAware;
 	use Traits\CommentAware;
+	use Traits\AttributeAware;
 
 	public static function from(string $function): self
 	{
diff --git a/src/PhpGenerator/Method.php b/src/PhpGenerator/Method.php
@@ -24,6 +24,7 @@ final class Method
 	use Traits\NameAware;
 	use Traits\VisibilityAware;
 	use Traits\CommentAware;
+	use Traits\AttributeAware;
 
 	/** @var string|null */
 	private $body = '';
diff --git a/src/PhpGenerator/Parameter.php b/src/PhpGenerator/Parameter.php
@@ -21,6 +21,7 @@ class Parameter
 {
 	use Nette\SmartObject;
 	use Traits\NameAware;
+	use Traits\AttributeAware;
 
 	/** @var bool */
 	private $reference = false;
diff --git a/src/PhpGenerator/Printer.php b/src/PhpGenerator/Printer.php
@@ -39,6 +39,7 @@ class Printer
 	public function printFunction(GlobalFunction $function, PhpNamespace $namespace = null): string
 	{
 		return Helpers::formatDocComment($function->getComment() . "\n")
+			. self::printAttributes($function->getAttributes(), $namespace)
 			. 'function '
 			. ($function->getReturnReference() ? '&' : '')
 			. $function->getName()
@@ -58,7 +59,8 @@ public function printClosure(Closure $closure): string
 			? "\n" . $this->indentation . implode(",\n" . $this->indentation, $uses) . "\n"
 			: $tmp;
 
-		return 'function '
+		return self::printAttributes($closure->getAttributes(), null, true)
+			. 'function '
 			. ($closure->getReturnReference() ? '&' : '')
 			. $this->printParameters($closure, null)
 			. ($uses ? " use ($useStr)" : '')
@@ -75,7 +77,8 @@ public function printArrowFunction(Closure $closure): string
 			}
 		}
 
-		return 'fn '
+		return self::printAttributes($closure->getAttributes(), null)
+			. 'fn '
 			. ($closure->getReturnReference() ? '&' : '')
 			. $this->printParameters($closure, null)
 			. $this->printReturnType($closure, null)
@@ -87,6 +90,7 @@ public function printMethod(Method $method, PhpNamespace $namespace = null): str
 	{
 		$method->validate();
 		return Helpers::formatDocComment($method->getComment() . "\n")
+			. self::printAttributes($method->getAttributes(), $namespace)
 			. ($method->isAbstract() ? 'abstract ' : '')
 			. ($method->isFinal() ? 'final ' : '')
 			. ($method->getVisibility() ? $method->getVisibility() . ' ' : '')
@@ -122,6 +126,7 @@ public function printClass(ClassType $class, PhpNamespace $namespace = null): st
 		foreach ($class->getConstants() as $const) {
 			$def = ($const->getVisibility() ? $const->getVisibility() . ' ' : '') . 'const ' . $const->getName() . ' = ';
 			$consts[] = Helpers::formatDocComment((string) $const->getComment())
+				. self::printAttributes($const->getAttributes(), $namespace)
 				. $def
 				. $this->dump($const->getValue(), strlen($def)) . ";\n";
 		}
@@ -134,6 +139,7 @@ public function printClass(ClassType $class, PhpNamespace $namespace = null): st
 				. '$' . $property->getName());
 
 			$properties[] = Helpers::formatDocComment((string) $property->getComment())
+				. self::printAttributes($property->getAttributes(), $namespace)
 				. $def
 				. ($property->getValue() === null && !$property->isInitialized() ? '' : ' = ' . $this->dump($property->getValue(), strlen($def) + 3)) // 3 = ' = '
 				. ";\n";
@@ -154,6 +160,7 @@ public function printClass(ClassType $class, PhpNamespace $namespace = null): st
 
 		return Strings::normalize(
 			Helpers::formatDocComment($class->getComment() . "\n")
+			. self::printAttributes($class->getAttributes(), $namespace)
 			. ($class->isAbstract() ? 'abstract ' : '')
 			. ($class->isFinal() ? 'final ' : '')
 			. ($class->getName() ? $class->getType() . ' ' . $class->getName() . ' ' : '')
@@ -259,14 +266,15 @@ public function printParameters($function, PhpNamespace $namespace = null): stri
 			$promoted = $param instanceof PromotedParameter ? $param : null;
 			$params[] =
 				($promoted ? Helpers::formatDocComment((string) $promoted->getComment()) : '')
-				. ($promoted ? ($promoted->getVisibility() ?: 'public') . ' ' : '')
+				. ($attrs = self::printAttributes($param->getAttributes(), $namespace, true))
+				. ($promoted ? ($param->getVisibility() ?: 'public') . ' ' : '')
 				. ltrim($this->printType($type, $param->isNullable(), $namespace) . ' ')
 				. ($param->isReference() ? '&' : '')
 				. ($variadic ? '...' : '')
 				. '$' . $param->getName()
 				. ($param->hasDefaultValue() && !$variadic ? ' = ' . $this->dump($param->getDefaultValue()) : '');
 
-			$special = $special || $promoted;
+			$special = $special || $promoted || $attrs;
 		}
 
 		$line = implode(', ', $params);
@@ -296,6 +304,22 @@ private function printReturnType($function, ?PhpNamespace $namespace): string
 	}
 
 
+	private function printAttributes(array $attrs, ?PhpNamespace $namespace, bool $inline = false): string
+	{
+		if (!$attrs) {
+			return '';
+		}
+		$items = [];
+		foreach ($attrs as $attr) {
+			$args = (new Dumper)->format('...?', $attr->getArguments());
+			$items[] = $this->printType($attr->getName(), false, $namespace) . ($args ? "($args)" : '');
+		}
+		return $inline
+			? '#[' . implode(', ', $items) . '] '
+			: '#[' . implode("]\n#[", $items) . "]\n";
+	}
+
+
 	private function joinProperties(array $props)
 	{
 		return $this->linesBetweenProperties
diff --git a/src/PhpGenerator/Property.php b/src/PhpGenerator/Property.php
@@ -23,6 +23,7 @@ final class Property
 	use Traits\NameAware;
 	use Traits\VisibilityAware;
 	use Traits\CommentAware;
+	use Traits\AttributeAware;
 
 	/** @var mixed */
 	private $value;
diff --git a/src/PhpGenerator/Traits/AttributeAware.php b/src/PhpGenerator/Traits/AttributeAware.php
@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+declare(strict_types=1);
+
+namespace Nette\PhpGenerator\Traits;
+
+use Nette\PhpGenerator\Attribute;
+
+
+/**
+ * @internal
+ */
+trait AttributeAware
+{
+	/** @var Attribute[] */
+	private $attributes = [];
+
+
+	/** @return static */
+	public function addAttribute(string $name, array $args = []): self
+	{
+		$this->attributes[] = new Attribute($name, $args);
+		return $this;
+	}
+
+
+	/**
+	 * @param  Attribute[]  $attrs
+	 * @return static
+	 */
+	public function setAttributes(array $attrs): self
+	{
+		(function (Attribute ...$attrs) {})(...$attrs);
+		$this->attributes = $attrs;
+		return $this;
+	}
+
+
+	/** @return Attribute[] */
+	public function getAttributes(): array
+	{
+		return $this->attributes;
+	}
+}
diff --git a/tests/PhpGenerator/ClassType.attributes.phpt b/tests/PhpGenerator/ClassType.attributes.phpt
@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * Test: Nette\PhpGenerator for classes.
+ */
+
+declare(strict_types=1);
+
+use Nette\PhpGenerator\ClassType;
+use Nette\PhpGenerator\PhpLiteral;
+
+
+require __DIR__ . '/../bootstrap.php';
+
+
+$class = new ClassType('Example');
+
+$class
+	->addComment('Description of class.')
+	->addAttribute('ExampleAttribute')
+	->addAttribute('WithArgument', [new PhpLiteral('Foo::BAR')])
+	->addAttribute('NamedArguments', ['foo' => 'bar', 'bar' => [1, 2, 3]]);
+
+$class->addConstant('FOO', 123)
+	->addComment('Commented')
+	->addAttribute('ExampleAttribute')
+	->addAttribute('WithArguments', [true]);
+
+$class->addProperty('handle')
+	->addComment('@var resource')
+	->addAttribute('ExampleAttribute');
+
+$method = $class->addMethod('getHandle')
+	->addComment('Returns file handle.')
+	->addAttribute('ExampleAttribute');
+
+$method->addParameter('mode')
+	->addAttribute('ExampleAttribute')
+	->addAttribute('WithArguments', [123]);
+
+sameFile(__DIR__ . '/expected/ClassType.attributes.expect', (string) $class);
diff --git a/tests/PhpGenerator/ClassType.promotion.phpt b/tests/PhpGenerator/ClassType.promotion.phpt
@@ -15,6 +15,7 @@ $method->addPromotedParameter('b');
 $method->addPromotedParameter('c')
 	->setPrivate()
 	->setType('string')
-	->addComment('promo');
+	->addComment('promo')
+	->addAttribute('Example');
 
 sameFile(__DIR__ . '/expected/ClassType.promotion.expect', (string) $class);
diff --git a/tests/PhpGenerator/Closure.phpt b/tests/PhpGenerator/Closure.phpt
@@ -66,6 +66,19 @@ same(
 
 
 
+$function = new Closure;
+$function->setBody('return $a + $b;');
+$function->addAttribute('ExampleAttribute');
+
+same(
+	'#[ExampleAttribute] function () {
+	return $a + $b;
+}',
+	(string) $function
+);
+
+
+
 $closure = function (stdClass $a, $b = null) {};
 $function = Closure::from($closure);
 same(
diff --git a/tests/PhpGenerator/GlobalFunction.phpt b/tests/PhpGenerator/GlobalFunction.phpt
diff --git a/tests/PhpGenerator/PhpNamespace.phpt b/tests/PhpGenerator/PhpNamespace.phpt
diff --git a/tests/PhpGenerator/expected/ClassType.attributes.expect b/tests/PhpGenerator/expected/ClassType.attributes.expect
diff --git a/tests/PhpGenerator/expected/ClassType.promotion.expect b/tests/PhpGenerator/expected/ClassType.promotion.expect
diff --git a/tests/PhpGenerator/expected/PhpNamespace.expect b/tests/PhpGenerator/expected/PhpNamespace.expect

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ final class ClassType`
`22`	`22`	`{`
`23`	`23`	`use Nette\SmartObject;`
`24`	`24`	`use Traits\CommentAware;`
	`25`	`+ use Traits\AttributeAware;`
`25`	`26`
`26`	`27`	`public const`
`27`	`28`	`TYPE_CLASS = 'class',`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ final class Closure`
`21`	`21`	`{`
`22`	`22`	`use Nette\SmartObject;`
`23`	`23`	`use Traits\FunctionLike;`
	`24`	`+ use Traits\AttributeAware;`
`24`	`25`
`25`	`26`	`/** @var Parameter[] */`
`26`	`27`	`private $uses = [];`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ final class GlobalFunction`
`23`	`23`	`use Traits\FunctionLike;`
`24`	`24`	`use Traits\NameAware;`
`25`	`25`	`use Traits\CommentAware;`
	`26`	`+ use Traits\AttributeAware;`
`26`	`27`
`27`	`28`	`public static function from(string $function): self`
`28`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@ class Parameter`
`21`	`21`	`{`
`22`	`22`	`use Nette\SmartObject;`
`23`	`23`	`use Traits\NameAware;`
	`24`	`+ use Traits\AttributeAware;`
`24`	`25`
`25`	`26`	`/** @var bool */`
`26`	`27`	`private $reference = false;`