added support for intersection types foo&bar

Author: dg

readme.md

@@ -188,14 +188,14 @@ $class->addMember($methodRecount);
 Types
 -----
 
-Each type or union type can be passed as a string, you can also use predefined constants for native types:
+Each type or union/intersection type can be passed as a string, you can also use predefined constants for native types:
 
 ```php
 use Nette\PhpGenerator\Type;
 
-$member->setType('array');
-$member->setType(Type::ARRAY);
-$member->setType('array|string');
+$member->setType('array'); // or Type::ARRAY;
+$member->setType('array|string'); // or Type::union('array', 'string')
+$member->setType('Foo&Bar'); // or Type::intersection(Foo::class, Bar::class)
 $member->setType(null); // removes type
 ```
 

src/PhpGenerator/Factory.php

@@ -126,7 +126,10 @@ public function fromMethodReflection(\ReflectionMethod $from): Method
 		if ($from->getReturnType() instanceof \ReflectionNamedType) {
 			$method->setReturnType($from->getReturnType()->getName());
 			$method->setReturnNullable($from->getReturnType()->allowsNull());
-		} elseif ($from->getReturnType() instanceof \ReflectionUnionType) {
+		} elseif (
+			$from->getReturnType() instanceof \ReflectionUnionType
+			|| $from->getReturnType() instanceof \ReflectionIntersectionType
+		) {
 			$method->setReturnType((string) $from->getReturnType());
 		}
 		return $method;
@@ -147,7 +150,10 @@ public function fromFunctionReflection(\ReflectionFunction $from, bool $withBody
 		if ($from->getReturnType() instanceof \ReflectionNamedType) {
 			$function->setReturnType($from->getReturnType()->getName());
 			$function->setReturnNullable($from->getReturnType()->allowsNull());
-		} elseif ($from->getReturnType() instanceof \ReflectionUnionType) {
+		} elseif (
+			$from->getReturnType() instanceof \ReflectionUnionType
+			|| $from->getReturnType() instanceof \ReflectionIntersectionType
+		) {
 			$function->setReturnType((string) $from->getReturnType());
 		}
 		$function->setBody($withBody ? $this->loadFunctionBody($from) : '');
@@ -174,7 +180,10 @@ public function fromParameterReflection(\ReflectionParameter $from): Parameter
 		if ($from->getType() instanceof \ReflectionNamedType) {
 			$param->setType($from->getType()->getName());
 			$param->setNullable($from->getType()->allowsNull());
-		} elseif ($from->getType() instanceof \ReflectionUnionType) {
+		} elseif (
+			$from->getType() instanceof \ReflectionUnionType
+			|| $from->getType() instanceof \ReflectionIntersectionType
+		) {
 			$param->setType((string) $from->getType());
 		}
 		if ($from->isDefaultValueAvailable()) {
@@ -228,7 +237,10 @@ public function fromPropertyReflection(\ReflectionProperty $from): Property
 			if ($from->getType() instanceof \ReflectionNamedType) {
 				$prop->setType($from->getType()->getName());
 				$prop->setNullable($from->getType()->allowsNull());
-			} elseif ($from->getType() instanceof \ReflectionUnionType) {
+			} elseif (
+				$from->getType() instanceof \ReflectionUnionType
+				|| $from->getType() instanceof \ReflectionIntersectionType
+			) {
 				$prop->setType((string) $from->getType());
 			}
 			$prop->setInitialized($from->hasType() && array_key_exists($prop->getName(), $defaults));

src/PhpGenerator/PhpNamespace.php

@@ -126,9 +126,9 @@ public function getUses(): array
 	}
 
 
-	public function unresolveUnionType(string $type): string
+	public function unresolveType(string $type): string
 	{
-		return implode('|', array_map([$this, 'unresolveName'], explode('|', $type)));
+		return preg_replace_callback('~[^|&?]+~', function ($m) { return $this->unresolveName($m[0]); }, $type);
 	}
 
 

src/PhpGenerator/Printer.php

@@ -119,7 +119,7 @@ public function printClass(ClassType $class, PhpNamespace $namespace = null): st
 	{
 		$class->validate();
 		$resolver = $this->resolveTypes && $namespace
-			? [$namespace, 'unresolveUnionType']
+			? [$namespace, 'unresolveType']
 			: function ($s) { return $s; };
 
 		$traits = [];
@@ -310,7 +310,7 @@ public function printType(?string $type, bool $nullable = false, PhpNamespace $n
 			return '';
 		}
 		if ($this->resolveTypes && $namespace) {
-			$type = $namespace->unresolveUnionType($type);
+			$type = $namespace->unresolveType($type);
 		}
 		if ($nullable && strcasecmp($type, 'mixed')) {
 			$type = strpos($type, '|') === false

src/PhpGenerator/Type.php

@@ -46,6 +46,12 @@ public static function union(string ...$types): string
 	}
 
 
+	public static function intersection(string ...$types): string
+	{
+		return implode('&', $types);
+	}
+
+
 	public static function getType($value): ?string
 	{
 		if (is_object($value)) {

tests/PhpGenerator/ClassType.from.81.phpt

@@ -0,0 +1,17 @@
+<?php
+
+/**
+ * @phpVersion 8.1
+ */
+
+declare(strict_types=1);
+
+use Nette\PhpGenerator\ClassType;
+
+
+require __DIR__ . '/../bootstrap.php';
+require __DIR__ . '/fixtures/classes.php81';
+
+$res[] = ClassType::from(new Abc\Class11);
+
+sameFile(__DIR__ . '/expected/ClassType.from.81.expect', implode("\n", $res));

tests/PhpGenerator/PhpNamespace.phpt

@@ -36,9 +36,11 @@ Assert::same('\A', $namespace->unresolveName('\A'));
 Assert::same('\A', $namespace->unresolveName('A'));
 Assert::same('A', $namespace->unresolveName('foo\A'));
 
-Assert::same('A', $namespace->unresolveUnionType('foo\A'));
-Assert::same('null|A', $namespace->unresolveUnionType('null|foo\A'));
-Assert::same('', $namespace->unresolveUnionType(''));
+Assert::same('A', $namespace->unresolveType('foo\A'));
+Assert::same('null|A', $namespace->unresolveType('null|foo\A'));
+Assert::same('?A', $namespace->unresolveType('?foo\A'));
+Assert::same('A&\Countable', $namespace->unresolveType('foo\A&Countable'));
+Assert::same('', $namespace->unresolveType(''));
 
 $namespace->addUse('Bar\C');
 Assert::same(['C' => 'Bar\\C'], $namespace->getUses());

tests/PhpGenerator/expected/ClassType.from.81.expect

@@ -0,0 +1,9 @@
+class Class11
+{
+	public Foo&Bar $foo;
+
+
+	public function foo(Foo&Bar $c): Foo&Bar
+	{
+	}
+}

tests/PhpGenerator/fixtures/classes.php81

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Abc;
+
+class Class11
+{
+	public Foo&Bar $foo;
+
+	public function foo(Foo&Bar $c): Foo&Bar {
+	}
+}