Detect doctrine query type widening in direct returns

DoctrineTypeWideningRule.php

<?php declare(strict_types = 1);

namespace ShipMonk\Rules\PHPStan\Rule;

use Doctrine\ORM\Query;
use PhpParser\Node;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Stmt\Return_;
use PHPStan\Analyser\Scope;
use PHPStan\Node\MethodReturnStatementsNode;
use PHPStan\Reflection\ParametersAcceptorSelector;
use PHPStan\Rules\IdentifierRuleError;
use PHPStan\Rules\Rule;
use PHPStan\Rules\RuleErrorBuilder;
use PHPStan\Type\MixedType;
use PHPStan\Type\VerbosityLevel;

/**
 * @implements Rule<MethodReturnStatementsNode>
 */
class DoctrineTypeWideningRule implements Rule
{

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

    /**
     * @param MethodReturnStatementsNode $node
     *
     * @return list<IdentifierRuleError>
     */
    public function processNode(
        Node $node,
        Scope $scope,
    ): array
    {
        $methodReflection = $node->getMethodReflection();
        $returnType = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();

        foreach ($node->getReturnStatements() as $returnStatement) {
            $scope = $returnStatement->getScope();
            $returnNode = $returnStatement->getReturnNode();

            if ($returnNode->expr === null) {
                continue;
            }

            $realReturnedType = $scope->getType($returnNode->expr);
            
            if ($realReturnedType instanceof MixedType) {
                continue;
            }

            if (!$this->isQueryReturn($returnNode, $scope)) {
                continue;
            }

            if ($returnType->isSuperTypeOf($realReturnedType)->yes()) {
                $error = "Method {$methodReflection->getName()} returns {$realReturnedType->describe(VerbosityLevel::precise())}, but is annotated as {$returnType->describe(VerbosityLevel::precise())}";
                return [
                    RuleErrorBuilder::message($error)
                        ->line($returnNode->getLine())
                        ->identifier('shipmonk.doctrineTypeWidening')
                        ->build(),
                ];
            }
        }

        return [];
    }

    private function isQueryReturn(Return_ $returnNode, Scope $scope): bool
    {
        return $returnNode->expr instanceof MethodCall
            && $scope->getType($returnNode->expr->var)->getObjectClassNames() === [Query::class];
    }

}