Fix phpstan/phpstan#11430: Two unbounded generics in conditional return are assumed to be always the same (#5336)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: 3 people

src/Type/Generic/TemplateTypeTrait.php

@@ -368,6 +368,10 @@ public function traverseSimultaneously(Type $right, callable $cb): Type
 
 	public function tryRemove(Type $typeToRemove): ?Type
 	{
+		if ($typeToRemove instanceof TemplateType) {
+			return null;
+		}
+
 		$bound = TypeCombinator::remove($this->getBound(), $typeToRemove);
 		if ($this->getBound() === $bound) {
 			return null;

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

@@ -0,0 +1,98 @@
+<?php declare(strict_types = 1);
+
+namespace Bug11430Methods;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template T
+ *
+ * @implements \IteratorAggregate<T>
+ */
+abstract class Option  implements \IteratorAggregate
+{
+    /**
+     * @template S
+	 * @template U
+     *
+     * @param S $value     The actual return value.
+     * @param U $noneValue The value which should be considered "None"; null by
+     *                     default.
+     *
+     * @return (S is U ? None : Option<S>)
+     */
+    public static function fromValue($value, $noneValue = null)
+    {
+        if ($value === $noneValue) {
+            return None::create();
+		}
+
+        return new Some($value);
+    }
+}
+
+/**
+ * @extends Option<mixed>
+ */
+final class None extends Option
+{
+    /** @var None|null */
+    private static $instance;
+
+    /**
+     * @return None
+     */
+    public static function create(): self
+    {
+        if (null === self::$instance) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
+	public function getIterator(): \EmptyIterator
+    {
+        return new \EmptyIterator();
+    }
+}
+
+/**
+ * @template T
+ *
+ * @extends Option<T>
+ */
+final class Some extends Option
+{
+    /** @var T */
+    private $value;
+
+    /**
+     * @param T $value
+     */
+    public function __construct($value)
+    {
+        $this->value = $value;
+    }
+
+	/**
+     * @return \ArrayIterator<int, T>
+     */
+    public function getIterator(): \ArrayIterator
+    {
+        return new \ArrayIterator([$this->value]);
+    }
+}
+
+
+class Test
+{
+	/** @var Option<string> */
+	public Option $name;
+}
+
+$test = new Test();
+/** @var ?string $foo */
+$foo = null;
+$test->name = Option::fromValue($foo);
+assertType('Bug11430Methods\Option<string>', $test->name);

tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php

@@ -1326,4 +1326,9 @@ public function testBug10924(): void
 		$this->analyse([__DIR__ . '/data/bug-10924.php'], []);
 	}
 
+	public function testBug11430(): void
+	{
+		$this->analyse([__DIR__ . '/../../Analyser/nsrt/bug-11430.php'], []);
+	}
+
 }

tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php

@@ -309,4 +309,10 @@ public function testBug13676(): void
 		$this->analyse([__DIR__ . '/data/bug-13676.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.2')]
+	public function testBug11430(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-11430.php'], []);
+	}
+
 }

tests/PHPStan/Rules/TooWideTypehints/data/bug-11430.php

@@ -0,0 +1,51 @@
+<?php // lint >= 8.2
+
+declare(strict_types = 1);
+
+namespace Bug11430;
+
+/**
+ * @template T
+ */
+interface Option {}
+
+/**
+ * @template T
+ * @implements Option<T>
+ */
+class Some implements Option
+{
+	/**
+	 * @param T $value
+	 */
+	public function __construct(public mixed $value) {}
+}
+
+/**
+ * @implements Option<never>
+ */
+class None implements Option {}
+
+/**
+ * @internal
+ */
+final class Choice
+{
+	/**
+	 * @template T
+	 * @template S
+	 *
+	 * @param T $value
+	 * @param S $none
+	 *
+	 * @return (T is S ? None : Some<T>)
+	 */
+	public static function from(mixed $value, mixed $none = null): Option
+	{
+		if ($value === $none) {
+			return new None();
+		}
+
+		return new Some($value);
+	}
+}