Skip to content

Commit 8e260fa

Browse files
ondrejmirtesclaude
ondrejmirtes
and
claude
committed
Report variable writes whose value never reaches a use, per array offset
A read no longer counts as a use by itself: a write is used iff its value reaches a sink (a call argument, a condition, a return, echo, throw, a property write...) directly or through the writes it is computed into. The right side of an assignment, a compound assignment and the operand of an increment are walked with the write as the ExpressionContext's value-flow target; pure combinators (arithmetic, concat, casts, unary ops, ternary and match arms, literal arrays, interpolated strings, ??'s right side) keep it, everything else drops it (enterDeep()/withoutValueFlow()). VariableHandler then records a dependency edge instead of a read, VariableWritesNode computes the used set as a fixpoint over the edges and the rule reports `$b = $b + 1` chains, `$s .= ...` chains and `$i++` runs that never reach a sink, as Psalm does. A nested assignment or compound assignment copies its dependencies to the enclosing target. Array offsets are tracked as their own writes of the variable: a literal assigned straight to a variable registers one write per constant offset (items of `$a = ['x' => 1, 'y' => 2]`, up to TRACKED_LITERAL_ITEMS_LIMIT), `$a['k'] = ...` is an offset write that kills only the earlier writes of offset 'k', `$a['k']['j'] = ...` extends offset 'k' (reads it, kills nothing). The receiver of an offset access is read as a container (its whole-variable writes only), `$a['k']` reads offset 'k' plus the writes of unknown offsets, a dynamic offset reads everything, `$a['k'] OP=` and `$a['k'] ??=` read the offset first. unset() discards the reaching writes of a variable or a constant offset without reading them (MutatingScope:: withoutVariableWriteMarkers()), so `$x = 1; unset($x);` is reported too. Messages: "Value assigned to variable $x is never used.", "Value assigned to $a['k'] is never used." and "Offset 'k' of array assigned to variable $a is never used." (an item is reported on its own only when the array as a whole is used). The stronger rule found two more genuine bugs in fixtures: bug-10847's loop appends to the iterated $overloads instead of $processedOverloads, and array-destructuring-array-dim-fetch builds $barcodes for nothing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CbZPnVnRJDLbnqmtD3sYSy
1 parent 6bd8b70 commit 8e260fa

39 files changed

Lines changed: 2599 additions & 220 deletions

‎src/Analyser/ExprHandler/ArrayDimFetchHandler.php‎

Lines changed: 28 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
use PhpParser\Node\Expr;
88
use PhpParser\Node\Expr\ArrayDimFetch;
99
use PhpParser\Node\Expr\MethodCall;
10+
use PhpParser\Node\Expr\Variable;
1011
use PhpParser\Node\Identifier;
1112
use PhpParser\Node\Stmt;
1213
use PHPStan\Analyser\ExpressionContext;
@@ -23,6 +24,7 @@
2324
use PHPStan\Analyser\NodeScopeResolver;
2425
use PHPStan\Analyser\SpecifiedTypes;
2526
use PHPStan\Analyser\TypeSpecifierContext;
27+
use PHPStan\Analyser\VariableWriteOffset;
2628
use PHPStan\DependencyInjection\AutowiredService;
2729
use PHPStan\Node\Expr\TypeExpr;
2830
use PHPStan\Reflection\ParametersAcceptorSelector;
@@ -32,6 +34,7 @@
3234
use PHPStan\Type\Type;
3335
use PHPStan\Type\TypeCombinator;
3436
use function array_merge;
37+
use function is_string;
3538

3639
/**
3740
* @implements ExprHandler<ArrayDimFetch>
@@ -57,18 +60,40 @@ public function supports(Expr $expr): bool
5760
public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
5861
{
5962
$beforeScope = $scope;
63+
// the receiver is read as a container - the offset read itself is
64+
// recorded below, once the dimension is known; both flow into the value
6065
if ($expr->dim === null) {
61-
$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep());
66+
$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeepKeepingValueFlow()->enterArrayDimFetchRoot());
67+
$this->markOffsetRead($nodeScopeResolver, $expr, null, $scope, $context);
6268

6369
return $this->composeResult($nodeScopeResolver, $stmt, $expr, null, $varResult, $storage, $context, $beforeScope);
6470
}
6571

66-
$dimResult = $nodeScopeResolver->processExprNode($stmt, $expr->dim, $scope, $storage, $nodeCallback, $context->enterDeep());
67-
$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $dimResult->getScope(), $storage, $nodeCallback, $context->enterDeep());
72+
$dimResult = $nodeScopeResolver->processExprNode($stmt, $expr->dim, $scope, $storage, $nodeCallback, $context->enterDeepKeepingValueFlow());
73+
$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $dimResult->getScope(), $storage, $nodeCallback, $context->enterDeepKeepingValueFlow()->enterArrayDimFetchRoot());
74+
$this->markOffsetRead($nodeScopeResolver, $expr, VariableWriteOffset::fromType($dimResult->getType()), $dimResult->getScope(), $context);
6875

6976
return $this->composeResult($nodeScopeResolver, $stmt, $expr, $dimResult, $varResult, $storage, $context, $beforeScope);
7077
}
7178

79+
/**
80+
* Records the read of one offset of a local variable for the
81+
* unused-variable check; an unset() target discards the offset's writes
82+
* instead of reading them.
83+
*
84+
* @param int|string|null $offset
85+
*/
86+
private function markOffsetRead(NodeScopeResolver $nodeScopeResolver, ArrayDimFetch $expr, $offset, MutatingScope $scope, ExpressionContext $context): void
87+
{
88+
if ($context->isUnsetTarget()) {
89+
return;
90+
}
91+
if (!$expr->var instanceof Variable || !is_string($expr->var->name)) {
92+
return;
93+
}
94+
$nodeScopeResolver->markVariableOffsetRead($expr->var->name, $offset, $scope, $context->getValueFlowTarget());
95+
}
96+
7297
/**
7398
* Builds the offset read's ExpressionResult from the already-walked
7499
* dimension and receiver results - the chain is not re-walked (only the

‎src/Analyser/ExprHandler/ArrayHandler.php‎

Lines changed: 43 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,11 @@
1616
use PHPStan\Analyser\MutatingScope;
1717
use PHPStan\Analyser\NodeScopeResolver;
1818
use PHPStan\Analyser\SpecifiedTypes;
19+
use PHPStan\Analyser\VariableWriteOffset;
1920
use PHPStan\DependencyInjection\AutowiredService;
2021
use PHPStan\Node\LiteralArrayItem;
2122
use PHPStan\Node\LiteralArrayNode;
23+
use PHPStan\Node\Variable\VariableWrite;
2224
use PHPStan\Reflection\InitializerExprTypeResolver;
2325
use PHPStan\ShouldNotHappenException;
2426
use PHPStan\Type\CallableType;
@@ -27,6 +29,8 @@
2729
use function array_key_exists;
2830
use function array_merge;
2931
use function count;
32+
use function is_int;
33+
use function max;
3034
use function spl_object_id;
3135

3236
/**
@@ -36,6 +40,9 @@
3640
final class ArrayHandler implements ExprHandler
3741
{
3842

43+
/** Offsets of a literal array tracked as separate writes of the assigned variable. */
44+
private const TRACKED_LITERAL_ITEMS_LIMIT = 32;
45+
3946
public function __construct(
4047
private InitializerExprTypeResolver $initializerExprTypeResolver,
4148
private ExpressionResultFactory $expressionResultFactory,
@@ -57,11 +64,22 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
5764
$throwPoints = [];
5865
$impurePoints = [];
5966
$isAlwaysTerminating = false;
67+
// a literal assigned straight to a variable writes each of its constant
68+
// offsets: the items become offset writes of that variable, so a read of
69+
// one offset leaves the others unused
70+
$literalWrite = $context->getValueFlowTarget();
71+
if ($literalWrite !== null && (!$context->isValueFlowDirect() || $literalWrite->isOffsetWrite())) {
72+
$literalWrite = null;
73+
}
74+
$nextIndex = 0;
75+
$nextIndexKnown = true;
76+
$trackedItems = 0;
6077
foreach ($expr->items as $arrayItem) {
6178
$itemNodes[] = new LiteralArrayItem($scope, $arrayItem);
6279
$itemCallbackScope = $scope;
80+
$keyResult = null;
6381
if ($arrayItem->key !== null) {
64-
$keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $scope, $storage, $nodeCallback, $context->enterDeep());
82+
$keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $scope, $storage, $nodeCallback, $context->enterDeepKeepingValueFlow());
6583
$itemResults[spl_object_id($arrayItem->key)] = $keyResult;
6684
$hasYield = $hasYield || $keyResult->hasYield();
6785
$throwPoints = array_merge($throwPoints, $keyResult->getThrowPoints());
@@ -70,7 +88,30 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
7088
$scope = $keyResult->getScope();
7189
}
7290

73-
$valueResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->value, $scope, $storage, $nodeCallback, $context->enterDeep());
91+
$valueContext = $context->enterDeepKeepingValueFlow();
92+
if ($literalWrite !== null) {
93+
if ($arrayItem->unpack) {
94+
$itemOffset = null;
95+
$nextIndexKnown = false;
96+
} elseif ($keyResult === null) {
97+
$itemOffset = $nextIndexKnown ? $nextIndex++ : null;
98+
} else {
99+
$itemOffset = VariableWriteOffset::fromType($keyResult->getType());
100+
if (is_int($itemOffset)) {
101+
$nextIndex = max($nextIndex, $itemOffset + 1);
102+
} elseif ($itemOffset === null) {
103+
$nextIndexKnown = false;
104+
}
105+
}
106+
if ($trackedItems < self::TRACKED_LITERAL_ITEMS_LIMIT) {
107+
$trackedItems++;
108+
$itemWrite = $nodeScopeResolver->recordVariableOffsetWrite($arrayItem, $literalWrite->getVariableName(), VariableWrite::KIND_ARRAY_LITERAL_ITEM, $itemOffset, $literalWrite);
109+
if ($itemWrite !== null) {
110+
$valueContext = $context->enterDeep()->enterValueFlow($itemWrite, false);
111+
}
112+
}
113+
}
114+
$valueResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->value, $scope, $storage, $nodeCallback, $valueContext);
74115
$itemResults[spl_object_id($arrayItem->value)] = $valueResult;
75116
$hasYield = $hasYield || $valueResult->hasYield();
76117
$throwPoints = array_merge($throwPoints, $valueResult->getThrowPoints());

‎src/Analyser/ExprHandler/AssignHandler.php‎

Lines changed: 99 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,7 @@
4747
use PHPStan\Analyser\SpecifiedTypes;
4848
use PHPStan\Analyser\TypeSpecifierContext;
4949
use PHPStan\Analyser\VarAnnotationProcessor;
50+
use PHPStan\Analyser\VariableWriteOffset;
5051
use PHPStan\DependencyInjection\AutowiredService;
5152
use PHPStan\Node\Expr\ExistingArrayDimFetch;
5253
use PHPStan\Node\Expr\IntertwinedVariableByReferenceWithExpr;
@@ -187,8 +188,20 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
187188
$expr->expr,
188189
);
189190
}
191+
$valueContext = $valueContext->enterDeep();
192+
// the write site is registered before its value is walked, so the
193+
// variable reads in the value are recorded as what the write is
194+
// computed from rather than as sinks
195+
$valueFlowWrite = $expr instanceof AssignRef ? null : $this->registerWriteSite($nodeScopeResolver, $target, VariableWrite::KIND_ASSIGN);
196+
if ($valueFlowWrite !== null) {
197+
$valueContext = $valueContext->enterValueFlow($valueFlowWrite, true);
198+
}
190199

191-
$assignedExprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext->enterDeep());
200+
$assignedExprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext);
201+
if ($valueFlowWrite !== null && $context->getValueFlowTarget() !== null) {
202+
// `$a = $b = ...`: the value flows into both targets
203+
$nodeScopeResolver->copyVariableWriteDependencies($context->getValueFlowTarget(), $valueFlowWrite);
204+
}
192205
$valueImpurePoints = array_merge($valueImpurePoints, $assignedExprResult->getImpurePoints());
193206
$valueScope = $assignedExprResult->getScope();
194207

@@ -547,14 +560,15 @@ public function prepareTarget(
547560
callable $nodeCallback,
548561
ExpressionContext $context,
549562
AssignTargetWalkMode $mode,
563+
?VariableWrite $valueFlowTarget = null,
550564
): PreparedAssignTarget
551565
{
552566
// The raw target's node callback fires after the walk below composed and
553567
// stored the target's read result, with the scope captured at entry -
554568
// a synchronously invoked rule (the plain resolver, PHP < 8.1) then
555569
// answers its asks from the storage instead of re-walking on demand,
556570
// same as NodeScopeResolver::processExprNodeInternal().
557-
$prepared = $this->doPrepareTarget($nodeScopeResolver, $scope, $storage, $stmt, $var, $assignedExpr, $nodeCallback, $context, $mode);
571+
$prepared = $this->doPrepareTarget($nodeScopeResolver, $scope, $storage, $stmt, $var, $assignedExpr, $nodeCallback, $context, $mode, $valueFlowTarget);
558572
$nodeScopeResolver->callNodeCallback($nodeCallback, $var, $mode->enterExpressionAssign() ? $scope->enterExpressionAssign($var) : $scope, $storage);
559573

560574
return $prepared;
@@ -573,6 +587,7 @@ private function doPrepareTarget(
573587
callable $nodeCallback,
574588
ExpressionContext $context,
575589
AssignTargetWalkMode $mode,
590+
?VariableWrite $valueFlowTarget = null,
576591
): PreparedAssignTarget
577592
{
578593
$enterExpressionAssign = $mode->enterExpressionAssign();
@@ -595,7 +610,7 @@ private function doPrepareTarget(
595610
if (!is_string($var->name)) {
596611
// `$$name OP= ...` evaluates the name before reading the old
597612
// value: walk it once here, the write flow consumes the result
598-
$variableNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context);
613+
$variableNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
599614
$hasYield = $variableNameResult->hasYield();
600615
$throwPoints = $variableNameResult->getThrowPoints();
601616
$impurePoints = $variableNameResult->getImpurePoints();
@@ -607,7 +622,7 @@ private function doPrepareTarget(
607622
$nonNullabilityResult = $this->nonNullabilityHelper->ensureNonNullability($scope, $var);
608623
$readScope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($nonNullabilityResult->getScope(), $var);
609624
}
610-
$targetReadResult = $this->variableHandler->composeResult($nodeScopeResolver, $var, $variableNameResult, $storage, $readScope);
625+
$targetReadResult = $this->variableHandler->composeResult($nodeScopeResolver, $var, $variableNameResult, $storage, $readScope, $valueFlowTarget);
611626
if ($mode->issetSemanticsForRead()) {
612627
$targetChainResults[spl_object_id($var)] = $targetReadResult;
613628
}
@@ -648,7 +663,7 @@ private function doPrepareTarget(
648663
if ($enterExpressionAssign) {
649664
$scope = $scope->enterExpressionAssign($var, false);
650665
}
651-
$varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep());
666+
$varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep()->enterArrayDimFetchRoot());
652667
$hasYield = $varResult->hasYield();
653668
$throwPoints = $varResult->getThrowPoints();
654669
$impurePoints = $varResult->getImpurePoints();
@@ -834,7 +849,7 @@ private function doPrepareTarget(
834849

835850
if ($var instanceof PropertyFetch) {
836851
$scopeBeforeVar = $scope;
837-
$objectResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, $context);
852+
$objectResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
838853
$hasYield = $objectResult->hasYield();
839854
$throwPoints = $objectResult->getThrowPoints();
840855
$impurePoints = $objectResult->getImpurePoints();
@@ -846,7 +861,7 @@ private function doPrepareTarget(
846861
if ($var->name instanceof Node\Identifier) {
847862
$propertyName = $var->name->name;
848863
} else {
849-
$propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context);
864+
$propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
850865
$hasYield = $hasYield || $propertyNameResult->hasYield();
851866
$throwPoints = array_merge($throwPoints, $propertyNameResult->getThrowPoints());
852867
$impurePoints = array_merge($impurePoints, $propertyNameResult->getImpurePoints());
@@ -903,7 +918,7 @@ private function doPrepareTarget(
903918
if ($var->class instanceof Node\Name) {
904919
$propertyHolderType = $scope->resolveTypeByName($var->class);
905920
} else {
906-
$classResult = $nodeScopeResolver->processExprNode($stmt, $var->class, $scope, $storage, $nodeCallback, $context);
921+
$classResult = $nodeScopeResolver->processExprNode($stmt, $var->class, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
907922
$propertyHolderType = $classResult->getType();
908923
}
909924

@@ -912,7 +927,7 @@ private function doPrepareTarget(
912927
if ($var->name instanceof Node\Identifier) {
913928
$propertyName = $var->name->name;
914929
} else {
915-
$propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context);
930+
$propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
916931
$hasYield = $propertyNameResult->hasYield();
917932
$throwPoints = $propertyNameResult->getThrowPoints();
918933
$impurePoints = $propertyNameResult->getImpurePoints();
@@ -1027,7 +1042,7 @@ private function doPrepareTarget(
10271042
);
10281043
}
10291044

1030-
$varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context);
1045+
$varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
10311046
$hasYield = $varResult->hasYield();
10321047
$throwPoints = array_merge($throwPoints, $varResult->getThrowPoints());
10331048
$impurePoints = array_merge($impurePoints, $varResult->getImpurePoints());
@@ -1245,7 +1260,7 @@ public function applyWrite(
12451260
$this->readAssignedValueType($nodeScopeResolver, $storedAssignedExprResult, $assignedExpr, $scope->doNotTreatPhpDocTypesAsCertain()),
12461261
TrinaryLogic::createYes(),
12471262
[],
1248-
$write,
1263+
$write !== null ? $nodeScopeResolver->getVariableWriteMarkersToPlant($write) : [],
12491264
$write !== null ? $nodeScopeResolver->getVariableWriteMarkersToKill($var->name) : [],
12501265
);
12511266
foreach ($conditionalExpressions as $exprString => $holders) {
@@ -1259,7 +1274,7 @@ public function applyWrite(
12591274
// a plain assignment does not read the target, so the dynamic name
12601275
// is walked here; read-modify-write targets walked it in
12611276
// prepareTarget() and already carry its state
1262-
$nameExprResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context);
1277+
$nameExprResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context->withoutValueFlow());
12631278
$hasYield = $hasYield || $nameExprResult->hasYield();
12641279
$throwPoints = array_merge($throwPoints, $nameExprResult->getThrowPoints());
12651280
$impurePoints = array_merge($impurePoints, $nameExprResult->getImpurePoints());
@@ -1351,16 +1366,20 @@ public function applyWrite(
13511366
// an offset write on an object (ArrayAccess, mixed) mutates a shared
13521367
// handle - only a value container (array, string) makes it a write site
13531368
$write = $target->getWriteSiteKind() !== null && ($varType->isArray()->yes() || $varType->isString()->yes())
1354-
? $nodeScopeResolver->recordVariableWrite($var, VariableWrite::KIND_ARRAY_DIM_WRITE)
1369+
? $this->registerArrayDimWriteSite($nodeScopeResolver, $target)
13551370
: null;
1371+
if ($write !== null && $target->getWriteSiteKind() === VariableWrite::KIND_READ_MODIFY_WRITE) {
1372+
// `$a['k'] OP= ...` and `$a['k'] ??= ...` read the offset's old value
1373+
$nodeScopeResolver->markVariableOffsetRead($var->name, $write->getOffset(), $scopeBeforeAssignEval);
1374+
}
13561375
$scope = $scope->assignVariable(
13571376
$var->name,
13581377
$valueToWrite,
13591378
$nativeValueToWrite,
13601379
TrinaryLogic::createYes(),
13611380
[],
1362-
$write,
1363-
$write !== null ? $nodeScopeResolver->getVariableWriteMarkersToKill($var->name) : [],
1381+
$write !== null ? [$write->getMarkerExpr()] : [],
1382+
$write !== null ? $this->getArrayDimWriteMarkersToKill($nodeScopeResolver, $target, $write) : [],
13641383
);
13651384
} else {
13661385
if ($var instanceof PropertyFetch || $var instanceof StaticPropertyFetch) {
@@ -2132,6 +2151,71 @@ private function isExprSafeToProjectThroughVariable(Expr $expr, string $variable
21322151
return count($rhsImpurePoints) === 0;
21332152
}
21342153

2154+
/**
2155+
* Registers the write site of a prepared plain-variable or offset target
2156+
* before its value is walked, so the reads in the value are recorded as
2157+
* what the write is computed from; null when the target is not a site (a
2158+
* dynamic name, an offset of an object or of a value of unknown type).
2159+
*
2160+
* @param VariableWrite::KIND_* $kind
2161+
*/
2162+
public function registerWriteSite(NodeScopeResolver $nodeScopeResolver, PreparedAssignTarget $target, int $kind): ?VariableWrite
2163+
{
2164+
$var = $target->getVar();
2165+
if ($var instanceof Variable) {
2166+
return is_string($var->name) ? $nodeScopeResolver->recordVariableWrite($var, $kind) : null;
2167+
}
2168+
if (!$var instanceof ArrayDimFetch) {
2169+
return null;
2170+
}
2171+
$rootType = $target->getVarResult()->getType();
2172+
if (
2173+
!$rootType->isArray()->yes()
2174+
&& !$rootType->isString()->yes()
2175+
&& !$this->isImplicitArrayCreation($target->getDimFetchStack(), $target->getScope())->yes()
2176+
) {
2177+
return null;
2178+
}
2179+
2180+
return $this->registerArrayDimWriteSite($nodeScopeResolver, $target);
2181+
}
2182+
2183+
/**
2184+
* `$a['k'] = ...` writes offset 'k' of $a. `$a['k']['j'] = ...` extends the
2185+
* value of offset 'k' instead: that value is read and the earlier writes of
2186+
* the offset stay alive (the site kills nothing).
2187+
*/
2188+
private function registerArrayDimWriteSite(NodeScopeResolver $nodeScopeResolver, PreparedAssignTarget $target): ?VariableWrite
2189+
{
2190+
$rootVar = $target->getRootVar();
2191+
if (!$rootVar instanceof Variable || !is_string($rootVar->name)) {
2192+
return null;
2193+
}
2194+
$offsetTypes = $target->getOffsetTypes();
2195+
$offset = $offsetTypes[0][0] !== null ? VariableWriteOffset::fromType($offsetTypes[0][0]) : null;
2196+
if (count($target->getDimFetchStack()) > 1) {
2197+
$nodeScopeResolver->markVariableOffsetRead($rootVar->name, $offset, $target->getBeforeScope());
2198+
}
2199+
2200+
return $nodeScopeResolver->recordVariableOffsetWrite($target->getVar(), $rootVar->name, VariableWrite::KIND_ARRAY_DIM_WRITE, $offset);
2201+
}
2202+
2203+
/**
2204+
* The markers an offset write kills: the earlier writes of the same
2205+
* constant offset - see MutatingScope::assignVariable().
2206+
*
2207+
* @return list<Expr>
2208+
*/
2209+
private function getArrayDimWriteMarkersToKill(NodeScopeResolver $nodeScopeResolver, PreparedAssignTarget $target, VariableWrite $write): array
2210+
{
2211+
$offset = $write->getOffset();
2212+
if ($offset === null || count($target->getDimFetchStack()) > 1) {
2213+
return [];
2214+
}
2215+
2216+
return $nodeScopeResolver->getVariableOffsetWriteMarkersToKill($write->getVariableName(), $offset);
2217+
}
2218+
21352219
/**
21362220
* @param list<ArrayDimFetch> $dimFetchStack
21372221
*/

0 commit comments

Comments
 (0)