<form method="POST">
    <h3>Editing: ReflectionMapper.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of sebastian/type.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\Type;

use function assert;
use ReflectionFunctionAbstract;
use ReflectionIntersectionType;
use ReflectionMethod;
use ReflectionNamedType;
use ReflectionType;
use ReflectionUnionType;

final class ReflectionMapper
{
    /**
     * @psalm-return list&lt;Parameter&gt;
     */
    public function fromParameterTypes(ReflectionFunctionAbstract $functionOrMethod): array
    {
        $parameters = [];

        foreach ($functionOrMethod-&gt;getParameters() as $parameter) {
            $name = $parameter-&gt;getName();

            assert($name !== '');

            if (!$parameter-&gt;hasType()) {
                $parameters[] = new Parameter($name, new UnknownType);

                continue;
            }

            $type = $parameter-&gt;getType();

            if ($type instanceof ReflectionNamedType) {
                $parameters[] = new Parameter(
                    $name,
                    $this-&gt;mapNamedType($type, $functionOrMethod)
                );

                continue;
            }

            if ($type instanceof ReflectionUnionType) {
                $parameters[] = new Parameter(
                    $name,
                    $this-&gt;mapUnionType($type, $functionOrMethod)
                );

                continue;
            }

            if ($type instanceof ReflectionIntersectionType) {
                $parameters[] = new Parameter(
                    $name,
                    $this-&gt;mapIntersectionType($type, $functionOrMethod)
                );
            }
        }

        return $parameters;
    }

    public function fromReturnType(ReflectionFunctionAbstract $functionOrMethod): Type
    {
        if (!$this-&gt;hasReturnType($functionOrMethod)) {
            return new UnknownType;
        }

        $returnType = $this-&gt;returnType($functionOrMethod);

        assert($returnType instanceof ReflectionNamedType || $returnType instanceof ReflectionUnionType || $returnType instanceof ReflectionIntersectionType);

        if ($returnType instanceof ReflectionNamedType) {
            return $this-&gt;mapNamedType($returnType, $functionOrMethod);
        }

        if ($returnType instanceof ReflectionUnionType) {
            return $this-&gt;mapUnionType($returnType, $functionOrMethod);
        }

        if ($returnType instanceof ReflectionIntersectionType) {
            return $this-&gt;mapIntersectionType($returnType, $functionOrMethod);
        }
    }

    private function mapNamedType(ReflectionNamedType $type, ReflectionFunctionAbstract $functionOrMethod): Type
    {
        if ($functionOrMethod instanceof ReflectionMethod &amp;&amp; $type-&gt;getName() === 'self') {
            return ObjectType::fromName(
                $functionOrMethod-&gt;getDeclaringClass()-&gt;getName(),
                $type-&gt;allowsNull()
            );
        }

        if ($functionOrMethod instanceof ReflectionMethod &amp;&amp; $type-&gt;getName() === 'static') {
            return new StaticType(
                TypeName::fromReflection($functionOrMethod-&gt;getDeclaringClass()),
                $type-&gt;allowsNull()
            );
        }

        if ($type-&gt;getName() === 'mixed') {
            return new MixedType;
        }

        if ($functionOrMethod instanceof ReflectionMethod &amp;&amp; $type-&gt;getName() === 'parent') {
            return ObjectType::fromName(
                $functionOrMethod-&gt;getDeclaringClass()-&gt;getParentClass()-&gt;getName(),
                $type-&gt;allowsNull()
            );
        }

        return Type::fromName(
            $type-&gt;getName(),
            $type-&gt;allowsNull()
        );
    }

    private function mapUnionType(ReflectionUnionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
    {
        $types = [];

        foreach ($type-&gt;getTypes() as $_type) {
            assert($_type instanceof ReflectionNamedType || $_type instanceof ReflectionIntersectionType);

            if ($_type instanceof ReflectionNamedType) {
                $types[] = $this-&gt;mapNamedType($_type, $functionOrMethod);

                continue;
            }

            $types[] = $this-&gt;mapIntersectionType($_type, $functionOrMethod);
        }

        return new UnionType(...$types);
    }

    private function mapIntersectionType(ReflectionIntersectionType $type, ReflectionFunctionAbstract $functionOrMethod): Type
    {
        $types = [];

        foreach ($type-&gt;getTypes() as $_type) {
            assert($_type instanceof ReflectionNamedType);

            $types[] = $this-&gt;mapNamedType($_type, $functionOrMethod);
        }

        return new IntersectionType(...$types);
    }

    private function hasReturnType(ReflectionFunctionAbstract $functionOrMethod): bool
    {
        if ($functionOrMethod-&gt;hasReturnType()) {
            return true;
        }

        if (!method_exists($functionOrMethod, 'hasTentativeReturnType')) {
            return false;
        }

        return $functionOrMethod-&gt;hasTentativeReturnType();
    }

    private function returnType(ReflectionFunctionAbstract $functionOrMethod): ?ReflectionType
    {
        if ($functionOrMethod-&gt;hasReturnType()) {
            return $functionOrMethod-&gt;getReturnType();
        }

        if (!method_exists($functionOrMethod, 'getTentativeReturnType')) {
            return null;
        }

        return $functionOrMethod-&gt;getTentativeReturnType();
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>