Bleeding edge - deep inspect unresolvable types in PHPDoc

conf/config.neon

@@ -394,8 +394,6 @@ services:
 
 	-
 		class: PHPStan\PhpDoc\PhpDocNodeResolver
-		arguments:
-			deepInspectTypes: %featureToggles.deepInspectTypes%
 
 	-
 		class: PHPStan\PhpDoc\PhpDocStringResolver
@@ -848,6 +846,11 @@ services:
 	-
 		class: PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider
 
+	-
+		class: PHPStan\Rules\PhpDoc\UnresolvableTypeHelper
+		arguments:
+			deepInspectTypes: %featureToggles.deepInspectTypes%
+
 	-
 		class: PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider
 

src/PhpDoc/PhpDocNodeResolver.php

@@ -23,13 +23,11 @@
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
 use PHPStan\Reflection\PassedByReference;
-use PHPStan\Type\ErrorType;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\MixedType;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeTraverser;
 
 class PhpDocNodeResolver
 {
@@ -38,17 +36,17 @@ class PhpDocNodeResolver
 
 	private ConstExprNodeResolver $constExprNodeResolver;
 
-	private bool $deepInspectTypes;
+	private UnresolvableTypeHelper $unresolvableTypeHelper;
 
 	public function __construct(
 		TypeNodeResolver $typeNodeResolver,
 		ConstExprNodeResolver $constExprNodeResolver,
-		bool $deepInspectTypes = false
+		UnresolvableTypeHelper $unresolvableTypeHelper
 	)
 	{
 		$this->typeNodeResolver = $typeNodeResolver;
 		$this->constExprNodeResolver = $constExprNodeResolver;
-		$this->deepInspectTypes = $deepInspectTypes;
+		$this->unresolvableTypeHelper = $unresolvableTypeHelper;
 	}
 
 	/**
@@ -471,29 +469,7 @@ private function shouldSkipType(string $tagName, Type $type): bool
 			return false;
 		}
 
-		if ($this->deepInspectTypes) {
-			$shouldSkip = false;
-			TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$shouldSkip): Type {
-				if ($type instanceof ErrorType) {
-					$shouldSkip = true;
-					return $type;
-				}
-				if ($type instanceof NeverType && !$type->isExplicit()) {
-					$shouldSkip = true;
-					return $type;
-				}
-
-				return $traverse($type);
-			});
-
-			return $shouldSkip;
-		}
-
-		if ($type instanceof ErrorType) {
-			return true;
-		}
-
-		return $type instanceof NeverType && !$type->isExplicit();
+		return $this->unresolvableTypeHelper->containsUnresolvableType($type);
 	}
 
 }

src/PhpDoc/StubValidator.php

@@ -40,6 +40,7 @@
 use PHPStan\Rules\PhpDoc\IncompatiblePropertyPhpDocTypeRule;
 use PHPStan\Rules\PhpDoc\InvalidPhpDocTagValueRule;
 use PHPStan\Rules\PhpDoc\InvalidThrowsPhpDocValueRule;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Rules\Properties\ExistingClassesInPropertiesRule;
 use PHPStan\Rules\Properties\MissingPropertyTypehintRule;
 use PHPStan\Rules\Registry;
@@ -122,6 +123,7 @@ private function getRuleRegistry(Container $container): Registry
 		$classCaseSensitivityCheck = $container->getByType(ClassCaseSensitivityCheck::class);
 		$functionDefinitionCheck = $container->getByType(FunctionDefinitionCheck::class);
 		$missingTypehintCheck = $container->getByType(MissingTypehintCheck::class);
+		$unresolvableTypeHelper = $container->getByType(UnresolvableTypeHelper::class);
 
 		return new Registry([
 			// level 0
@@ -145,9 +147,10 @@ private function getRuleRegistry(Container $container): Registry
 			new TraitTemplateTypeRule($fileTypeMapper, $templateTypeCheck),
 			new IncompatiblePhpDocTypeRule(
 				$fileTypeMapper,
-				$genericObjectTypeCheck
+				$genericObjectTypeCheck,
+				$unresolvableTypeHelper
 			),
-			new IncompatiblePropertyPhpDocTypeRule($genericObjectTypeCheck),
+			new IncompatiblePropertyPhpDocTypeRule($genericObjectTypeCheck, $unresolvableTypeHelper),
 			new InvalidPhpDocTagValueRule(
 				$container->getByType(Lexer::class),
 				$container->getByType(PhpDocParser::class)

src/Rules/Classes/MixinRule.php

@@ -9,11 +9,10 @@
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Rules\MissingTypehintCheck;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
-use PHPStan\Type\ErrorType;
 use PHPStan\Type\FileTypeMapper;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\VerbosityLevel;
 
 /**
@@ -32,6 +31,8 @@ class MixinRule implements Rule
 
 	private MissingTypehintCheck $missingTypehintCheck;
 
+	private UnresolvableTypeHelper $unresolvableTypeHelper;
+
 	private bool $checkClassCaseSensitivity;
 
 	public function __construct(
@@ -40,6 +41,7 @@ public function __construct(
 		ClassCaseSensitivityCheck $classCaseSensitivityCheck,
 		GenericObjectTypeCheck $genericObjectTypeCheck,
 		MissingTypehintCheck $missingTypehintCheck,
+		UnresolvableTypeHelper $unresolvableTypeHelper,
 		bool $checkClassCaseSensitivity
 	)
 	{
@@ -48,6 +50,7 @@ public function __construct(
 		$this->classCaseSensitivityCheck = $classCaseSensitivityCheck;
 		$this->genericObjectTypeCheck = $genericObjectTypeCheck;
 		$this->missingTypehintCheck = $missingTypehintCheck;
+		$this->unresolvableTypeHelper = $unresolvableTypeHelper;
 		$this->checkClassCaseSensitivity = $checkClassCaseSensitivity;
 	}
 
@@ -85,8 +88,7 @@ public function processNode(Node $node, Scope $scope): array
 			}
 
 			if (
-				$type instanceof ErrorType
-				|| ($type instanceof NeverType && !$type->isExplicit())
+				$this->unresolvableTypeHelper->containsUnresolvableType($type)
 			) {
 				$errors[] = RuleErrorBuilder::message('PHPDoc tag @mixin contains unresolvable type.')->build();
 				continue;

src/Rules/PhpDoc/IncompatiblePhpDocTypeRule.php

@@ -8,10 +8,8 @@
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ArrayType;
-use PHPStan\Type\ErrorType;
 use PHPStan\Type\FileTypeMapper;
 use PHPStan\Type\Generic\TemplateTypeHelper;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 
@@ -25,13 +23,17 @@ class IncompatiblePhpDocTypeRule implements \PHPStan\Rules\Rule
 
 	private \PHPStan\Rules\Generics\GenericObjectTypeCheck $genericObjectTypeCheck;
 
+	private UnresolvableTypeHelper $unresolvableTypeHelper;
+
 	public function __construct(
 		FileTypeMapper $fileTypeMapper,
-		GenericObjectTypeCheck $genericObjectTypeCheck
+		GenericObjectTypeCheck $genericObjectTypeCheck,
+		UnresolvableTypeHelper $unresolvableTypeHelper
 	)
 	{
 		$this->fileTypeMapper = $fileTypeMapper;
 		$this->genericObjectTypeCheck = $genericObjectTypeCheck;
+		$this->unresolvableTypeHelper = $unresolvableTypeHelper;
 	}
 
 	public function getNodeType(): string
@@ -74,8 +76,7 @@ public function processNode(Node $node, Scope $scope): array
 				))->identifier('phpDoc.unknownParameter')->metadata(['parameterName' => $parameterName])->build();
 
 			} elseif (
-				$phpDocParamType instanceof ErrorType
-				|| ($phpDocParamType instanceof NeverType && !$phpDocParamType->isExplicit())
+				$this->unresolvableTypeHelper->containsUnresolvableType($phpDocParamType)
 			) {
 				$errors[] = RuleErrorBuilder::message(sprintf(
 					'PHPDoc tag @param for parameter $%s contains unresolvable type.',
@@ -136,8 +137,7 @@ public function processNode(Node $node, Scope $scope): array
 			$phpDocReturnType = TemplateTypeHelper::resolveToBounds($resolvedPhpDoc->getReturnTag()->getType());
 
 			if (
-				$phpDocReturnType instanceof ErrorType
-				|| ($phpDocReturnType instanceof NeverType && !$phpDocReturnType->isExplicit())
+				$this->unresolvableTypeHelper->containsUnresolvableType($phpDocReturnType)
 			) {
 				$errors[] = RuleErrorBuilder::message('PHPDoc tag @return contains unresolvable type.')->build();
 

src/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRule.php

@@ -8,8 +8,6 @@
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
-use PHPStan\Type\ErrorType;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\VerbosityLevel;
 
 /**
@@ -20,9 +18,15 @@ class IncompatiblePropertyPhpDocTypeRule implements Rule
 
 	private \PHPStan\Rules\Generics\GenericObjectTypeCheck $genericObjectTypeCheck;
 
-	public function __construct(GenericObjectTypeCheck $genericObjectTypeCheck)
+	private UnresolvableTypeHelper $unresolvableTypeHelper;
+
+	public function __construct(
+		GenericObjectTypeCheck $genericObjectTypeCheck,
+		UnresolvableTypeHelper $unresolvableTypeHelper
+	)
 	{
 		$this->genericObjectTypeCheck = $genericObjectTypeCheck;
+		$this->unresolvableTypeHelper = $unresolvableTypeHelper;
 	}
 
 	public function getNodeType(): string
@@ -51,8 +55,7 @@ public function processNode(Node $node, Scope $scope): array
 
 		$messages = [];
 		if (
-			$phpDocType instanceof ErrorType
-			|| ($phpDocType instanceof NeverType && !$phpDocType->isExplicit())
+			$this->unresolvableTypeHelper->containsUnresolvableType($phpDocType)
 		) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
 				'%s for property %s::$%s contains unresolvable type.',

src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php

@@ -11,9 +11,7 @@
 use PHPStan\Rules\MissingTypehintCheck;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
-use PHPStan\Type\ErrorType;
 use PHPStan\Type\FileTypeMapper;
-use PHPStan\Type\NeverType;
 use PHPStan\Type\VerbosityLevel;
 use function sprintf;
 
@@ -33,6 +31,8 @@ class InvalidPhpDocVarTagTypeRule implements Rule
 
 	private MissingTypehintCheck $missingTypehintCheck;
 
+	private UnresolvableTypeHelper $unresolvableTypeHelper;
+
 	private bool $checkClassCaseSensitivity;
 
 	private bool $checkMissingVarTagTypehint;
@@ -43,6 +43,7 @@ public function __construct(
 		ClassCaseSensitivityCheck $classCaseSensitivityCheck,
 		GenericObjectTypeCheck $genericObjectTypeCheck,
 		MissingTypehintCheck $missingTypehintCheck,
+		UnresolvableTypeHelper $unresolvableTypeHelper,
 		bool $checkClassCaseSensitivity,
 		bool $checkMissingVarTagTypehint
 	)
@@ -52,6 +53,7 @@ public function __construct(
 		$this->classCaseSensitivityCheck = $classCaseSensitivityCheck;
 		$this->genericObjectTypeCheck = $genericObjectTypeCheck;
 		$this->missingTypehintCheck = $missingTypehintCheck;
+		$this->unresolvableTypeHelper = $unresolvableTypeHelper;
 		$this->checkClassCaseSensitivity = $checkClassCaseSensitivity;
 		$this->checkMissingVarTagTypehint = $checkMissingVarTagTypehint;
 	}
@@ -92,8 +94,7 @@ public function processNode(Node $node, Scope $scope): array
 				$identifier .= sprintf(' for variable $%s', $name);
 			}
 			if (
-				$varTagType instanceof ErrorType
-				|| ($varTagType instanceof NeverType && !$varTagType->isExplicit())
+				$this->unresolvableTypeHelper->containsUnresolvableType($varTagType)
 			) {
 				$errors[] = RuleErrorBuilder::message(sprintf('%s contains unresolvable type.', $identifier))->line($docComment->getStartLine())->build();
 				continue;

src/Rules/PhpDoc/UnresolvableTypeHelper.php

@@ -0,0 +1,47 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\PhpDoc;
+
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\NeverType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeTraverser;
+
+class UnresolvableTypeHelper
+{
+
+	private bool $deepInspectTypes;
+
+	public function __construct(bool $deepInspectTypes)
+	{
+		$this->deepInspectTypes = $deepInspectTypes;
+	}
+
+	public function containsUnresolvableType(Type $type): bool
+	{
+		if ($this->deepInspectTypes) {
+			$containsUnresolvable = false;
+			TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$containsUnresolvable): Type {
+				if ($type instanceof ErrorType) {
+					$containsUnresolvable = true;
+					return $type;
+				}
+				if ($type instanceof NeverType && !$type->isExplicit()) {
+					$containsUnresolvable = true;
+					return $type;
+				}
+
+				return $traverse($type);
+			});
+
+			return $containsUnresolvable;
+		}
+
+		if ($type instanceof ErrorType) {
+			return true;
+		}
+
+		return $type instanceof NeverType && !$type->isExplicit();
+	}
+
+}

tests/PHPStan/Rules/Classes/MixinRuleTest.php

@@ -5,6 +5,7 @@
 use PHPStan\Rules\ClassCaseSensitivityCheck;
 use PHPStan\Rules\Generics\GenericObjectTypeCheck;
 use PHPStan\Rules\MissingTypehintCheck;
+use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper;
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 use PHPStan\Type\FileTypeMapper;
@@ -25,6 +26,7 @@ protected function getRule(): Rule
 			new ClassCaseSensitivityCheck($reflectionProvider),
 			new GenericObjectTypeCheck(),
 			new MissingTypehintCheck($reflectionProvider, true, true, true),
+			new UnresolvableTypeHelper(true),
 			true
 		);
 	}

tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php

@@ -11,11 +11,15 @@
 class IncompatiblePhpDocTypeRuleTest extends \PHPStan\Testing\RuleTestCase
 {
 
+	/** @var bool */
+	private $deepInspectTypes = false;
+
 	protected function getRule(): \PHPStan\Rules\Rule
 	{
 		return new IncompatiblePhpDocTypeRule(
 			self::getContainer()->getByType(FileTypeMapper::class),
-			new GenericObjectTypeCheck()
+			new GenericObjectTypeCheck(),
+			new UnresolvableTypeHelper($this->deepInspectTypes)
 		);
 	}
 
@@ -150,4 +154,20 @@ public function testBug4643(): void
 		$this->analyse([__DIR__ . '/data/bug-4643.php'], []);
 	}
 
+	public function testBug3753(): void
+	{
+		$this->deepInspectTypes = true;
+		$this->analyse([__DIR__ . '/data/bug-3753.php'], [
+			[
+				'PHPDoc tag @param for parameter $foo contains unresolvable type.',
+				20,
+			],
+		]);
+	}
+
+	public function testBug3753NotDeepInspectTypes(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-3753.php'], []);
+	}
+
 }