Simplify reference propagation: prevent invalidation instead of re-registering

Replace the re-register-after-propagation approach with a cleaner design:
- Skip invalidation of simple variable-to-variable IntertwinedVariableByReferenceWithExpr
  entries in invalidateExpression() so reference links persist across assignments
- Add propagateReferences parameter to assignVariable() to prevent infinite
  recursion when propagating types through bidirectional reference links

This is simpler and more efficient than the previous approach of letting
entries be invalidated and then re-creating them after each propagation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: phpstan-bot

src/Analyser/MutatingScope.php

@@ -2635,7 +2635,7 @@ public function isUndefinedExpressionAllowed(Expr $expr): bool
 		return array_key_exists($exprString, $this->currentlyAllowedUndefinedExpressions);
 	}
 
-	public function assignVariable(string $variableName, Type $type, Type $nativeType, TrinaryLogic $certainty): self
+	public function assignVariable(string $variableName, Type $type, Type $nativeType, TrinaryLogic $certainty, bool $propagateReferences = true): self
 	{
 		$node = new Variable($variableName);
 		$scope = $this->assignExpression($node, $type, $nativeType);
@@ -2647,12 +2647,11 @@ public function assignVariable(string $variableName, Type $type, Type $nativeTyp
 			$scope->nativeExpressionTypes[$exprString] = new ExpressionTypeHolder($node, $nativeType, $certainty);
 		}
 
-		// Use $this->expressionTypes (pre-invalidation) to find intertwined entries.
-		// assignExpression() calls invalidateExpression() which removes entries whose
-		// sub-nodes contain the variable being assigned. For bidirectional reference
-		// links ($b = &$a), this incorrectly removes the reverse entry.
-		$processedIntertwinedEntries = [];
-		foreach ($this->expressionTypes as $expressionType) {
+		if (!$propagateReferences) {
+			return $scope;
+		}
+
+		foreach ($scope->expressionTypes as $expressionType) {
 			if (!$expressionType->getExpr() instanceof IntertwinedVariableByReferenceWithExpr) {
 				continue;
 			}
@@ -2669,12 +2668,12 @@ public function assignVariable(string $variableName, Type $type, Type $nativeTyp
 				&& is_string($expressionType->getExpr()->getExpr()->name)
 				&& !$has->no()
 			) {
-				$processedIntertwinedEntries[] = $expressionType->getExpr();
 				$scope = $scope->assignVariable(
 					$expressionType->getExpr()->getExpr()->name,
 					$scope->getType($expressionType->getExpr()->getAssignedExpr()),
 					$scope->getNativeType($expressionType->getExpr()->getAssignedExpr()),
 					$has,
+					false,
 				);
 			} else {
 				$scope = $scope->assignExpression(
@@ -2686,31 +2685,6 @@ public function assignVariable(string $variableName, Type $type, Type $nativeTyp
 
 		}
 
-		// Re-register intertwined entries (and their reverse) that were
-		// invalidated during propagation so that subsequent assignments
-		// to either variable continue to propagate correctly.
-		foreach ($processedIntertwinedEntries as $intertwinedExpr) {
-			$currentType = $scope->getType($intertwinedExpr->getAssignedExpr());
-			$currentNativeType = $scope->getNativeType($intertwinedExpr->getAssignedExpr());
-
-			// Re-register this direction
-			$scope = $scope->assignExpression($intertwinedExpr, $currentType, $currentNativeType);
-
-			// Re-register the reverse direction
-			if (
-				$intertwinedExpr->getExpr() instanceof Variable
-				&& is_string($intertwinedExpr->getExpr()->name)
-			) {
-				$linkedVarName = $intertwinedExpr->getExpr()->name;
-				$reverseExpr = new IntertwinedVariableByReferenceWithExpr(
-					$linkedVarName,
-					new Variable($variableName),
-					new Variable($linkedVarName),
-				);
-				$scope = $scope->assignExpression($reverseExpr, $currentType, $currentNativeType);
-			}
-		}
-
 		return $scope;
 	}
 
@@ -2901,6 +2875,15 @@ public function invalidateExpression(Expr $expressionToInvalidate, bool $require
 
 		foreach ($expressionTypes as $exprString => $exprTypeHolder) {
 			$exprExpr = $exprTypeHolder->getExpr();
+			if (
+				$exprExpr instanceof IntertwinedVariableByReferenceWithExpr
+				&& $exprExpr->getExpr() instanceof Variable
+				&& is_string($exprExpr->getExpr()->name)
+				&& $exprExpr->getAssignedExpr() instanceof Variable
+				&& is_string($exprExpr->getAssignedExpr()->name)
+			) {
+				continue;
+			}
 			if (!$this->shouldInvalidateExpression($exprStringToInvalidate, $expressionToInvalidate, $exprExpr, $exprString, $requireMoreCharacters, $invalidatingClass)) {
 				continue;
 			}