Treat all in-scope variables as used when an unused-parameter body accesses a variable variable ($$name)

[phpstan-bot]

Summary

The reported bug — a false closure.unusedUse error for a use variable that is only accessed inside an include/require/eval — was already fixed on 2.2.x (commit 501ac99) by treating all in-scope variables as used when the body contains include/require/eval. Per the maintainer, only a regression test was outstanding.

While adding that test, I probed the parallel "dynamic variable access PHPStan cannot resolve statically" axis and found the same false positive for variable variables ($$name): PHPStan cannot know which variable $$name resolves to, yet it still reported the captured use/constructor parameter as unused. This PR fixes that analogous case and adds regression tests for both the original and the new case.

Changes

• src/Rules/UnusedFunctionParametersCheck.php: in getUsedVariables(), when a Variable node has a non-string name (a variable variable such as $$name), return $scope->getDefinedVariables() so every in-scope variable is considered used — the same conservative treatment already applied to include/require/eval and func_get_args()/get_defined_vars(). The two Variable branches were merged to keep the narrowing clean and avoid a now-redundant is_string() check.
• tests/PHPStan/Rules/Functions/data/unused-closure-uses.php: added the issue's verbatim closure-with-require reproducer, plus a closure whose body accesses $$name.
• tests/PHPStan/Rules/Classes/data/unused-constructor-parameters-include.php: added a constructor whose body accesses $$name.

Both callers of the shared check — UnusedClosureUsesRule and UnusedConstructorParametersRule — are covered by the single fix location.

Root cause

UnusedFunctionParametersCheck walks the function/closure body collecting the names of variables that are "used", then flags any parameter/use variable that never appears. Constructs that can access variables PHPStan cannot enumerate statically must short-circuit this walk and mark every in-scope variable as used. include/require/eval were handled; a Variable with a dynamic (non-string) name — i.e. a variable variable — was not, so it fell through to the recursive descent, marking only the inner name expression ($name) as used and leaving the actually-captured variable ($container) reported as unused.

Test

• UnusedClosureUsesRuleTest::testUnusedClosureUses — extended with the require reproducer from the issue (no error expected) and a $$name closure body; the latter fails without the fix with Anonymous function has an unused use $container. and passes with it.
• UnusedConstructorParametersRuleTest::testParameterUsedInIncludedFile — extended with a constructor accessing $$name; fails without the fix with Constructor of class ... has an unused parameter $usedViaVariableVariable. and passes with it.

Fixes phpstan/phpstan#13960

[VincentLanglet]

Should

$name = 'notcontainer';

function () use ($container, $name) {
	echo $$name;
};

still be reported as unused ?

[staabm]

check the comment #6058 (comment)

[phpstan-bot]

I've addressed the review. Here's what the referenced comment (VincentLanglet's) was asking:

Should $name = 'notcontainer'; function () use ($container, $name) { echo $$name; }; still be reported as unused?

Yes — and my original PR was wrong there. The first version conservatively marked every in-scope variable as used whenever the body contained any variable variable, which is a false negative when $$name provably resolves to a different variable.

What I changed

src/Rules/UnusedFunctionParametersCheck.php — for a Variable with a non-string name ($$name), I now resolve the type of the name expression first:

• If it's isString()->yes() with non-empty getConstantStrings() (i.e. a fully enumerable set of constant string names — TypeCombinator guarantees a general string component would collapse the constants away), mark exactly those resolved variable names as used, and let the normal recursion also mark the inner $name.
• Otherwise (name can't be resolved statically), fall back to getDefinedVariables() as before.

This mirrors the existing precedent in VariableHandler::resolveType() and the compact() branch in the same method.

Tests — added VincentLanglet's exact scenario to unused-closure-uses.php ($otherName = 'notContainer') with an expected unused use $container error at line 43, since $$otherName provably refers to notContainer, not container.

Verification

• Confirmed the new test fails without the source change (the $container error is missing) and passes with it.
• make phpstan — no errors.
• UnusedClosureUsesRuleTest + UnusedConstructorParametersRuleTest — 9/9 pass.

Committed and pushed as one logical change.