Remove type logic from this package

src/DocBlock/Tags/Factory/AbstractPHPStanFactory.php

@@ -50,6 +50,10 @@ class AbstractPHPStanFactory implements Factory
         $tokens = $this->lexer->tokenize($tagLine);
         $ast = $this->parser->parseTag(new TokenIterator($tokens));
 
+        if ($context === null) {
+            $context = new TypeContext('');
+        }
+
         foreach ($this->factories as $factory) {
             if ($factory->supports($ast, $context)) {
                 return $factory->create($ast, $context);

src/DocBlock/Tags/Factory/MethodFactory.php

@@ -9,6 +9,7 @@ use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\Method;
 use phpDocumentor\Reflection\DocBlock\Tags\MethodParameter;
 use phpDocumentor\Reflection\Type;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use phpDocumentor\Reflection\Types\Mixed_;
 use phpDocumentor\Reflection\Types\Void_;
@@ -25,16 +26,16 @@ use function trim;
  */
 final class MethodFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, MethodTagValueNode::class);
@@ -50,7 +51,7 @@ final class MethodFactory implements PHPStanFactory
                 function (MethodTagValueParameterNode $param) use ($context) {
                     return new MethodParameter(
                         trim($param->parameterName, '$'),
-                        $this->typeFactory->createType($param->type, $context) ?? new Mixed_(),
+                        $this->typeResolver->createType($param->type, $context) ?? new Mixed_(),
                         $param->isReference,
                         $param->isVariadic,
                         (string) $param->defaultValue
@@ -61,13 +62,13 @@ final class MethodFactory implements PHPStanFactory
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof MethodTagValueNode;
     }
 
-    private function createReturnType(MethodTagValueNode $tagValue, ?Context $context): Type
+    private function createReturnType(MethodTagValueNode $tagValue, Context $context): Type
     {
-        return $this->typeFactory->createType($tagValue->returnType, $context) ?? new Void_();
+        return $this->typeResolver->createType($tagValue->returnType, $context) ?? new Void_();
     }
 }

src/DocBlock/Tags/Factory/PHPStanFactory.php

@@ -10,7 +10,7 @@ use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 
 interface PHPStanFactory
 {
-    public function create(PhpDocTagNode $node, ?Context $context): Tag;
+    public function create(PhpDocTagNode $node, Context $context): Tag;
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool;
+    public function supports(PhpDocTagNode $node, Context $context): bool;
 }

src/DocBlock/Tags/Factory/ParamFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\Param;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
@@ -19,30 +20,30 @@ use function trim;
  */
 final class ParamFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, ParamTagValueNode::class);
 
         return new Param(
             trim($tagValue->parameterName, '$'),
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $tagValue->isVariadic,
             $this->descriptionFactory->create($tagValue->description, $context),
             $tagValue->isReference
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof ParamTagValueNode;
     }

src/DocBlock/Tags/Factory/PropertyFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\Property;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode;
@@ -19,28 +20,28 @@ use function trim;
  */
 final class PropertyFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, PropertyTagValueNode::class);
 
         return new Property(
             trim($tagValue->propertyName, '$'),
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $this->descriptionFactory->create($tagValue->description, $context)
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof PropertyTagValueNode && $node->name === '@property';
     }

src/DocBlock/Tags/Factory/PropertyReadFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\PropertyRead;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode;
@@ -19,28 +20,28 @@ use function trim;
  */
 final class PropertyReadFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
+        $this->typeResolver = $typeResolver;
         $this->descriptionFactory = $descriptionFactory;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, PropertyTagValueNode::class);
 
         return new PropertyRead(
             trim($tagValue->propertyName, '$'),
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $this->descriptionFactory->create($tagValue->description, $context)
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof PropertyTagValueNode && $node->name === '@property-read';
     }

src/DocBlock/Tags/Factory/PropertyWriteFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\PropertyWrite;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode;
@@ -19,28 +20,28 @@ use function trim;
  */
 final class PropertyWriteFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, PropertyTagValueNode::class);
 
         return new PropertyWrite(
             trim($tagValue->propertyName, '$'),
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $this->descriptionFactory->create($tagValue->description, $context)
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof PropertyTagValueNode && $node->name === '@property-write';
     }

src/DocBlock/Tags/Factory/ReturnFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\Return_;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
@@ -17,27 +18,27 @@ use Webmozart\Assert\Assert;
  */
 final class ReturnFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, ReturnTagValueNode::class);
 
         return new Return_(
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $this->descriptionFactory->create($tagValue->description, $context)
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof ReturnTagValueNode;
     }

src/DocBlock/Tags/Factory/TypeFactory.php

@@ -1,230 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
-
-use phpDocumentor\Reflection\FqsenResolver;
-use phpDocumentor\Reflection\PseudoTypes\ArrayShape;
-use phpDocumentor\Reflection\PseudoTypes\ArrayShapeItem;
-use phpDocumentor\Reflection\PseudoTypes\ConstExpression;
-use phpDocumentor\Reflection\PseudoTypes\FloatValue;
-use phpDocumentor\Reflection\PseudoTypes\IntegerRange;
-use phpDocumentor\Reflection\PseudoTypes\IntegerValue;
-use phpDocumentor\Reflection\PseudoTypes\List_;
-use phpDocumentor\Reflection\PseudoTypes\StringValue;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\TypeResolver;
-use phpDocumentor\Reflection\Types\Array_;
-use phpDocumentor\Reflection\Types\Callable_;
-use phpDocumentor\Reflection\Types\CallableParameter;
-use phpDocumentor\Reflection\Types\ClassString;
-use phpDocumentor\Reflection\Types\Collection;
-use phpDocumentor\Reflection\Types\Compound;
-use phpDocumentor\Reflection\Types\Context;
-use phpDocumentor\Reflection\Types\InterfaceString;
-use phpDocumentor\Reflection\Types\Intersection;
-use phpDocumentor\Reflection\Types\Nullable;
-use phpDocumentor\Reflection\Types\This;
-use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprFloatNode;
-use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
-use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode;
-use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
-use PHPStan\PhpDocParser\Ast\Type\ArrayShapeItemNode;
-use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode;
-use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\CallableTypeParameterNode;
-use PHPStan\PhpDocParser\Ast\Type\ConditionalTypeForParameterNode;
-use PHPStan\PhpDocParser\Ast\Type\ConditionalTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\IntersectionTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\NullableTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\OffsetAccessTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\ThisTypeNode;
-use PHPStan\PhpDocParser\Ast\Type\TypeNode;
-use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
-
-use function array_filter;
-use function array_map;
-use function array_reverse;
-use function get_class;
-use function strtolower;
-
-/**
- * @internal This class is not part of the BC promise of this library.
- */
-final class TypeFactory
-{
-    private TypeResolver $resolver;
-    private FqsenResolver $fqsenResolver;
-
-    public function __construct(TypeResolver $resolver, FqsenResolver $fqsenResolver)
-    {
-        $this->resolver = $resolver;
-        $this->fqsenResolver = $fqsenResolver;
-    }
-
-    public function createType(?TypeNode $type, ?Context $context): ?Type
-    {
-        if ($type === null) {
-            return null;
-        }
-
-        switch (get_class($type)) {
-            case ArrayTypeNode::class:
-                return new Array_(
-                    $this->createType($type->type, $context)
-                );
-
-            case ArrayShapeNode::class:
-                return new ArrayShape(
-                    ...array_map(
-                        fn (ArrayShapeItemNode $item) => new ArrayShapeItem(
-                            (string) $item->keyName,
-                            $this->createType($item->valueType, $context),
-                            $item->optional
-                        ),
-                        $type->items
-                    )
-                );
-
-            case CallableTypeNode::class:
-                return $this->createFromCallable($type, $context);
-
-            case ConstTypeNode::class:
-                return $this->createFromConst($type, $context);
-
-            case GenericTypeNode::class:
-                return $this->createFromGeneric($type, $context);
-
-            case IdentifierTypeNode::class:
-                return $this->resolver->resolve($type->name, $context);
-
-            case IntersectionTypeNode::class:
-                return new Intersection(
-                    array_filter(
-                        array_map(
-                            fn (TypeNode $nestedType) => $this->createType($nestedType, $context),
-                            $type->types
-                        )
-                    )
-                );
-
-            case NullableTypeNode::class:
-                $nestedType = $this->createType($type->type, $context);
-                if ($nestedType === null) {
-                    return null;
-                }
-
-                return new Nullable($nestedType);
-
-            case UnionTypeNode::class:
-                return new Compound(
-                    array_filter(
-                        array_map(
-                            fn (TypeNode $nestedType) => $this->createType($nestedType, $context),
-                            $type->types
-                        )
-                    )
-                );
-
-            case ThisTypeNode::class:
-                return new This();
-
-            case ConditionalTypeNode::class:
-            case ConditionalTypeForParameterNode::class:
-            case OffsetAccessTypeNode::class:
-            default:
-                return null;
-        }
-    }
-
-    private function createFromGeneric(GenericTypeNode $type, ?Context $context): Type
-    {
-        switch (strtolower($type->type->name)) {
-            case 'array':
-                return new Array_(
-                    ...array_reverse(
-                        array_map(
-                            fn (TypeNode $genericType) => $this->createType($genericType, $context),
-                            $type->genericTypes
-                        )
-                    )
-                );
-
-            case 'class-string':
-                return new ClassString(
-                    $this->fqsenResolver->resolve((string) $type->genericTypes[0], $context)
-                );
-
-            case 'interface-string':
-                return new InterfaceString(
-                    $this->fqsenResolver->resolve((string) $type->genericTypes[0], $context)
-                );
-
-            case 'list':
-                return new List_(
-                    $this->createType($type->genericTypes[0], $context)
-                );
-
-            case 'int':
-                return new IntegerRange(
-                    (string) $type->genericTypes[0],
-                    (string) ($type->genericTypes[1] ?? ''),
-                );
-
-            default:
-                return new Collection(
-                    $this->createType($type->type, $context)->getFqsen(),
-                    ...array_reverse(
-                        array_map(
-                            fn (TypeNode $genericType) => $this->createType($genericType, $context),
-                            $type->genericTypes
-                        )
-                    )
-                );
-        }
-    }
-
-    private function createFromCallable(CallableTypeNode $type, ?Context $context): Callable_
-    {
-        return new Callable_(
-            array_map(
-                function (CallableTypeParameterNode $param) use ($context) {
-                    return new CallableParameter(
-                        $param->parameterName !== '' ? trim($param->parameterName, '$') : null,
-                        $this->createType($param->type, $context),
-                        $param->isReference,
-                        $param->isVariadic,
-                        $param->isOptional
-                    );
-                },
-                $type->parameters
-            ),
-            $this->createType($type->returnType, $context),
-        );
-    }
-
-    private function createFromConst(ConstTypeNode $type, ?Context $context): ?Type
-    {
-        switch (get_class($type->constExpr)) {
-            case ConstExprIntegerNode::class:
-                return new IntegerValue((int) $type->constExpr->value);
-
-            case ConstExprFloatNode::class:
-                return new FloatValue((float) $type->constExpr->value);
-
-            case ConstExprStringNode::class:
-                return new StringValue($type->constExpr->value);
-
-            case ConstFetchNode::class:
-                return new ConstExpression(
-                    $this->fqsenResolver->resolve($type->constExpr->className, $context),
-                    $type->constExpr->name
-                );
-        }
-    }
-}

src/DocBlock/Tags/Factory/VarFactory.php

@@ -7,6 +7,7 @@ namespace phpDocumentor\Reflection\DocBlock\Tags\Factory;
 use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
 use phpDocumentor\Reflection\DocBlock\Tag;
 use phpDocumentor\Reflection\DocBlock\Tags\Var_;
+use phpDocumentor\Reflection\TypeResolver;
 use phpDocumentor\Reflection\Types\Context;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode;
@@ -19,28 +20,28 @@ use function trim;
  */
 final class VarFactory implements PHPStanFactory
 {
-    private TypeFactory $typeFactory;
     private DescriptionFactory $descriptionFactory;
+    private TypeResolver $typeResolver;
 
-    public function __construct(TypeFactory $typeFactory, DescriptionFactory $descriptionFactory)
+    public function __construct(TypeResolver $typeResolver, DescriptionFactory $descriptionFactory)
     {
-        $this->typeFactory = $typeFactory;
         $this->descriptionFactory = $descriptionFactory;
+        $this->typeResolver = $typeResolver;
     }
 
-    public function create(PhpDocTagNode $node, ?Context $context): Tag
+    public function create(PhpDocTagNode $node, Context $context): Tag
     {
         $tagValue = $node->value;
         Assert::isInstanceOf($tagValue, VarTagValueNode::class);
 
         return new Var_(
             trim($tagValue->variableName, '$'),
-            $this->typeFactory->createType($tagValue->type, $context),
+            $this->typeResolver->createType($tagValue->type, $context),
             $this->descriptionFactory->create($tagValue->description, $context)
         );
     }
 
-    public function supports(PhpDocTagNode $node, ?Context $context): bool
+    public function supports(PhpDocTagNode $node, Context $context): bool
     {
         return $node->value instanceof VarTagValueNode;
     }

src/DocBlockFactory.php

@@ -70,15 +70,14 @@ final class DocBlockFactory implements DocBlockFactoryInterface
         $tagFactory = new StandardTagFactory($fqsenResolver);
         $descriptionFactory = new DescriptionFactory($tagFactory);
         $typeResolver = new TypeResolver($fqsenResolver);
-        $typeFactory = new TypeFactory($typeResolver, $fqsenResolver);
 
         $phpstanTagFactory = new AbstractPHPStanFactory(
-            new ParamFactory($typeFactory, $descriptionFactory),
-            new VarFactory($typeFactory, $descriptionFactory),
-            new ReturnFactory($typeFactory, $descriptionFactory),
-            new PropertyFactory($typeFactory, $descriptionFactory),
-            new PropertyReadFactory($typeFactory, $descriptionFactory),
-            new PropertyWriteFactory($typeFactory, $descriptionFactory),
+            new ParamFactory($typeResolver, $descriptionFactory),
+            new VarFactory($typeResolver, $descriptionFactory),
+            new ReturnFactory($typeResolver, $descriptionFactory),
+            new PropertyFactory($typeResolver, $descriptionFactory),
+            new PropertyReadFactory($typeResolver, $descriptionFactory),
+            new PropertyWriteFactory($typeResolver, $descriptionFactory),
         );
 
         $tagFactory->addService($descriptionFactory);

src/PseudoTypes/ArrayShape.php

@@ -1,34 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\PseudoType;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Array_;
-use phpDocumentor\Reflection\Types\ArrayKey;
-use phpDocumentor\Reflection\Types\Mixed_;
-
-use function implode;
-
-class ArrayShape implements PseudoType
-{
-    /** @var ArrayShapeItem[] */
-    private array $items;
-
-    public function __construct(ArrayShapeItem ...$items)
-    {
-        $this->items = $items;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Array_(new Mixed_(), new ArrayKey());
-    }
-
-    public function __toString(): string
-    {
-        return 'array{' . implode(', ', $this->items) . '}';
-    }
-}

src/PseudoTypes/ArrayShapeItem.php

@@ -1,53 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Mixed_;
-
-use function sprintf;
-
-final class ArrayShapeItem
-{
-    private ?string $key;
-    private Type $value;
-    private bool $optional;
-
-    public function __construct(?string $key, ?Type $value, bool $optional)
-    {
-        $this->key = $key;
-        $this->value = $value ?? new Mixed_();
-        $this->optional = $optional;
-    }
-
-    public function getKey(): ?string
-    {
-        return $this->key;
-    }
-
-    public function getValue(): Type
-    {
-        return $this->value;
-    }
-
-    public function isOptional(): bool
-    {
-        return $this->optional;
-    }
-
-    public function __toString(): string
-    {
-        if ($this->key !== null) {
-            return sprintf(
-                '%s%s: %s',
-                $this->key,
-                $this->optional ? '?' : '',
-                $this->value
-            );
-        }
-
-        return (string) $this->value;
-    }
-}

src/PseudoTypes/ConstExpression.php

@@ -1,44 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\Fqsen;
-use phpDocumentor\Reflection\PseudoType;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Mixed_;
-
-use function sprintf;
-
-final class ConstExpression implements PseudoType
-{
-    private Fqsen $owner;
-    private string $expression;
-
-    public function __construct(Fqsen $owner, string $expression)
-    {
-        $this->owner = $owner;
-        $this->expression = $expression;
-    }
-
-    public function getOwner(): Fqsen
-    {
-        return $this->owner;
-    }
-
-    public function getExpression(): string
-    {
-        return $this->expression;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Mixed_();
-    }
-
-    public function __toString(): string
-    {
-        return sprintf('%s::%s', $this->owner, $this->expression);
-    }
-}

src/PseudoTypes/FloatValue.php

@@ -1,34 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\PseudoType;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Float_;
-
-class FloatValue implements PseudoType
-{
-    private float $value;
-
-    public function __construct(float $value)
-    {
-        $this->value = $value;
-    }
-
-    public function getValue(): float
-    {
-        return $this->value;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Float_();
-    }
-
-    public function __toString(): string
-    {
-        return (string) $this->value;
-    }
-}

src/PseudoTypes/IntegerValue.php

@@ -1,34 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\PseudoType;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Integer;
-
-final class IntegerValue implements PseudoType
-{
-    private int $value;
-
-    public function __construct(int $value)
-    {
-        $this->value = $value;
-    }
-
-    public function getValue(): int
-    {
-        return $this->value;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Integer();
-    }
-
-    public function __toString(): string
-    {
-        return (string) $this->value;
-    }
-}

src/PseudoTypes/StringValue.php

@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace phpDocumentor\Reflection\PseudoTypes;
-
-use phpDocumentor\Reflection\PseudoType;
-use phpDocumentor\Reflection\Type;
-use phpDocumentor\Reflection\Types\Float_;
-
-use function sprintf;
-
-class StringValue implements PseudoType
-{
-    private string $value;
-
-    public function __construct(string $value)
-    {
-        $this->value = $value;
-    }
-
-    public function getValue(): string
-    {
-        return $this->value;
-    }
-
-    public function underlyingType(): Type
-    {
-        return new Float_();
-    }
-
-    public function __toString(): string
-    {
-        return sprintf('"%s"', $this->value);
-    }
-}