Fix phpstan/phpstan#14188: Preserve template type when narrowing class-string parameter

- Modified NewHandler::resolveType() to intersect the template type from the
  parameter's declared class-string<T> type with the concrete object type when
  evaluating `new $class()` after the class-string has been narrowed
- Added rule regression test in tests/PHPStan/Rules/Methods/data/bug-14188.php
- Added NSRT test in tests/PHPStan/Analyser/nsrt/bug-14188.php
- Root cause: when class-string<T> is narrowed via === to a constant class string,
  `new $class()` lost the template type T and returned a plain ObjectType, causing
  the return type check to report a false positive "breaks the contract" error

Author: phpstan-bot

src/Analyser/ExprHandler/NewHandler.php

@@ -53,6 +53,7 @@
 use function array_map;
 use function array_merge;
 use function count;
+use function is_string;
 use function sprintf;
 
 /**
@@ -308,7 +309,39 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type
 		}
 
 		$exprType = $scope->getType($expr->class);
-		return $exprType->getObjectTypeOrClassStringObjectType();
+		$objectType = $exprType->getObjectTypeOrClassStringObjectType();
+
+		// When $class has been narrowed from class-string<T> to a concrete class string,
+		// preserve the template type relationship by intersecting with the template type.
+		// This ensures that `new $class()` is still compatible with return type T.
+		if (
+			$expr->class instanceof Expr\Variable
+			&& is_string($expr->class->name)
+			&& !$objectType->hasTemplateOrLateResolvableType()
+		) {
+			$function = $scope->getFunction();
+			if ($function !== null) {
+				foreach ($function->getParameters() as $param) {
+					if ($param->getName() !== $expr->class->name) {
+						continue;
+					}
+					$paramType = $param->getType();
+					if (!$paramType->isClassString()->yes()) {
+						break;
+					}
+					$classStringObjectType = $paramType->getClassStringObjectType();
+					if (!$classStringObjectType instanceof TemplateType) {
+						break;
+					}
+					if ($classStringObjectType->getBound()->isSuperTypeOf($objectType)->yes()) {
+						$objectType = TypeCombinator::intersect($classStringObjectType, $objectType);
+					}
+					break;
+				}
+			}
+		}
+
+		return $objectType;
 	}
 
 	private function exactInstantiation(MutatingScope $scope, New_ $node, Name $className): Type

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

@@ -0,0 +1,28 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14188Nsrt;
+
+use function PHPStan\Testing\assertType;
+
+interface MyInterface {}
+class A implements MyInterface {}
+class B implements MyInterface {}
+
+class MyFactory {
+	/**
+	 * @template T of MyInterface
+	 *
+	 * @param class-string<T> $class
+	 *
+	 * @return T
+	 */
+	public function create(string $class) {
+		if ($class === A::class) {
+			assertType("'Bug14188Nsrt\\\\A'", $class);
+			assertType('Bug14188Nsrt\A&T of Bug14188Nsrt\MyInterface (method Bug14188Nsrt\MyFactory::create(), argument)', new $class());
+			return new $class();
+		}
+
+		return new $class();
+	}
+}

tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php

@@ -1310,4 +1310,9 @@ public function testBug9669(): void
 		$this->analyse([__DIR__ . '/data/bug-9669.php'], []);
 	}
 
+	public function testBug14188(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-14188.php'], []);
+	}
+
 }

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

@@ -0,0 +1,24 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14188;
+
+interface MyInterface {}
+class A implements MyInterface {}
+class B implements MyInterface {}
+
+class MyFactory {
+	/**
+	 * @template T of MyInterface
+	 *
+	 * @param class-string<T> $class
+	 *
+	 * @return T
+	 */
+	public function create(string $class) {
+		if ($class === A::class) {
+			return new $class();
+		}
+
+		return new $class();
+	}
+}