[Php85] Add ArrayKeyExistsNullToEmptyStringRector

config/set/php85.php

@@ -10,6 +10,7 @@
 use Rector\Php85\Rector\ArrayDimFetch\ArrayFirstLastRector;
 use Rector\Php85\Rector\ClassMethod\NullDebugInfoReturnRector;
 use Rector\Php85\Rector\Const_\DeprecatedAnnotationToDeprecatedAttributeRector;
+use Rector\Php85\Rector\FuncCall\ArrayKeyExistsNullToEmptyStringRector;
 use Rector\Php85\Rector\FuncCall\RemoveFinfoBufferContextArgRector;
 use Rector\Php85\Rector\Switch_\ColonAfterSwitchCaseRector;
 use Rector\Removing\Rector\FuncCall\RemoveFuncCallArgRector;
@@ -32,6 +33,7 @@
             NullDebugInfoReturnRector::class,
             DeprecatedAnnotationToDeprecatedAttributeRector::class,
             ColonAfterSwitchCaseRector::class,
+            ArrayKeyExistsNullToEmptyStringRector::class,
         ]
     );
 

rules-tests/Php85/Rector/FuncCall/ArrayKeyExistsNullToEmptyStringRector/ArrayKeyExistsNullToEmptyStringRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Php85\Rector\FuncCall\ArrayKeyExistsNullToEmptyStringRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class ArrayKeyExistsNullToEmptyStringRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

rules-tests/Php85/Rector/FuncCall/ArrayKeyExistsNullToEmptyStringRector/Fixture/key_null.php.inc

@@ -0,0 +1,11 @@
+<?php
+
+array_key_exists(null, $array);
+
+?>
+-----
+<?php
+
+array_key_exists('', $array);
+
+?>

rules-tests/Php85/Rector/FuncCall/ArrayKeyExistsNullToEmptyStringRector/Fixture/key_null_var.php.inc

@@ -0,0 +1,11 @@
+<?php
+
+array_key_exists($k, $array);
+
+?>
+-----
+<?php
+
+array_key_exists((string) $k, $array);
+
+?>

rules-tests/Php85/Rector/FuncCall/ArrayKeyExistsNullToEmptyStringRector/config/configured_rule.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\Php85\Rector\FuncCall\ArrayKeyExistsNullToEmptyStringRector;
+use Rector\ValueObject\PhpVersion;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(ArrayKeyExistsNullToEmptyStringRector::class);
+
+    $rectorConfig->phpVersion(PhpVersion::PHP_85);
+};

rules/Php81/NodeManipulator/NullToStrictStringConverter.php

@@ -0,0 +1,183 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Php81\NodeManipulator;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr;
+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\Scalar\InterpolatedString;
+use PhpParser\Node\Scalar\String_;
+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\NodeTypeResolver;
+use Rector\PhpParser\Node\Value\ValueResolver;
+
+final readonly class NullToStrictStringConverter
+{
+    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
+    ): ?FuncCall {
+        if (! isset($args[$position])) {
+            return null;
+        }
+
+        $argValue = $args[$position]->value;
+        if ($this->valueResolver->isNull($argValue)) {
+            $args[$position]->value = new String_('');
+            $funcCall->args = $args;
+            return $funcCall;
+        }
+
+        if ($this->shouldSkipValue($argValue, $scope, $isTrait)) {
+            return null;
+        }
+
+        $parameter = $parametersAcceptor->getParameters()[$position] ?? null;
+        if ($parameter instanceof ExtendedNativeParameterReflection && $parameter->getType() instanceof UnionType) {
+            $parameterType = $parameter->getType();
+            if (! $this->isValidUnionType($parameterType)) {
+                return null;
+            }
+        }
+
+        if ($argValue instanceof Ternary && ! $this->shouldSkipValue($argValue->else, $scope, $isTrait)) {
+            if ($this->valueResolver->isNull($argValue->else)) {
+                $argValue->else = new String_('');
+            } else {
+                $argValue->else = new CastString_($argValue->else);
+            }
+
+            $args[$position]->value = $argValue;
+            $funcCall->args = $args;
+            return $funcCall;
+        }
+
+        $args[$position]->value = new CastString_($argValue);
+        $funcCall->args = $args;
+        return $funcCall;
+    }
+
+    private function shouldSkipValue(Expr $expr, Scope $scope, bool $isTrait): bool
+    {
+        $type = $this->nodeTypeResolver->getType($expr);
+        if ($type->isString()->yes()) {
+            return true;
+        }
+
+        $nativeType = $this->nodeTypeResolver->getNativeType($expr);
+        if ($nativeType->isString()->yes()) {
+            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 Scope) {
+            return $parentScope->getType($expr) instanceof ErrorType;
+        }
+
+        return $type instanceof MixedType
+            && ! $type->isExplicitMixed()
+            && $type->getSubtractedType() instanceof NullType;
+    }
+}