Fix phpstan/phpstan#14333: Setting an array key doesn't update a reference

src/Analyser/ExprHandler/AssignHandler.php

@@ -55,6 +55,7 @@
 use PHPStan\Type\ConstantTypeHelper;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\IntegerRangeType;
+use PHPStan\Type\IntegerType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\StaticTypeFactory;
@@ -69,6 +70,7 @@
 use function array_slice;
 use function count;
 use function in_array;
+use function is_int;
 use function is_string;
 
 /**
@@ -315,6 +317,10 @@
 				foreach ($conditionalExpressions as $exprString => $holders) {
 					$scope = $scope->addConditionalExpressions($exprString, $holders);
 				}
+
+				if ($assignedExpr instanceof Expr\Array_) {
+					$scope = $this->processArrayByRefItems($scope, $var->name, $assignedExpr, new Variable($var->name));
+				}
 			} else {
 				$nameExprResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context);
 				$hasYield = $hasYield || $nameExprResult->hasYield();
@@ -936,6 +942,67 @@
 		return $scope->hasVariableType($varNode->name)->negate();
 	}
 
+	private function processArrayByRefItems(MutatingScope $scope, string $rootVarName, Expr\Array_ $arrayExpr, Expr $parentExpr): MutatingScope
+	{
+		$implicitIndex = 0;
+		foreach ($arrayExpr->items as $arrayItem) {
+			if ($arrayItem->key !== null) {
+				$keyType = $scope->getType($arrayItem->key)->toArrayKey();
+
+				if ($implicitIndex !== null) {
+					$keyValues = $keyType->getConstantScalarValues();
+					if (count($keyValues) === 1) {
+						$keyValue = $keyValues[0];
+						if (is_int($keyValue) && $keyValue >= $implicitIndex) {
+							$implicitIndex = $keyValue + 1;
+						}
+					} elseif (!$keyType->isInteger()->no()) {
+						// Key could be an integer, but we don't know which one,
+						// so subsequent implicit indices are unpredictable
+						$implicitIndex = null;
+					}
+				}
+
+				$dimExpr = $arrayItem->key;
+			} elseif ($implicitIndex !== null) {
+				$dimExpr = new Node\Scalar\Int_($implicitIndex);
+				$implicitIndex++;
+			} else {
+				$dimExpr = new TypeExpr(new IntegerType());
+			}
+
+			if ($arrayItem->value instanceof Expr\Array_) {
+				$dimFetchExpr = new ArrayDimFetch($parentExpr, $dimExpr);
+				$scope = $this->processArrayByRefItems($scope, $rootVarName, $arrayItem->value, $dimFetchExpr);
+			}
+
+			if (!$arrayItem->byRef || !$arrayItem->value instanceof Variable || !is_string($arrayItem->value->name)) {
+				continue;
+			}
+
+			$refVarName = $arrayItem->value->name;
+			$dimFetchExpr = new ArrayDimFetch($parentExpr, $dimExpr);
+			$refType = $scope->getType(new Variable($refVarName));
+			$refNativeType = $scope->getNativeType(new Variable($refVarName));
+
+			// When $rootVarName's array key changes, update $refVarName
+			$scope = $scope->assignExpression(
+				new IntertwinedVariableByReferenceWithExpr($rootVarName, new Variable($refVarName), $dimFetchExpr),
+				$refType,
+				$refNativeType,
+			);
+
+			// When $refVarName changes, update $rootVarName's array key
+			$scope = $scope->assignExpression(
+				new IntertwinedVariableByReferenceWithExpr($refVarName, $dimFetchExpr, new Variable($refVarName)),
+				$refType,
+				$refNativeType,
+			);
+		}
+
+		return $scope;
+	}
+
 	/**
 	 * @param list<ArrayDimFetch> $dimFetchStack
 	 * @param non-empty-list<array{Type|null, ArrayDimFetch}> $offsetTypes

src/Analyser/MutatingScope.php

@@ -2582,7 +2582,7 @@
 			$scope->nativeExpressionTypes[$exprString] = new ExpressionTypeHolder($node, $nativeType, $certainty);
 		}
 
-		foreach ($scope->expressionTypes as $expressionType) {
+		foreach ($scope->expressionTypes as $exprString => $expressionType) {
 			if (!$expressionType->getExpr() instanceof IntertwinedVariableByReferenceWithExpr) {
 				continue;
 			}
@@ -2593,6 +2593,16 @@
 				continue;
 			}
 
+			$assignedExpr = $expressionType->getExpr()->getAssignedExpr();
+			if (
+				$assignedExpr instanceof Expr\ArrayDimFetch
+				&& !$this->isDimFetchPathReachable($scope, $assignedExpr)
+			) {
+				unset($scope->expressionTypes[$exprString]);
+				unset($scope->nativeExpressionTypes[$exprString]);
+				continue;
+			}
+
 			$has = $scope->hasExpressionType($expressionType->getExpr()->getExpr());
 			if (
 				$expressionType->getExpr()->getExpr() instanceof Variable
@@ -2611,18 +2621,41 @@
 					array_merge($intertwinedPropagatedFrom, [$variableName]),
 				);
 			} else {
+				$targetRootVar = $this->getIntertwinedRefRootVariableName($expressionType->getExpr()->getExpr());
+				if ($targetRootVar !== null && in_array($targetRootVar, $intertwinedPropagatedFrom, true)) {
+					continue;
+				}
 				$scope = $scope->assignExpression(
 					$expressionType->getExpr()->getExpr(),
 					$scope->getType($expressionType->getExpr()->getAssignedExpr()),
 					$scope->getNativeType($expressionType->getExpr()->getAssignedExpr()),
 				);
 			}
-
 		}
 
 		return $scope;
 	}
 
+	private function isDimFetchPathReachable(self $scope, Expr\ArrayDimFetch $dimFetch): bool
+	{
+		if ($dimFetch->dim === null) {
+			return false;
+		}
+
+		if (!$dimFetch->var instanceof Expr\ArrayDimFetch) {
+			return true;
+		}
+
+		$varType = $scope->getType($dimFetch->var);
+		$dimType = $scope->getType($dimFetch->dim);
+
+		if (!$varType->hasOffsetValueType($dimType)->yes()) {
+			return false;
+		}
+
+		return $this->isDimFetchPathReachable($scope, $dimFetch->var);
+	}
+
 	private function unsetExpression(Expr $expr): self
 	{
 		$scope = $this;
@@ -2833,12 +2866,6 @@
 
 		foreach ($expressionTypes as $exprString => $exprTypeHolder) {
 			$exprExpr = $exprTypeHolder->getExpr();
-			if (
-				$exprExpr instanceof IntertwinedVariableByReferenceWithExpr
-				&& $exprExpr->isVariableToVariableReference()
-			) {
-				continue;
-			}
 			if (!$this->shouldInvalidateExpression($exprStringToInvalidate, $expressionToInvalidate, $exprExpr, $exprString, $requireMoreCharacters, $invalidatingClass)) {
 				continue;
 			}
@@ -2906,8 +2933,32 @@
 		);
 	}
 
+	private function getIntertwinedRefRootVariableName(Expr $expr): ?string
+	{
+		if ($expr instanceof Variable && is_string($expr->name)) {
+			return $expr->name;
+		}
+		if ($expr instanceof Expr\ArrayDimFetch) {
+			return $this->getIntertwinedRefRootVariableName($expr->var);
+		}
+		return null;
+	}
+
 	private function shouldInvalidateExpression(string $exprStringToInvalidate, Expr $exprToInvalidate, Expr $expr, string $exprString, bool $requireMoreCharacters = false, ?ClassReflection $invalidatingClass = null): bool
 	{
+		if (
+			$expr instanceof IntertwinedVariableByReferenceWithExpr
+			&& $exprToInvalidate instanceof Variable
+			&& is_string($exprToInvalidate->name)
+			&& (
+				$expr->getVariableName() === $exprToInvalidate->name
+				|| $this->getIntertwinedRefRootVariableName($expr->getExpr()) === $exprToInvalidate->name
+				|| $this->getIntertwinedRefRootVariableName($expr->getAssignedExpr()) === $exprToInvalidate->name
+			)
+		) {
+			return false;
+		}
+
 		if ($requireMoreCharacters && $exprStringToInvalidate === $exprString) {
 			return false;
 		}

src/Node/Expr/IntertwinedVariableByReferenceWithExpr.php

@@ -4,9 +4,7 @@
 
 use Override;
 use PhpParser\Node\Expr;
-use PhpParser\Node\Expr\Variable;
 use PHPStan\Node\VirtualNode;
-use function is_string;
 
 final class IntertwinedVariableByReferenceWithExpr extends Expr implements VirtualNode
 {
@@ -31,14 +29,6 @@ public function getAssignedExpr(): Expr
 		return $this->assignedExpr;
 	}
 
-	public function isVariableToVariableReference(): bool
-	{
-		return $this->expr instanceof Variable
-			&& is_string($this->expr->name)
-			&& $this->assignedExpr instanceof Variable
-			&& is_string($this->assignedExpr->name);
-	}
-
 	#[Override]
 	public function getType(): string
 	{

src/Type/Accessory/HasOffsetValueType.php

@@ -156,7 +156,8 @@
 
 	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 	{
-		if ($offsetType->isConstantScalarValue()->yes() && $offsetType->equals($this->offsetType)) {
+		$arrayKeyType = $offsetType->toArrayKey();
+		if ($arrayKeyType->isConstantScalarValue()->yes() && $arrayKeyType->equals($this->offsetType)) {
 			return TrinaryLogic::createYes();
 		}
 
@@ -165,7 +166,8 @@
 
 	public function getOffsetValueType(Type $offsetType): Type
 	{
-		if ($offsetType->isConstantScalarValue()->yes() && $offsetType->equals($this->offsetType)) {
+		$arrayKeyType = $offsetType->toArrayKey();
+		if ($arrayKeyType->isConstantScalarValue()->yes() && $arrayKeyType->equals($this->offsetType)) {
 			return $this->valueType;
 		}