Merge scope after ?-> method call to account for argument short-circuiting

- In NullsafeMethodCallHandler::processExpr(), merge the post-call scope
  with the pre-call scope when the var type is nullable, so variables
  assigned in arguments become "maybe defined" rather than "definitely defined"
- When the var type is always null, use the pre-call scope directly since
  arguments are never evaluated
- Add DefinedVariableRule regression tests for nullable, always-null, and
  multi-argument cases
- Add NSRT type inference tests verifying correct types after nullsafe calls

Author: ondrejmirtes

src/Analyser/ExprHandler/NullsafeMethodCallHandler.php

@@ -60,6 +60,9 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type
 
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
+		$scopeBeforeNullsafe = $scope;
+		$varType = $scope->getType($expr->var);
+
 		$nonNullabilityResult = $this->nonNullabilityHelper->ensureShallowNonNullability($scope, $scope, $expr->var);
 		$attributes = array_merge($expr->getAttributes(), ['virtualNullsafeMethodCall' => true]);
 		unset($attributes[ExprPrinter::ATTRIBUTE_CACHE_KEY]);
@@ -78,6 +81,15 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		);
 		$scope = $this->nonNullabilityHelper->revertNonNullability($exprResult->getScope(), $nonNullabilityResult->getSpecifiedExpressions());
 
+		if ($varType->isNull()->yes()) {
+			// Arguments are never evaluated when the var is always null.
+			$scope = $scopeBeforeNullsafe;
+		} elseif (TypeCombinator::containsNull($varType)) {
+			// Arguments might not be evaluated (short-circuit).
+			// Merge with the original scope so variables assigned in arguments become "maybe defined".
+			$scope = $scope->mergeWith($scopeBeforeNullsafe);
+		}
+
 		return new ExpressionResult(
 			$scope,
 			hasYield: $exprResult->hasYield(),

tests/PHPStan/Analyser/nsrt/bug-10729.php

@@ -0,0 +1,44 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug10729Types;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+	public function bar(string $a, string $b): string
+	{
+		return $a . $b;
+	}
+}
+
+function nullable(?Foo $foo): void
+{
+	$foo?->bar($a = 'hello', $b = 'world');
+	assertType("'hello'|null", $a ?? null);
+	assertType("'world'|null", $b ?? null);
+}
+
+function nonNullable(Foo $foo): void
+{
+	$foo->bar($a = 'hello', $b = 'world');
+	assertType("'hello'", $a);
+	assertType("'world'", $b);
+}
+
+function alwaysNull(): void
+{
+	$foo = null;
+	$foo?->bar($a = 'hello', $b = 'world');
+	assertType('null', $a ?? null); // $a is never assigned when $foo is always null
+}
+
+function chainedNullsafe(?Foo $foo): void
+{
+	$result = $foo?->bar($x = 'a', $y = 'b');
+	assertType('string|null', $result);
+	assertType("'a'|null", $x ?? null);
+	assertType("'b'|null", $y ?? null);
+}

tests/PHPStan/Rules/Variables/DefinedVariableRuleTest.php

@@ -1531,4 +1531,35 @@ public function testBug6688(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.0')]
+	public function testBug10729(): void
+	{
+		$this->cliArgumentsVariablesRegistered = true;
+		$this->polluteScopeWithLoopInitialAssignments = false;
+		$this->checkMaybeUndefinedVariables = true;
+		$this->polluteScopeWithAlwaysIterableForeach = true;
+		$this->analyse([__DIR__ . '/data/bug-10729.php'], [
+			[
+				'Variable $format might not be defined.',
+				12,
+			],
+			[
+				'Undefined variable: $format',
+				25,
+			],
+			[
+				'Variable $format might not be defined.',
+				31,
+			],
+			[
+				'Variable $value might not be defined.',
+				32,
+			],
+			[
+				'Variable $format might not be defined.',
+				38,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Variables/data/bug-10729.php

@@ -0,0 +1,47 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug10729;
+
+class HelloWorld
+{
+	public function sayHello(?\DateTimeImmutable $date): void
+	{
+		var_dump($date?->format($format = "Y-m-d"));
+		var_dump($format); // might not be defined if $date is null
+	}
+
+	public function nonNullable(\DateTimeImmutable $date): void
+	{
+		var_dump($date->format($format = "Y-m-d"));
+		var_dump($format); // always defined, $date can't be null
+	}
+
+	public function nullOnly(): void
+	{
+		$date = null;
+		var_dump($date?->format($format = "Y-m-d"));
+		var_dump($format); // undefined, $date is always null
+	}
+
+	public function multipleArgs(?\DateTimeImmutable $date): void
+	{
+		$date?->createFromFormat($format = 'Y-m-d', $value = '2024-01-01');
+		var_dump($format); // might not be defined
+		var_dump($value); // might not be defined
+	}
+
+	public function nestedAssignment(?\DateTimeImmutable $date): void
+	{
+		$result = $date?->format($format = "Y-m-d");
+		var_dump($format); // might not be defined
+	}
+
+	public function existingVarStillDefined(?\DateTimeImmutable $date): void
+	{
+		$existing = 'before';
+		$date?->format($format = "Y-m-d");
+		var_dump($existing); // always defined, not affected by nullsafe
+	}
+}