[Php71] Skip AssignArrayToStringRector on a variable re-assigned as string

PHPStan 2.2.8 infers a possibly undefined variable as ErrorType, where it used to be a union of its possible types. AssignArrayToStringRector leaned on that union to skip:

    if (empty($where)) {
        $where = '';
    } else {
        $where = 'WHERE ' . implode(' AND ', $where);
    }

With ErrorType, neither the isArray() nor the UnionType guard matches, and the empty string turned into an array, breaking the concat that follows.

The variable being filled as a string later on is what makes it a string here, so that is now checked directly. An empty string assign does not count, as it is a candidate for the very same re-type.

Author: TomasVotruba

rules/Php71/Rector/Assign/AssignArrayToStringRector.php

@@ -237,6 +237,61 @@ private function isReAssignedAsArray(Assign $assign, string $variableName, Varia
         return false;
     }
 
+    /**
+     * The variable is filled as a string later on, so it has to stay a string here as well
+     */
+    private function isReAssignedAsString(
+        Variable $variable,
+        Namespace_|FileNode|ClassMethod|Function_|Closure $node
+    ): bool {
+        if ($node->stmts === null) {
+            return false;
+        }
+
+        $variableName = $this->getName($variable);
+        if ($variableName === null) {
+            return false;
+        }
+
+        $isReAssignedAsString = false;
+
+        $this->traverseNodesWithCallable($node->stmts, function (Node $node) use (
+            $variable,
+            $variableName,
+            &$isReAssignedAsString
+        ): ?int {
+            if (! $node instanceof Assign) {
+                return null;
+            }
+
+            if (! $node->var instanceof Variable) {
+                return null;
+            }
+
+            if (! $this->isName($node->var, $variableName)) {
+                return null;
+            }
+
+            if ($node->var->getStartTokenPos() <= $variable->getStartTokenPos()) {
+                return null;
+            }
+
+            // an empty string assign is a candidate for the very same re-type, so it is no proof of a string
+            if ($this->isEmptyString($node->expr)) {
+                return null;
+            }
+
+            if (! $this->nodeTypeResolver->getNativeType($node->expr)->isString()->yes()) {
+                return null;
+            }
+
+            $isReAssignedAsString = true;
+            return NodeVisitor::STOP_TRAVERSAL;
+        });
+
+        return $isReAssignedAsString;
+    }
+
     private function refactorAssign(
         Assign $assign,
         Namespace_|FileNode|ClassMethod|Function_|Closure $node
@@ -258,6 +313,10 @@ private function refactorAssign(
             return null;
         }
 
+        if ($this->isReAssignedAsString($assign->var, $node)) {
+            return null;
+        }
+
         $variableAssignArrayDimFetches = $this->findSameNamedVariableAssigns($assign->var, $node);
 
         $shouldRetype = false;