AssertIssetToSpecificMethodRector.php

<?php

declare(strict_types=1);

namespace Rector\PHPUnit\CodeQuality\Rector\MethodCall;

use PhpParser\Node;
use PhpParser\Node\Expr\ArrayDimFetch;
use PhpParser\Node\Expr\Isset_;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PHPStan\Type\ObjectType;
use Rector\PHPUnit\Enum\AssertMethod;
use Rector\PHPUnit\NodeAnalyzer\IdentifierManipulator;
use Rector\PHPUnit\NodeAnalyzer\TestsNodeAnalyzer;
use Rector\Rector\AbstractRector;
use Rector\RuleDoc\CodeSample\CodeSample;
use Rector\RuleDoc\RuleDefinition;

/**
 * @see \Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertIssetToSpecificMethodRector\AssertIssetToSpecificMethodRectorTest
 */
final class AssertIssetToSpecificMethodRector extends AbstractRector
{
    /**
     * @var string[]
     */
    private const array SUPER_GLOBAL_VARIABLE_NAMES = [
        'GLOBALS',
        '_SERVER',
        '_GET',
        '_POST',
        '_FILES',
        '_COOKIE',
        '_SESSION',
        '_REQUEST',
        '_ENV',
    ];

    public function __construct(
        private readonly IdentifierManipulator $identifierManipulator,
        private readonly TestsNodeAnalyzer $testsNodeAnalyzer,
    ) {
    }

    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Turns assertTrue() + isset() comparisons to more precise assertArrayHasKey() method',
            [
                new CodeSample(
                    '$this->assertTrue(isset($anything["foo"]), "message");',
                    '$this->assertArrayHasKey("foo", $anything, "message");'
                ),
            ]
        );
    }

    /**
     * @return array<class-string<Node>>
     */
    public function getNodeTypes(): array
    {
        return [MethodCall::class, StaticCall::class];
    }

    /**
     * @param MethodCall|StaticCall $node
     */
    public function refactor(Node $node): ?Node
    {
        if (! $this->testsNodeAnalyzer->isPHPUnitMethodCallNames(
            $node,
            [AssertMethod::ASSERT_TRUE, AssertMethod::ASSERT_FALSE]
        )) {
            return null;
        }

        if ($node->isFirstClassCallable()) {
            return null;
        }

        $firstArg = $node->getArgs()[0];
        $firstArgumentValue = $firstArg->value;

        // is property access
        if (! $firstArgumentValue instanceof Isset_) {
            return null;
        }

        $issetExpr = $firstArgumentValue->vars[0];
        if (! $issetExpr instanceof ArrayDimFetch) {
            return null;
        }

        // Keep the non-evaluating behavior of isset() for global state. A superglobal
        // may be unavailable or unset, while passing it directly evaluates the variable.
        if ($this->isNames($issetExpr->var, self::SUPER_GLOBAL_VARIABLE_NAMES)) {
            return null;
        }

        // isset() on an ArrayAccess object is not equivalent to assertArrayHasKey():
        // the key may be any type (assertArrayHasKey() requires int|string) and offsetExists()
        // semantics can differ from array_key_exists()
        if ($this->isObjectType($issetExpr->var, new ObjectType('ArrayAccess'))) {
            return null;
        }

        return $this->refactorArrayDimFetchNode($node, $issetExpr);
    }

    /**
     * @template TNode of MethodCall|StaticCall
     * @param TNode $node
     * @return TNode
     */
    private function refactorArrayDimFetchNode(MethodCall|StaticCall $node, ArrayDimFetch $arrayDimFetch): MethodCall|StaticCall
    {
        $this->identifierManipulator->renameNodeWithMap($node, [
            AssertMethod::ASSERT_TRUE => 'assertArrayHasKey',
            AssertMethod::ASSERT_FALSE => 'assertArrayNotHasKey',
        ]);

        $oldArgs = $node->getArgs();
        unset($oldArgs[0]);

        $node->args = [...$this->nodeFactory->createArgs([$arrayDimFetch->dim, $arrayDimFetch->var]), ...$oldArgs];
        return $node;
    }
}