NullToStrictStringIntConverter.php

<?php

declare(strict_types=1);

namespace Rector\Php81\NodeManipulator;

use PhpParser\Node\Arg;
use PhpParser\Node\Expr;
use PhpParser\Node\Expr\Cast\Int_ as CastInt_;
use PhpParser\Node\Expr\Cast\String_ as CastString_;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\Ternary;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Scalar\Int_;
use PhpParser\Node\Scalar\InterpolatedString;
use PhpParser\Node\Scalar\String_;
use PHPStan\Analyser\Fiber\FiberScope;
use PHPStan\Analyser\Scope;
use PHPStan\Reflection\Native\ExtendedNativeParameterReflection;
use PHPStan\Reflection\ParametersAcceptor;
use PHPStan\Type\ErrorType;
use PHPStan\Type\MixedType;
use PHPStan\Type\NullType;
use PHPStan\Type\Type;
use PHPStan\Type\UnionType;
use Rector\NodeAnalyzer\PropertyFetchAnalyzer;
use Rector\NodeTypeResolver\Node\AttributeKey;
use Rector\NodeTypeResolver\NodeTypeResolver;
use Rector\PhpParser\Node\Value\ValueResolver;

final readonly class NullToStrictStringIntConverter
{
    public function __construct(
        private ValueResolver $valueResolver,
        private NodeTypeResolver $nodeTypeResolver,
        private PropertyFetchAnalyzer $propertyFetchAnalyzer,
    ) {
    }

    /**
     * @param Arg[] $args
     */
    public function convertIfNull(
        FuncCall $funcCall,
        array $args,
        int $position,
        bool $isTrait,
        Scope $scope,
        ParametersAcceptor $parametersAcceptor,
        string $targetType = 'string'
    ): ?FuncCall {
        if (! isset($args[$position])) {
            return null;
        }

        $argValue = $args[$position]->value;

        if ($this->valueResolver->isNull($argValue)) {
            $args[$position]->value = $targetType === 'string' ? new String_('') : new Int_(0);
            $funcCall->args = $args;
            return $funcCall;
        }

        // skip (string) ternary conditions with both values
        if ($this->isStringCastedTernaryOfMixedTypes($argValue, $scope)) {
            return null;
        }

        if ($this->shouldSkipValue($argValue, $scope, $isTrait, $targetType)) {
            return null;
        }

        $parameterReflection = $parametersAcceptor->getParameters()[$position] ?? null;
        if ($parameterReflection instanceof ExtendedNativeParameterReflection && $parameterReflection->getType() instanceof UnionType) {
            $parameterType = $parameterReflection->getType();
            if (! $this->isValidUnionType($parameterType)) {
                return null;
            }
        }

        if ($argValue instanceof Ternary && ! $this->shouldSkipValue($argValue->else, $scope, $isTrait, $targetType)) {

            if ($this->valueResolver->isNull($argValue->else)) {
                $argValue->else = $targetType === 'string' ? new String_('') : new Int_(0);
            } else {
                $argValue->else = $targetType === 'string' ? new CastString_($argValue->else) : new CastInt_(
                    $argValue->else
                );
            }

            $args[$position]->value = $argValue;

            return $funcCall;
        }

        $wrapInParentheses = false;
        if ($argValue instanceof Ternary && $argValue->cond instanceof CastString_) {
            $wrapInParentheses = true;
        }

        if ($targetType === 'string') {
            $castedType = new CastString_($argValue);
        } else {
            $castedType = new CastInt_($argValue);
        }

        if ($wrapInParentheses) {
            $argValue->setAttribute(AttributeKey::WRAPPED_IN_PARENTHESES, true);
        }

        $args[$position]->value = $castedType;

        return $funcCall;
    }

    private function shouldSkipValue(Expr $expr, Scope $scope, bool $isTrait, string $targetType): bool
    {
        $type = $this->nodeTypeResolver->getType($expr);
        if ($type->isString()->yes() && $targetType === 'string') {
            return true;
        }

        if ($type->isInteger()->yes() && $targetType === 'int') {
            return true;
        }

        $nativeType = $this->nodeTypeResolver->getNativeType($expr);
        if ($nativeType->isString()->yes() && $targetType === 'string') {
            return true;
        }

        if ($nativeType->isInteger()->yes() && $targetType === 'int') {
            return true;
        }

        if ($this->isPossibleArrayVariableName($type, $nativeType, $expr)) {
            return true;
        }

        if ($this->shouldSkipType($type)) {
            return true;
        }

        if ($expr instanceof InterpolatedString) {
            return true;
        }

        if ($this->isAnErrorType($expr, $nativeType, $scope)) {
            return true;
        }

        return $this->shouldSkipTrait($expr, $type, $isTrait);
    }

    private function isValidUnionType(Type $type): bool
    {
        if (! $type instanceof UnionType) {
            return false;
        }

        foreach ($type->getTypes() as $childType) {
            if ($childType->isString()->yes()) {
                continue;
            }

            if ($childType->isInteger()->yes()) {
                continue;
            }

            if ($childType->isNull()->yes()) {
                continue;
            }

            return false;
        }

        return true;
    }

    private function shouldSkipType(Type $type): bool
    {
        return ! $type instanceof MixedType
            && ! $type->isNull()
                ->yes()
            && ! $this->isValidUnionType($type);
    }

    private function shouldSkipTrait(Expr $expr, Type $type, bool $isTrait): bool
    {
        if (! $type instanceof MixedType) {
            return false;
        }

        if (! $isTrait) {
            return false;
        }

        if ($type->isExplicitMixed()) {
            return false;
        }

        if (! $expr instanceof MethodCall) {
            return $this->propertyFetchAnalyzer->isLocalPropertyFetch($expr);
        }

        return true;
    }

    private function isAnErrorType(Expr $expr, Type $type, Scope $scope): bool
    {
        if ($type instanceof ErrorType) {
            return true;
        }

        $parentScope = $scope->getParentScope();
        if ($parentScope instanceof FiberScope) {
            $parentScope = $parentScope->toMutatingScope();
        }

        if ($parentScope instanceof Scope) {
            return $parentScope->getType($expr) instanceof ErrorType;
        }

        return $type instanceof MixedType
            && ! $type->isExplicitMixed()
            && $type->getSubtractedType() instanceof NullType;
    }

    /**
     * @see https://github.com/rectorphp/rector/issues/9447 for context
     */
    private function isPossibleArrayVariableName(Type $passedType, Type $reflectionParamType, Expr $expr): bool
    {
        // could mixed, resp. array, no need to (string) cast array
        if (! $passedType instanceof MixedType) {
            return false;
        }

        if (! $reflectionParamType->isArray()->maybe()) {
            return false;
        }

        if ($expr instanceof Variable && is_string($expr->name)) {
            $variableName = $expr->name;
            // most likely plural variable
            return strlen($variableName) > 3 && str_ends_with($variableName, 's');
        }

        return false;
    }

    private function isStringCastedTernaryOfMixedTypes(Expr $expr, Scope $scope): bool
    {
        if (! $expr instanceof Ternary) {
            return false;
        }

        if (! $expr->cond instanceof CastString_) {
            return false;
        }

        if (! $expr->if instanceof Expr) {
            return false;
        }

        $ifType = $scope->getType($expr->if);
        $elseType = $scope->getType($expr->else);
        return $ifType instanceof MixedType || $elseType instanceof MixedType;
    }
}