Use Collector in combination with DynamicMethodThrowTypeExtension

[amenophis]

Hi,
I'm trying to write a DynamicMethodThrowTypeExtension to enhance exceptions system from a Command / Query bus.

I wrote a Collector that search for all classes that are handler, and collect the tuple<Command, Handler>.
The question is: How to use the Collector in the BusDynamicMethodThrowTypeExtension ?

I shared the code below.

Thanks in advance

<?php

declare(strict_types=1);

namespace Tests\PHPStan\Extensions\Messenger\Bus;

use PhpParser\Node\Expr\MethodCall;
use PHPStan\Analyser\Scope;
use PHPStan\Reflection\MethodReflection;
use PHPStan\Type\DynamicMethodThrowTypeExtension;
use PHPStan\Type\Type;
use PHPStan\Type\TypeCombinator;

class BusDynamicMethodThrowTypeExtension implements DynamicMethodThrowTypeExtension
{
    /**
     * @param string[] $dispatchers
     */
    public function __construct(
        private readonly array $dispatchers,
    ) {
    }

    public function isMethodSupported(MethodReflection $methodReflection): bool
    {
        return [] !== array_filter($this->dispatchers, function (string $dispatcher) use ($methodReflection) {
            $dispatcher = explode('::', $dispatcher);

            return $dispatcher[1] === $methodReflection->getName()
                && is_a($methodReflection->getDeclaringClass()->getName(), $dispatcher[0], true);
        });
    }

    public function getThrowTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
    {
        $throwTypes = [];
        if ($methodReflection->getThrowType()) {
            $throwTypes[] = $methodReflection->getThrowType();
        }

        // How to use the Collector here ?

        return TypeCombinator::union(...$throwTypes);
    }
}

<?php

declare(strict_types=1);

namespace Tests\PHPStan\Extensions\Messenger\Bus;

use PhpParser\Node;
use PHPStan\Analyser\Scope;
use PHPStan\Collectors\Collector;
use PHPStan\Node\InClassNode;
use ReflectionClass;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

/**
 * @implements Collector<InClassNode, array{string, string}>
 */
class HandlerCollector implements Collector
{
    /**
     * @param string[] $collectableCommandImplements
     */
    public function __construct(
        private readonly array $collectableCommandImplements,
    ) {
    }

    public function getNodeType(): string
    {
        return InClassNode::class;
    }

    /**
     * @param InClassNode $node
     *
     * @return array{string, string}|null
     */
    public function processNode(Node $node, Scope $scope): ?array
    {
        $attributes = $node->getClassReflection()->getNativeReflection()->getAttributes(AsMessageHandler::class);
        if (!$attribute = $attributes[0] ?? null) {
            return null;
        }

        /** @var AsMessageHandler $attributeInstance */
        $attributeInstance = $attribute->newInstance();

        $method = $attributeInstance->method ?? '__invoke';
        if (!$methodNode = $node->getOriginalNode()->getMethod($method)) {
            return null;
        }

        $params = array_filter(
            $methodNode->getParams(),
            function ($param) {
                if (null === $param->type) {
                    return false;
                }

                if (!$param->type instanceof Node\Name\FullyQualified) {
                    return false;
                }

                $reflectionClass = new ReflectionClass($param->type->toString()); // @phpstan-ignore-line

                foreach ($this->collectableCommandImplements as $collectableHandlerImplement) {
                    if ($reflectionClass->implementsInterface($collectableHandlerImplement)) {
                        return true;
                    }
                }

                return false;
            });

        if ([] === $params) {
            return null;
        }
        /** @var Node\Name\FullyQualified $paramType */
        $paramType = $params[0]->type;

        $inputClass = $paramType->toString();
        $handlerClass = $node->getOriginalNode()->namespacedName?->toString();

        if (!$inputClass || !$handlerClass) {
            return null;
        }

        return [
            $inputClass,
            $handlerClass,
        ];
    }
}

[ondrejmirtes]

Hello, code analysis (type inference, finding out information about code) and rules that act on these data are strictly separated. PHPStan does only a single pass through the analysis. DynamicMethodThrowTypeExtension influences type inference, but collectors and rules are only for acting on that data.

There's no way for collectors to influence the type inference, it'd require inverted dependency direction, and multiple passes of the analyser.

If you show me the actual analysed code, and describe the problem you're trying to solve, I might help you another way.

[amenophis]

@ondrejmirtes Thanks for all infos, very appreciated 👍

@canvural Do you have a public example ?

Thanks 🙏

[canvural]

@amenophis It's the normal stub files feature of PHPStan: https://phpstan.org/user-guide/stub-files But you can use traits also in stubs, not just classes. So you can override Symfony\Component\Messenger\HandleTrait::handle() return type there to suit your needs.

[amenophis]

I tried with the following stub, it changed nothing

<?php

namespace Symfony\Component\Messenger;

trait HandleTrait
{
    /**
     * @template TResult
     * @template THandler
     * @template TCommand<TResult, THandler>

     * @param TCommand $message
     * @return TResult
     */
    private function handle(object $message): mixed;
}

Do you have an idea of what I miss ?

Thanks 🙏

[amenophis]

I finally succeed using this stub

<?php

namespace Symfony\Component\Messenger;

use Shared\Application\Command\Command;
use Shared\Application\Query\Query;

trait HandleTrait
{
    /**
     * @template TResult of object
     * @template THandler
     * @template T of Command<TResult, THandler>|Query<TResult, THandler>
     *
     * @param T $message
     * @return TResult
     */
    private function handle(object $message): mixed;
}

Thanks @ondrejmirtes and @canvural for your help 🙏

[amenophis]

Just a little precision, it seems that PHPstan stub didn't work with aliased imported trait method.

In my bus implementation, i have this

    use HandleTrait {
        handle as private messengerHandle;
    }

In the stub, I have to declare method messengerHandle (instead of handle) to make it work