Solution for PHPStan issue #12328: `Unable to inline-ignore errors from most collector-based rules`

FixUnmatchedIgnoresFormatter.php

<?php declare(strict_types = 1);

namespace ShipMonk\Rules\PHPStan\Formatter;

use PHPStan\Analyser\Error;
use PHPStan\Command\AnalysisResult;
use PHPStan\Command\ErrorFormatter\ErrorFormatter;
use PHPStan\Command\ErrorFormatter\TableErrorFormatter;
use PHPStan\Command\Output;
use ShipMonk\PHPStan\DeadCode\Rule\DeadCodeRule;
use function str_contains;
use function str_ends_with;

/**
 * This formatter solves following issue: https://github.com/phpstan/phpstan/issues/12328
 */
final class FixUnmatchedIgnoresFormatter implements ErrorFormatter
{

    /**
     * Any rule that emits no error for files-only analysis should be present
     *
     * Typically, such rule has a condition like this:
     *
     * if ($node->isOnlyFilesAnalysis()) {
     *     return [];
     * }
     */
    private const array COLLECTOR_BASED_ERROR_IDENTIFIERS = [
        'shipmonk.deadMethod',
        'shipmonk.deadConstant',
        'trait.unused',
    ];

    public function __construct(
        private TableErrorFormatter $tableErrorFormatter,
    )
    {
    }

    public function formatErrors(
        AnalysisResult $analysisResult,
        Output $output,
    ): int
    {
        if (!$this->isPartialAnalysis()) {
            return $this->tableErrorFormatter->formatErrors($analysisResult, $output);
        }

        $modifiedAnalysisResult = new AnalysisResult( // @phpstan-ignore phpstanApi.constructor
            $this->filterErrors($analysisResult->getFileSpecificErrors()),
            $analysisResult->getNotFileSpecificErrors(),
            $analysisResult->getInternalErrorObjects(),
            $analysisResult->getWarnings(),
            $analysisResult->getCollectedData(),
            $analysisResult->isDefaultLevelUsed(),
            $analysisResult->getProjectConfigFile(),
            $analysisResult->isResultCacheSaved(),
            $analysisResult->getPeakMemoryUsageBytes(),
            $analysisResult->isResultCacheUsed(),
            $analysisResult->getChangedProjectExtensionFilesOutsideOfAnalysedPaths(),
        );

        return $this->tableErrorFormatter->formatErrors($modifiedAnalysisResult, $output);
    }

    /**
     * @param list<Error> $errors
     * @return list<Error>
     */
    private function filterErrors(array $errors): array
    {
        $result = [];
        foreach ($errors as $error) {
            if (
                $error->getIdentifier() === 'ignore.unmatchedIdentifier'
                && $this->isCollectorBasedError($error->getMessage())
            ) {
                continue;
            }

            $result[] = $error;
        }

        return $result;
    }

    private function isCollectorBasedError(string $message): bool
    {
        foreach (self::COLLECTOR_BASED_ERROR_IDENTIFIERS as $identifier) {
            if (str_contains($message, $identifier)) {
                return true;
            }
        }
        return false;
    }

    private function isPartialAnalysis(): bool
    {
        foreach ($_SERVER['argv'] as $arg) {
            if (str_ends_with($arg, '.php')) {
                return true;
            }
        }

        return false;
    }

}