rework

Author: staabm

src/Php/PhpVersions.php

@@ -43,4 +43,9 @@ public function supportsNamedArgumentAfterUnpackedArgument(): TrinaryLogic
 		return IntegerRangeType::fromInterval(80100, null)->isSuperTypeOf($this->phpVersions)->result;
 	}
 
+	public function supportsTrueAndFalseStandaloneType(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80200, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
 }

src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php

@@ -31,15 +31,16 @@ public function processNode(Node $node, Scope $scope): array
 	{
 		$function = $node->getFunctionReflection();
 
-		$functionReturnType = $function->getReturnType();
 		return $this->check->checkFunction(
 			$node,
-			$functionReturnType,
+			$function->getReturnType(),
+			$function->getPhpDocReturnType(),
 			sprintf(
 				'Function %s()',
 				$function->getName(),
 			),
 			false,
+			$scope,
 		);
 	}
 

src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php

@@ -49,16 +49,17 @@ public function processNode(Node $node, Scope $scope): array
 			}
 		}
 
-		$methodReturnType = $method->getReturnType();
 		return $this->check->checkFunction(
 			$node,
-			$methodReturnType,
+			$method->getReturnType(),
+			$method->getPhpDocReturnType(),
 			sprintf(
 				'Method %s::%s()',
 				$method->getDeclaringClass()->getDisplayName(),
 				$method->getName(),
 			),
 			!$isFirstDeclaration && !$method->isPrivate(),
+			$scope,
 		);
 	}
 

src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php

@@ -4,15 +4,13 @@
 
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
-use PHPStan\DependencyInjection\AutowiredParameter;
 use PHPStan\DependencyInjection\RegisteredRule;
 use PHPStan\Node\ClassPropertiesNode;
 use PHPStan\Reflection\PropertyReflection;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\UnionType;
 use function count;
 use function sprintf;
 
@@ -27,8 +25,6 @@ public function __construct(
 		private ReadWritePropertiesExtensionProvider $extensionProvider,
 		private PropertyReflectionFinder $propertyReflectionFinder,
 		private TooWideTypeCheck $check,
-		#[AutowiredParameter(ref: '%featureToggles.reportTooWideBool%')]
-		private bool $reportTooWideBool,
 	)
 	{
 	}
@@ -60,11 +56,13 @@ public function processNode(Node $node, Scope $scope): array
 
 			$propertyReflection = $classReflection->getNativeProperty($propertyName);
 			$propertyType = $propertyReflection->getWritableType();
-			if (!$propertyType instanceof UnionType) {
-				if (!$propertyType->isBoolean()->yes() || !$this->reportTooWideBool) {
-					continue;
-				}
+			$phpdocType = $propertyReflection->getPhpDocType();
+
+			$propertyType = $this->check->findTypeToCheck($propertyType, $phpdocType, $scope);
+			if ($propertyType === null) {
+				continue;
 			}
+
 			foreach ($this->extensionProvider->getExtensions() as $extension) {
 				if ($extension->isAlwaysRead($propertyReflection, $propertyName)) {
 					continue 2;

src/Rules/TooWideTypehints/TooWideTypeCheck.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Rules\TooWideTypehints;
 
+use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredParameter;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Node\ClassPropertyNode;
@@ -11,6 +12,7 @@
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypehintHelper;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
@@ -71,18 +73,18 @@ public function checkProperty(
 	 */
 	public function checkFunction(
 		MethodReturnStatementsNode|FunctionReturnStatementsNode $node,
-		Type $functionReturnType,
+		Type $nativeFunctionReturnType,
+		Type $phpdocFunctionReturnType,
 		string $functionDescription,
 		bool $checkDescendantClass,
+		Scope $scope,
 	): array
 	{
-		$functionReturnType = TypeUtils::resolveLateResolvableTypes($functionReturnType);
-
-		if (!$functionReturnType instanceof UnionType) {
-			if (!$functionReturnType->isBoolean()->yes() || !$this->reportTooWideBool) {
-				return [];
-			}
+		$functionReturnType = $this->findTypeToCheck($nativeFunctionReturnType, $phpdocFunctionReturnType, $scope);
+		if ($functionReturnType === null) {
+			return [];
 		}
+
 		$statementResult = $node->getStatementResult();
 		if ($statementResult->hasYield()) {
 			return [];
@@ -178,4 +180,46 @@ public function checkAnonymousFunction(
 		return $messages;
 	}
 
+	/**
+	 * Returns null when type should not be checked, e.g. because it would be too annoying.
+	 */
+	public function findTypeToCheck(
+		Type $nativeType,
+		Type $phpdocType,
+		Scope $scope,
+	): ?Type
+	{
+		$combinedType = TypeUtils::resolveLateResolvableTypes(TypehintHelper::decideType($nativeType, $phpdocType));
+		if ($combinedType instanceof UnionType) {
+			return $combinedType;
+		}
+
+		if (!$this->reportTooWideBool) {
+			return null;
+		}
+
+		if (
+			$phpdocType->isBoolean()->yes()
+		) {
+			if (
+				!$phpdocType->isTrue()->yes()
+				&& !$phpdocType->isFalse()->yes()
+			) {
+				return $combinedType;
+			}
+		} elseif (
+			$scope->getPhpVersion()->supportsTrueAndFalseStandaloneType()->yes()
+			&& $nativeType->isBoolean()->yes()
+		) {
+			if (
+				!$nativeType->isTrue()->yes()
+				&& !$nativeType->isFalse()->yes()
+			) {
+				return $combinedType;
+			}
+		}
+
+		return null;
+	}
+
 }

tests/PHPStan/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRuleTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
 
 /**
  * @extends RuleTestCase<TooWideFunctionReturnTypehintRule>
@@ -68,7 +69,8 @@ public function testBug10312a(): void
 		$this->analyse([__DIR__ . '/data/bug-10312a.php'], []);
 	}
 
-	public function testBug13384c(): void
+	#[RequiresPhp('>= 8.2')]
+	public function testBug13384cPhp82(): void
 	{
 		$this->reportTooWideBool = true;
 		$this->analyse([__DIR__ . '/data/bug-13384c.php'], [
@@ -80,6 +82,30 @@ public function testBug13384c(): void
 				'Function Bug13384c\doFoo2() never returns false so it can be removed from the return type.',
 				9,
 			],
+			[
+				'Function Bug13384c\doFooPhpdoc() never returns false so it can be removed from the return type.',
+				93,
+			],
+			[
+				'Function Bug13384c\doFooPhpdoc2() never returns true so it can be removed from the return type.',
+				100,
+			],
+		]);
+	}
+
+	#[RequiresPhp('< 8.2')]
+	public function testBug13384cPrePhp82(): void
+	{
+		$this->reportTooWideBool = true;
+		$this->analyse([__DIR__ . '/data/bug-13384c.php'], [
+			[
+				'Function Bug13384c\doFooPhpdoc() never returns false so it can be removed from the return type.',
+				93,
+			],
+			[
+				'Function Bug13384c\doFooPhpdoc2() never returns true so it can be removed from the return type.',
+				100,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/TooWideTypehints/TooWideMethodReturnTypehintRuleTest.php

@@ -220,6 +220,7 @@ public function testBug10312d(): void
 		$this->analyse([__DIR__ . '/data/bug-10312d.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.2')]
 	public function testBug13384c(): void
 	{
 		$this->reportTooWideBool = true;
@@ -232,13 +233,37 @@ public function testBug13384c(): void
 				'Method Bug13384c\Bug13384c::doBar2() never returns false so it can be removed from the return type.',
 				37,
 			],
+			[
+				'Method Bug13384c\Bug13384c::doBarPhpdoc() never returns false so it can be removed from the return type.',
+				55,
+			],
 			[
 				'Method Bug13384c\Bug13384Static::doBar() never returns true so it can be removed from the return type.',
-				50,
+				62,
 			],
 			[
 				'Method Bug13384c\Bug13384Static::doBar2() never returns false so it can be removed from the return type.',
-				54,
+				66,
+			],
+			[
+				'Method Bug13384c\Bug13384Static::doBarPhpdoc() never returns false so it can be removed from the return type.',
+				84,
+			],
+		]);
+	}
+
+	#[RequiresPhp('< 8.2')]
+	public function testBug13384cPrePhp82(): void
+	{
+		$this->reportTooWideBool = true;
+		$this->analyse([__DIR__ . '/data/bug-13384c.php'], [
+			[
+				'Method Bug13384c\Bug13384c::doBarPhpdoc() never returns false so it can be removed from the return type.',
+				55,
+			],
+			[
+				'Method Bug13384c\Bug13384Static::doBarPhpdoc() never returns false so it can be removed from the return type.',
+				84,
 			],
 		]);
 	}

tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php

@@ -22,7 +22,6 @@ protected function getRule(): Rule
 			new DirectReadWritePropertiesExtensionProvider([]),
 			new PropertyReflectionFinder(),
 			new TooWideTypeCheck($this->reportTooWideBool),
-			$this->reportTooWideBool,
 		);
 	}
 

tests/PHPStan/Rules/TooWideTypehints/data/bug-13384c.php

@@ -44,6 +44,18 @@ private function doBar3(): bool {
 		}
 		return false;
 	}
+
+	private function doBarMixed() {
+		return true;
+	}
+
+	/**
+	 * @return bool
+	 */
+	private function doBarPhpdoc() {
+		return true;
+	}
+
 }
 
 class Bug13384Static {
@@ -61,4 +73,34 @@ private static function doBar3(): bool {
 		}
 		return false;
 	}
+
+	private static function doBarMixed() {
+		return true;
+	}
+
+	/**
+	 * @return bool
+	 */
+	private static function doBarPhpdoc() {
+		return true;
+	}
+
+}
+
+/**
+ * @return bool
+ */
+function doFooPhpdoc() {
+	return true;
+}
+
+/**
+ * @return bool
+ */
+function doFooPhpdoc2() {
+	return false;
+}
+
+function doFooMixed() {
+	return true;
 }