Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules\NoEnvironmentHelperInsideCompilerPassRule

Complexity

Total Complexity

9

Size/Duplication

Total Lines	41
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
B	processNode()	0	29	8
A	getNodeType()	0	3	1

<?php declare(strict_types=1);

namespace Shopware\Core\DevOps\StaticAnalyze\PHPStan\Rules;

use PhpParser\Node;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Identifier;
use PhpParser\Node\Name;
use PHPStan\Analyser\Scope;

The type PHPStan\Analyser\Scope was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Rules\Rule;

The type PHPStan\Rules\Rule was not found. Maybe you did not declare it correctly or list all dependencies?

use PHPStan\Rules\RuleError;

The type PHPStan\Rules\RuleError was not found. Maybe you did not declare it correctly or list all dependencies?

use Shopware\Core\DevOps\Environment\EnvironmentHelper;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;

/**
 * @internal
 *
 * @implements Rule<StaticCall>
 */
class NoEnvironmentHelperInsideCompilerPassRule implements Rule
{
    public function getNodeType(): string
    {
        return StaticCall::class;
    }

    /**
     * @param StaticCall $node
     *
     * @return array<array-key, RuleError|string>

The doc comment array<array-key, RuleError|string> at position 2 could not be parsed: Unknown type name 'array-key' at position 2 in array<array-key, RuleError|string>.

     */
    public function processNode(Node $node, Scope $scope): array
    {
        $class = $scope->getClassReflection();

        if ($class === null) {
            return [];
        }

        if (!$class->implementsInterface(CompilerPassInterface::class)) {
            return [];
        }

        if (!$node->name instanceof Identifier) {

Accessing name on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            return [];
        }

        if ((string) $node->name !== 'getVariable' && (string) $node->name !== 'hasVariable') {
            return [];
        }

        if (!$node->class instanceof Name) {

Accessing class on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            return [];
        }

        if ((string) $node->class !== EnvironmentHelper::class) {
            return [];
        }

        return ['Do not use EnvironmentHelper inside compiler passes.'];
    }
}