Generalize a template argument resolution when writes widen the object beyond its initial type

src/Analyser/Generics/TemplateArgumentSolver.php

@@ -5,6 +5,7 @@
 use PhpParser\Node\Expr;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Turbo\ReferencedByTurboExtension;
+use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\Generic\UnresolvedTemplateArgumentType;
 use PHPStan\Type\MixedType;
@@ -297,7 +298,16 @@
 		if (TemplateArgumentStats::$enabled) {
 			TemplateArgumentStats::increment(count($lowerBounds) > 0 ? 'resolvedWithLowerBounds' : 'resolvedToInitial');
 		}
-		return TypeCombinator::union(...$parts);
+		$resolved = TypeCombinator::union(...$parts);
+		if ($initial !== null && !$initial instanceof NeverType && !$initial->isSuperTypeOf($resolved)->yes()) {
+			// the body puts values into the object it was not created with: what
+			// the observation pass read out of it was the initial type alone, so
+			// a value derived from such a read and put back ($box->set($box->get() + 1))
+			// is one step of a loop - generalized like a loop's variables
+			return $resolved->generalize(GeneralizePrecision::lessSpecific());
+		}
+
+		return $resolved;
 	}
 
 	/**

tests/PHPStan/Analyser/Generics/TemplateArgumentResolverTest.php

@@ -128,7 +128,7 @@ public function testLowerBoundsUnionWithTheInitialUnlessASendWins(): void
 		$constraints = $constraints->merge((new TemplateArgumentObserver())->collectArgument(new CallableType([], $marker, false), new CallableType([], new StringType(), false)));
 		$frame = (new TemplateArgumentResolver())->resolve($constraints, null, []);
 
-		$this->assertSame("1|2|'a'|null", self::describe($frame->resolve($site, 'T')), 'callable parameters are contravariant and contribute nothing');
+		$this->assertSame('int|string|null', self::describe($frame->resolve($site, 'T')), 'callable parameters are contravariant and contribute nothing');
 
 		[$constraints, $site, $ofMarker] = self::constraintsWithA(new ConstantIntegerType(1));
 		$constraints = $constraints->merge((new TemplateArgumentObserver())->collectArgument($ofMarker->getTypes()[0], new ConstantStringType('a')));

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

@@ -0,0 +1,148 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug15430;
+
+use function PHPStan\Testing\assertType;
+
+/** @template T */
+final class Box
+{
+	/** @param T $value */
+	public function __construct(private mixed $value)
+	{
+	}
+
+	/** @return T */
+	public function get(): mixed
+	{
+		  return $this->value;
+	}
+
+	/** @param T $value */
+	public function set(mixed $value): void
+	{
+		  $this->value = $value;
+	}
+
+	/**
+	 * @template U
+	 * @param U $value
+	 * @return self<U>
+	 */
+	public static function of(mixed $value): self
+	{
+		return new self($value);
+	}
+}
+
+/** @param callable(): void $callback */
+function repeat(int $times, callable $callback): void
+{
+	for ($i = 0; $i < $times; $i++) {
+		$callback();
+	}
+}
+
+/**
+ * @template U
+ * @param U $value
+ * @return Box<U>
+ */
+function wrap(mixed $value): Box
+{
+	return new Box($value);
+}
+
+function test(): void
+{
+	$count = new Box(0);
+
+	repeat(5, function () use ($count): void {
+		  $count->set($count->get() + 1);
+	});
+
+	assertType('Bug15430\Box<int>', $count);
+
+	if ($count->get() === 5) {
+		  echo 'reached at runtime';
+	}
+}
+
+function straight(): void
+{
+	$count = new Box(0);
+	$count->set($count->get() + 1);
+	assertType('Bug15430\Box<int>', $count);
+}
+
+function loop(): void
+{
+	$count = new Box(0);
+	for ($i = 0; $i < 5; $i++) {
+		$count->set($count->get() + 1);
+	}
+	assertType('Bug15430\Box<int>', $count);
+}
+
+function arrowFunction(): void
+{
+	$count = new Box(0);
+	repeat(5, fn () => $count->set($count->get() + 1));
+	assertType('Bug15430\Box<int>', $count);
+}
+
+function staticFactory(): void
+{
+	$count = Box::of(0);
+	repeat(5, function () use ($count): void {
+		$count->set($count->get() + 1);
+	});
+	assertType('Bug15430\Box<int>', $count);
+}
+
+function genericFunction(): void
+{
+	$count = wrap(0);
+	repeat(5, function () use ($count): void {
+		$count->set($count->get() + 1);
+	});
+	assertType('Bug15430\Box<int>', $count);
+}
+
+function concat(): void
+{
+	$s = new Box('a');
+	repeat(5, function () use ($s): void {
+		$s->set($s->get() . 'b');
+	});
+	assertType('Bug15430\Box<string>', $s);
+}
+
+function append(): void
+{
+	$s = new Box([]);
+	repeat(5, function () use ($s): void {
+		$a = $s->get();
+		$a[] = 1;
+		$s->set($a);
+	});
+	assertType('Bug15430\Box<list<int>>', $s);
+}
+
+function shape(): void
+{
+	$s = new Box(['a' => 1]);
+	repeat(5, function () use ($s): void {
+		$s->set(['a' => $s->get()['a'] + 1]);
+	});
+	assertType('Bug15430\Box<non-empty-array<string, int>>', $s);
+}
+
+function writtenBackUnchanged(): void
+{
+	$b = new Box(0);
+	$b->set($b->get());
+	assertType('Bug15430\Box<0>', $b);
+}

tests/PHPStan/Analyser/nsrt/template-argument-multiple-sites.php

@@ -205,7 +205,7 @@ function covariantIntoInvariantInferred(): void
 	$z = collectBoxes($a, $b);
 	$z->add(3);
 	assertType('TemplateArgumentMultipleSites\Box<1>', $a);
-	assertType('TemplateArgumentMultipleSites\Coll<1|2|3>', $z);
+	assertType('TemplateArgumentMultipleSites\Coll<int>', $z);
 }
 
 function invariantIntoCovariant(): void

tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php

@@ -4560,6 +4560,15 @@ public function testBug15251(): void
 		$this->analyse([__DIR__ . '/data/bug-15251.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.0.0')]
+	public function testBug15430(): void
+	{
+		$this->checkThisOnly = false;
+		$this->checkNullables = true;
+		$this->checkUnionTypes = true;
+		$this->analyse([__DIR__ . '/data/bug-15430.php'], []);
+	}
+
 	#[RequiresPhp('>= 8.0.0')]
 	public function testBug12820(): void
 	{

tests/PHPStan/Rules/Methods/data/bug-15430.php

@@ -0,0 +1,49 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug15430Rule;
+
+
+/** @template T */
+final class Box
+{
+	/** @param T $value */
+	public function __construct(private mixed $value)
+	{
+	}
+
+	/** @return T */
+	public function get(): mixed
+	{
+		  return $this->value;
+	}
+
+	/** @param T $value */
+	public function set(mixed $value): void
+	{
+		  $this->value = $value;
+	}
+}
+
+/** @param callable(): void $callback */
+function repeat(int $times, callable $callback): void
+{
+	for ($i = 0; $i < $times; $i++) {
+		$callback();
+	}
+}
+
+function test(): void
+{
+	$count = new Box(0);
+
+	repeat(5, function () use ($count): void {
+		  $count->set($count->get() + 1);
+	});
+
+
+	if ($count->get() === 5) {
+		  echo 'reached at runtime';
+	}
+}