Fix false positive comparing identical generic types below level 8

RuleLevelHelper relaxes the nullability of the accepted type but not of
the accepting one, which is what lets a nullable value be passed where a
non-nullable one is expected below level 8. TypeTraverser applied that
relaxation to generic type arguments as well, so the argument of an
accepted Collection<string, int|null> became int while the accepting side
kept int|null. Compared invariantly, two identical types then stopped
matching and the reported message printed the same type on both sides.

Map the arguments of a concrete generic type instead of feeding them
through the relaxation. A template type keeps going through the regular
traversal, as rebuilding it as a plain generic would lose its bound.

Author: calebdw

phpstan-baseline.neon

@@ -708,6 +708,12 @@ parameters:
 			count: 2
 			path: src/Rules/RuleErrorBuilder.php
 
+		-
+			rawMessage: Doing instanceof PHPStan\Type\Generic\GenericObjectType is error-prone and deprecated.
+			identifier: phpstanApi.instanceofType
+			count: 1
+			path: src/Rules/RuleLevelHelper.php
+
 		-
 			rawMessage: Doing instanceof PHPStan\Type\IntersectionType is error-prone and deprecated.
 			identifier: phpstanApi.instanceofType

src/Rules/RuleLevelHelper.php

@@ -11,7 +11,9 @@
 use PHPStan\Type\CallableType;
 use PHPStan\Type\ClosureType;
 use PHPStan\Type\ErrorType;
+use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\Generic\TemplateMixedType;
+use PHPStan\Type\Generic\TemplateType;
 use PHPStan\Type\IntersectionType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
@@ -49,6 +51,57 @@ public function __construct(
 	{
 	}
 
+	/**
+	 * A callable return type is traversed directly instead of going through the
+	 * mapper, so a generic one needs the same handling here.
+	 *
+	 * @param callable(Type): Type $traverse
+	 */
+	private function traverseNestedType(Type $type, callable $traverse): Type
+	{
+		if ($this->isConcreteGenericObjectType($type)) {
+			return $this->traverseGenericObjectType($type, $traverse);
+		}
+
+		return $traverse($type);
+	}
+
+	/**
+	 * A template type is compared through its bound, and rebuilding it as a
+	 * plain generic would lose that, so only a concrete generic gets its
+	 * arguments mapped explicitly.
+	 *
+	 * @phpstan-assert-if-true GenericObjectType $type
+	 */
+	private function isConcreteGenericObjectType(Type $type): bool
+	{
+		return $type instanceof GenericObjectType && !$type instanceof TemplateType;
+	}
+
+	/**
+	 * The accepted type gets its nullability relaxed below level 8, but the
+	 * accepting type does not. Doing that to a generic argument compared
+	 * invariantly turns an otherwise identical pair into a mismatch, so map the
+	 * arguments themselves instead of feeding them through the relaxation.
+	 *
+	 * @param callable(Type): Type $traverse
+	 */
+	private function traverseGenericObjectType(GenericObjectType $type, callable $traverse): Type
+	{
+		$types = [];
+		foreach ($type->getTypes() as $innerType) {
+			$types[] = $traverse($innerType);
+		}
+
+		return new GenericObjectType(
+			$type->getClassName(),
+			$types,
+			$type->getSubtractedType(),
+			$type->getClassReflection(),
+			$type->getVariances(),
+		);
+	}
+
 	/** @api */
 	public function isThis(Expr $expression): bool
 	{
@@ -95,7 +148,7 @@ private function transformAcceptedType(Type $acceptingType, Type $acceptedType):
 
 				return new CallableType(
 					$acceptedType->getParameters(),
-					$traverse($acceptedType->getReturnType()),
+					$this->traverseNestedType($acceptedType->getReturnType(), $traverse),
 					$acceptedType->isVariadic(),
 					$acceptedType->getTemplateTypeMap(),
 					$acceptedType->getResolvedTemplateTypeMap(),
@@ -111,7 +164,7 @@ private function transformAcceptedType(Type $acceptingType, Type $acceptedType):
 
 				return new ClosureType(
 					$acceptedType->getParameters(),
-					$traverse($acceptedType->getReturnType()),
+					$this->traverseNestedType($acceptedType->getReturnType(), $traverse),
 					$acceptedType->isVariadic(),
 					$acceptedType->getTemplateTypeMap(),
 					$acceptedType->getResolvedTemplateTypeMap(),
@@ -127,6 +180,10 @@ private function transformAcceptedType(Type $acceptingType, Type $acceptedType):
 				);
 			}
 
+			if ($this->isConcreteGenericObjectType($acceptedType)) {
+				return $this->traverseGenericObjectType($acceptedType, $traverse);
+			}
+
 			if (
 				!$this->checkNullables
 				&& !$acceptingType instanceof NullType

tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php

@@ -3014,6 +3014,21 @@ public function testCallablesWithoutCheckNullables(bool $checkNullables, bool $c
 		$this->analyse([__DIR__ . '/data/callables-without-check-nullables.php'], $expectedErrors);
 	}
 
+	public static function dataGenericArgumentNullability(): iterable
+	{
+		yield [false];
+		yield [true];
+	}
+
+	#[DataProvider('dataGenericArgumentNullability')]
+	public function testGenericArgumentNullability(bool $checkNullables): void
+	{
+		$this->checkThisOnly = false;
+		$this->checkNullables = $checkNullables;
+		$this->checkUnionTypes = true;
+		$this->analyse([__DIR__ . '/data/generic-argument-nullability.php'], []);
+	}
+
 	#[RequiresPhp('>= 8.0.0')]
 	public function testBug8713(): void
 	{

tests/PHPStan/Rules/Methods/data/generic-argument-nullability.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+namespace GenericArgumentNullability;
+
+/**
+ * @template TKey of array-key
+ * @template TValue
+ */
+class Collection
+{
+
+}
+
+class Foo
+{
+
+	/**
+	 * @template T
+	 * @param callable(): T $cb
+	 * @return T
+	 */
+	public function grab(callable $cb)
+	{
+		return $cb();
+	}
+
+	/**
+	 * @template T
+	 * @param callable(mixed, array<string, mixed>): T $cb
+	 * @return T
+	 */
+	public function grabTwoArgs(callable $cb)
+	{
+		return $cb(null, []);
+	}
+
+	/** @param Collection<string, int|null> $collection */
+	public function acceptNullable(Collection $collection): void
+	{
+	}
+
+}
+
+/**
+ * @param Collection<string, int> $plain
+ * @param Collection<string, int|null> $nullable
+ * @param array<string, int|null> $array
+ */
+function test(Foo $foo, Collection $plain, Collection $nullable, array $array, ?int $scalar): void
+{
+	$foo->grab(fn () => $plain);
+	$foo->grab(fn () => $nullable);
+	$foo->grab(fn () => $array);
+	$foo->grab(fn () => $scalar);
+	$foo->grabTwoArgs(fn () => $nullable);
+	$foo->acceptNullable($nullable);
+}