Use tentative return types of built-in methods as native return types

Amp-Thread-ID: https://ampcode.com/threads/T-01a179f2-995f-7745-8d8c-4c174ba5c0ce

Author: ondrejmirtes

src/Reflection/SignatureMap/Php8SignatureMapProvider.php

@@ -195,6 +195,64 @@ public function hasFunctionSignature(string $name): bool
 	}
 
 	public function getMethodSignatures(string $className, string $methodName, ?ReflectionMethod $reflectionMethod): array
+	{
+		return $this->applyTentativeReturnType(
+			$className,
+			$reflectionMethod,
+			$this->getMethodSignaturesWithoutTentativeReturnType($className, $methodName, $reflectionMethod),
+		);
+	}
+
+	/**
+	 * PHP checks a tentative return type of a built-in method like a real one,
+	 * and overriding it with an incompatible type is deprecated,
+	 * so it is used as the native return type when the signature does not have one.
+	 *
+	 * @param array{positional: array<int, FunctionSignature>, named: ?array<int, FunctionSignature>} $signatures
+	 * @return array{positional: array<int, FunctionSignature>, named: ?array<int, FunctionSignature>}
+	 */
+	private function applyTentativeReturnType(string $className, ?ReflectionMethod $reflectionMethod, array $signatures): array
+	{
+		if ($reflectionMethod === null || !$this->phpVersion->hasTentativeReturnTypes()) {
+			return $signatures;
+		}
+
+		$tentativeReturnType = $reflectionMethod->getTentativeReturnType();
+		if ($tentativeReturnType === null) {
+			return $signatures;
+		}
+
+		$nativeReturnType = TypehintHelper::decideTypeFromReflection(
+			$tentativeReturnType,
+			selfClass: $this->reflectionProviderProvider->getReflectionProvider()->getClass($className),
+		);
+		foreach ($signatures as $signatureType => $typeSignatures) {
+			if ($typeSignatures === null) {
+				continue;
+			}
+
+			foreach ($typeSignatures as $i => $signature) {
+				$signatureNativeReturnType = $signature->getNativeReturnType();
+				if (!$signatureNativeReturnType instanceof MixedType || $signatureNativeReturnType->isExplicitMixed()) {
+					continue;
+				}
+
+				$signatures[$signatureType][$i] = new FunctionSignature(
+					$signature->getParameters(),
+					$signature->getReturnType(),
+					$nativeReturnType,
+					$signature->isVariadic(),
+				);
+			}
+		}
+
+		return $signatures;
+	}
+
+	/**
+	 * @return array{positional: array<int, FunctionSignature>, named: ?array<int, FunctionSignature>}
+	 */
+	private function getMethodSignaturesWithoutTentativeReturnType(string $className, string $methodName, ?ReflectionMethod $reflectionMethod): array
 	{
 		$lowerClassName = strtolower($className);
 		if (!array_key_exists($lowerClassName, $this->map->classes)) {

src/Rules/Methods/OverridingMethodRule.php

@@ -274,6 +274,9 @@ public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataE
 			$reportReturnType = !$realPrototype instanceof MethodPrototypeReflection
 				|| $realPrototype->getTentativeReturnType() === null
 				|| (is_bool($prototype->isBuiltin()) ? !$prototype->isBuiltin() : $prototype->isBuiltin()->no());
+		} elseif ($realPrototype instanceof MethodPrototypeReflection && $realPrototype->getTentativeReturnType() !== null) {
+			// return types that are only tentative are not checked before PHP 8.1
+			$reportReturnType = false;
 		} else {
 			if ($realPrototype instanceof MethodPrototypeReflection && $realPrototype->isInternal()) {
 				if (

tests/PHPStan/Analyser/nsrt/tentative-return-type-native.php

@@ -0,0 +1,46 @@
+<?php // lint >= 8.1
+
+namespace TentativeReturnTypeNative;
+
+use function PHPStan\Testing\assertNativeType;
+use function PHPStan\Testing\assertType;
+
+/**
+ * @extends \ArrayObject<int, string>
+ */
+class MyArrayObject extends \ArrayObject
+{
+
+}
+
+/**
+ * @implements \IteratorAggregate<int, string>
+ */
+class MyAggregate implements \IteratorAggregate
+{
+
+	#[\ReturnTypeWillChange]
+	public function getIterator()
+	{
+		return new \ArrayIterator([]);
+	}
+
+}
+
+class Foo
+{
+
+	/**
+	 * @param \ArrayObject<int, string> $arrayObject
+	 */
+	public function doFoo(\ArrayObject $arrayObject, MyArrayObject $myArrayObject, \DateTimeImmutable $date, \SplObjectStorage $storage, MyAggregate $aggregate): void
+	{
+		assertType('int<0, max>', $arrayObject->count());
+		assertNativeType('int', $arrayObject->count());
+		assertNativeType('int', $myArrayObject->count());
+		assertNativeType('int', $date->getTimestamp());
+		assertNativeType('string', $storage->getHash(new \stdClass()));
+		assertNativeType('mixed', $aggregate->getIterator());
+	}
+
+}

tests/PHPStan/Rules/Comparison/IfConstantConditionRuleTest.php

@@ -6,6 +6,7 @@
 use PHPStan\Testing\CompositeRule;
 use PHPStan\Testing\RuleTestCase;
 use PHPUnit\Framework\Attributes\RequiresPhp;
+use const PHP_VERSION_ID;
 
 /**
  * @extends RuleTestCase<CompositeRule>
@@ -151,12 +152,16 @@ public function testReportPhpDoc(): void
 	public function testBug4043(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
+		$assertError = [
+			'Call to function assert() with true will always evaluate to true.',
+			13,
+		];
+		if (PHP_VERSION_ID < 80100) {
+			// tentative return types are native only on PHP 8.1+
+			$assertError[] = 'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.';
+		}
 		$this->analyse([__DIR__ . '/data/bug-4043.php'], [
-			[
-				'Call to function assert() with true will always evaluate to true.',
-				13,
-				'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.',
-			],
+			$assertError,
 			[
 				'If condition is always false.',
 				43,