Refactor TooWideTypeCheck - report errors based on narrowed original type

Author: ondrejmirtes

src/Rules/TooWideTypehints/TooWideFunctionReturnTypehintRule.php

@@ -31,9 +31,9 @@ public function processNode(Node $node, Scope $scope): array
 	{
 		$function = $node->getFunctionReflection();
 
-		return $this->check->checkFunction(
+		return $this->check->checkFunctionReturnType(
 			$node,
-			$function->getReturnType(),
+			$function->getNativeReturnType(),
 			$function->getPhpDocReturnType(),
 			sprintf(
 				'Function %s()',

src/Rules/TooWideTypehints/TooWideMethodReturnTypehintRule.php

@@ -49,9 +49,9 @@ public function processNode(Node $node, Scope $scope): array
 			}
 		}
 
-		return $this->check->checkFunction(
+		return $this->check->checkFunctionReturnType(
 			$node,
-			$method->getReturnType(),
+			$method->getNativeReturnType(),
 			$method->getPhpDocReturnType(),
 			sprintf(
 				'Method %s::%s()',

src/Rules/TooWideTypehints/TooWideParameterOutTypeCheck.php

@@ -19,6 +19,12 @@
 final class TooWideParameterOutTypeCheck
 {
 
+	public function __construct(
+		private TooWideTypeCheck $tooWideTypeCheck,
+	)
+	{
+	}
+
 	/**
 	 * @param list<ExecutionEndNode> $executionEnds
 	 * @param list<ReturnStatement> $returnStatements
@@ -86,35 +92,24 @@ private function processSingleParameter(
 			$outType = $parameter->getType();
 		}
 
-		$outType = TypeUtils::resolveLateResolvableTypes($outType);
-		if (!$outType instanceof UnionType) {
-			return [];
-		}
-
 		$variableExpr = new Variable($parameter->getName());
 		$variableType = $scope->getType($variableExpr);
 
-		$messages = [];
-		foreach ($outType->getTypes() as $type) {
-			if (!$type->isSuperTypeOf($variableType)->no()) {
-				continue;
-			}
-
-			$errorBuilder = RuleErrorBuilder::message(sprintf(
+		/* sprintf(
 				'%s never assigns %s to &$%s so it can be removed from the %s.',
 				$functionDescription,
 				$type->describe(VerbosityLevel::getRecommendedLevelByType($type)),
 				$parameter->getName(),
 				$isParamOutType ? '@param-out type' : 'by-ref type',
-			))->identifier(sprintf('%s.unusedType', $isParamOutType ? 'paramOut' : 'parameterByRef'));
-			if (!$isParamOutType) {
-				$errorBuilder->tip('You can narrow the parameter out type with @param-out PHPDoc tag.');
-			}
-
-			$messages[] = $errorBuilder->build();
-		}
-
-		return $messages;
+			) */
+
+		return $this->tooWideTypeCheck->checkParameterOutType(
+			$outType,
+			$variableType,
+			$scope,
+			$isParamOutType ? 'paramOut' : 'parameterByRef',
+			$isParamOutType ? null : 'You can narrow the parameter out type with @param-out PHPDoc tag.',
+		);
 	}
 
 }

src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php

@@ -7,11 +7,8 @@
 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 function count;
 use function sprintf;
 
 /**
@@ -23,7 +20,6 @@ final class TooWidePropertyTypeRule implements Rule
 
 	public function __construct(
 		private ReadWritePropertiesExtensionProvider $extensionProvider,
-		private PropertyReflectionFinder $propertyReflectionFinder,
 		private TooWideTypeCheck $check,
 	)
 	{
@@ -55,13 +51,6 @@ public function processNode(Node $node, Scope $scope): array
 			}
 
 			$propertyReflection = $classReflection->getNativeProperty($propertyName);
-			$propertyType = $propertyReflection->getWritableType();
-			$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)) {
@@ -75,33 +64,17 @@ public function processNode(Node $node, Scope $scope): array
 				}
 			}
 
-			$assignedTypes = [];
-			foreach ($node->getPropertyAssigns() as $assign) {
-				$assignNode = $assign->getAssign();
-				$assignPropertyReflections = $this->propertyReflectionFinder->findPropertyReflectionsFromNode($assignNode->getPropertyFetch(), $assign->getScope());
-				foreach ($assignPropertyReflections as $assignPropertyReflection) {
-					if ($propertyName !== $assignPropertyReflection->getName()) {
-						continue;
-					}
-					if ($propertyReflection->getDeclaringClass()->getName() !== $assignPropertyReflection->getDeclaringClass()->getName()) {
-						continue;
-					}
-
-					$assignedTypes[] = $assignPropertyReflection->getScope()->getType($assignNode->getAssignedExpr());
-				}
-			}
-
-			if ($property->getDefault() !== null) {
-				$assignedTypes[] = $scope->getType($property->getDefault());
-			}
-
-			if (count($assignedTypes) === 0) {
-				continue;
-			}
-
-			$assignedType = TypeCombinator::union(...$assignedTypes);
 			$propertyDescription = $this->describePropertyByName($propertyReflection, $propertyName);
-			foreach ($this->check->checkProperty($property, $propertyType, $propertyDescription, $assignedType) as $error) {
+			$propertyErrors = $this->check->checkProperty(
+				$property,
+				$propertyReflection->getDeclaringClass(),
+				$node->getPropertyAssigns(),
+				$propertyReflection->getNativeType(),
+				$propertyReflection->getPhpDocType(),
+				$propertyDescription,
+				$scope,
+			);
+			foreach ($propertyErrors as $error) {
 				$errors[] = $error;
 			}
 		}