fold getRawGenericTypeAliasesUsage into getNonGenericObjectTypesWithGenericClass

shmax · shmax · commit ed1adfdbd2ee · 2026-04-15T09:25:46.000-07:00
diff --git a/src/Rules/Classes/LocalTypeAliasesCheck.php b/src/Rules/Classes/LocalTypeAliasesCheck.php
@@ -221,21 +221,6 @@ public function checkInTraitDefinitionContext(ClassReflection $reflection): arra
 					->build();
 			}
 
-			foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($resolvedType) as [$innerAliasName, $missingParams]) {
-				if ($innerAliasName === $aliasName) {
-					continue; // skip self-referential alias bodies (circular aliases are already reported separately)
-				}
-				$errors[] = RuleErrorBuilder::message(sprintf(
-					'%s %s has type alias %s with generic type alias %s but does not specify its types: %s',
-					$reflection->getClassTypeDescription(),
-					$reflection->getDisplayName(),
-					$aliasName,
-					$innerAliasName,
-					$missingParams,
-				))
-					->identifier('missingType.generics')
-					->build();
-			}
 
 			foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($resolvedType) as $callableType) {
 				$errors[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Classes/MethodTagCheck.php b/src/Rules/Classes/MethodTagCheck.php
@@ -190,18 +190,6 @@ private function checkMethodTypeInTraitDefinitionContext(ClassReflection $classR
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($type) as [$aliasName, $missingParams]) {
-			$errors[] = RuleErrorBuilder::message(sprintf(
-				'PHPDoc tag @method for method %s::%s() %s contains generic type alias %s but does not specify its types: %s',
-				$classReflection->getDisplayName(),
-				$methodName,
-				$description,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getIterableTypesWithMissingValueTypehint($type) as $iterableType) {
 			$iterableTypeDescription = $iterableType->describe(VerbosityLevel::typeOnly());
diff --git a/src/Rules/Classes/MixinCheck.php b/src/Rules/Classes/MixinCheck.php
@@ -99,15 +99,6 @@ public function checkInTraitDefinitionContext(ClassReflection $classReflection):
 					->build();
 			}
 
-			foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($type) as [$aliasName, $missingParams]) {
-				$errors[] = RuleErrorBuilder::message(sprintf(
-					'PHPDoc tag @mixin contains generic type alias %s but does not specify its types: %s',
-					$aliasName,
-					$missingParams,
-				))
-					->identifier('missingType.generics')
-					->build();
-			}
 
 			foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($type) as $callableType) {
 				$errors[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Classes/PropertyTagCheck.php b/src/Rules/Classes/PropertyTagCheck.php
@@ -171,18 +171,6 @@ private function checkPropertyTypeInTraitDefinitionContext(ClassReflection $clas
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($type) as [$aliasName, $missingParams]) {
-			$errors[] = RuleErrorBuilder::message(sprintf(
-				'PHPDoc tag %s for property %s::$%s contains generic type alias %s but does not specify its types: %s',
-				$tagName,
-				$classReflection->getDisplayName(),
-				$propertyName,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getIterableTypesWithMissingValueTypehint($type) as $iterableType) {
 			$iterableTypeDescription = $iterableType->describe(VerbosityLevel::typeOnly());
diff --git a/src/Rules/Constants/MissingClassConstantTypehintRule.php b/src/Rules/Constants/MissingClassConstantTypehintRule.php
@@ -83,17 +83,6 @@ private function processSingleConstant(ClassReflection $classReflection, string
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($constantType) as [$aliasName, $missingParams]) {
-			$errors[] = RuleErrorBuilder::message(sprintf(
-				'Constant %s::%s with generic type alias %s does not specify its types: %s',
-				$constantReflection->getDeclaringClass()->getDisplayName(),
-				$constantName,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($constantType) as $callableType) {
 			$errors[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Functions/MissingFunctionParameterTypehintRule.php b/src/Rules/Functions/MissingFunctionParameterTypehintRule.php
@@ -105,17 +105,6 @@ private function checkFunctionParameter(FunctionReflection $functionReflection,
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($parameterType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Function %s() has %s with generic type alias %s but does not specify its types: %s',
-				$functionReflection->getName(),
-				$parameterMessage,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($parameterType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Functions/MissingFunctionReturnTypehintRule.php b/src/Rules/Functions/MissingFunctionReturnTypehintRule.php
@@ -67,16 +67,6 @@ public function processNode(Node $node, Scope $scope): array
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($returnType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Function %s() return type with generic type alias %s does not specify its types: %s',
-				$functionReflection->getName(),
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($returnType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Methods/MissingMethodParameterTypehintRule.php b/src/Rules/Methods/MissingMethodParameterTypehintRule.php
@@ -108,18 +108,6 @@ private function checkMethodParameter(MethodReflection $methodReflection, string
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($parameterType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Method %s::%s() has %s with generic type alias %s but does not specify its types: %s',
-				$methodReflection->getDeclaringClass()->getDisplayName(),
-				$methodReflection->getName(),
-				$parameterMessage,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($parameterType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Methods/MissingMethodReturnTypehintRule.php b/src/Rules/Methods/MissingMethodReturnTypehintRule.php
@@ -79,17 +79,6 @@ public function processNode(Node $node, Scope $scope): array
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($returnType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Method %s::%s() return type with generic type alias %s does not specify its types: %s',
-				$methodReflection->getDeclaringClass()->getDisplayName(),
-				$methodReflection->getName(),
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($returnType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Methods/MissingMethodSelfOutTypeRule.php b/src/Rules/Methods/MissingMethodSelfOutTypeRule.php
@@ -72,18 +72,6 @@ public function processNode(Node $node, Scope $scope): array
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($selfOutType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Method %s::%s() has %s with generic type alias %s but does not specify its types: %s',
-				$classReflection->getDisplayName(),
-				$methodReflection->getName(),
-				$phpDocTagMessage,
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($selfOutType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/MissingTypehintCheck.php b/src/Rules/MissingTypehintCheck.php
@@ -117,6 +117,16 @@ public function getNonGenericObjectTypesWithGenericClass(Type $type): array
 			if ($type instanceof TemplateType) {
 				return $type;
 			}
+			if ($type instanceof GenericTypeAliasType) {
+				$missing = $type->getMissingRequiredParamNames();
+				if ($missing !== []) {
+					$objectTypes[] = [
+						sprintf('type alias %s', $type->getAliasName()),
+						implode(', ', array_unique($missing)),
+					];
+				}
+				return $traverse($type);
+			}
 			if ($type instanceof ObjectType) {
 				$classReflection = $type->getClassReflection();
 				if ($classReflection === null) {
@@ -172,31 +182,6 @@ public function getNonGenericObjectTypesWithGenericClass(Type $type): array
 		return $objectTypes;
 	}
 
-	/**
-	 * @return list<array{string, string}> List of [aliasName, missingTypeParamNames]
-	 */
-	public function getRawGenericTypeAliasesUsage(Type $type): array
-	{
-		/** @var array<string, list<string>> $found */
-		$found = [];
-		TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$found): Type {
-			if ($type instanceof GenericTypeAliasType) {
-				$missing = $type->getMissingRequiredParamNames();
-				if ($missing !== []) {
-					$found[$type->getAliasName()] = $missing;
-				}
-			}
-
-			return $traverse($type);
-		});
-
-		$result = [];
-		foreach ($found as $aliasName => $paramNames) {
-			$result[] = [$aliasName, implode(', ', array_unique($paramNames))];
-		}
-
-		return $result;
-	}
 
 	/**
 	 * @return Type[]
diff --git a/src/Rules/PhpDoc/AssertRuleHelper.php b/src/Rules/PhpDoc/AssertRuleHelper.php
@@ -200,17 +200,6 @@ public function check(
 					->build();
 			}
 
-			foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($assertedType) as [$aliasName, $missingParams]) {
-				$errors[] = RuleErrorBuilder::message(sprintf(
-					'PHPDoc tag %s for %s contains generic type alias %s but does not specify its types: %s',
-					$tagName,
-					$assertedExprString,
-					$aliasName,
-					$missingParams,
-				))
-					->identifier('missingType.generics')
-					->build();
-			}
 
 			foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($assertedType) as $callableType) {
 				$errors[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php b/src/Rules/PhpDoc/InvalidPhpDocVarTagTypeRule.php
@@ -122,17 +122,7 @@ public function processNode(Node $node, Scope $scope): array
 						->build();
 				}
 
-				foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($varTagType) as [$aliasName, $missingParams]) {
-					$errors[] = RuleErrorBuilder::message(sprintf(
-						'%s contains generic type alias %s but does not specify its types: %s',
-						$identifier,
-						$aliasName,
-						$missingParams,
-					))
-						->identifier('missingType.generics')
-						->build();
 				}
-			}
 
 			$escapedIdentifier = SprintfHelper::escapeFormatString($identifier);
 			$errors = array_merge($errors, $this->genericObjectTypeCheck->check(
diff --git a/src/Rules/Properties/MissingPropertyTypehintRule.php b/src/Rules/Properties/MissingPropertyTypehintRule.php
@@ -77,17 +77,6 @@ public function processNode(Node $node, Scope $scope): array
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($propertyType) as [$aliasName, $missingParams]) {
-			$messages[] = RuleErrorBuilder::message(sprintf(
-				'Property %s::$%s with generic type alias %s does not specify its types: %s',
-				$propertyReflection->getDeclaringClass()->getDisplayName(),
-				$node->getName(),
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($propertyType) as $callableType) {
 			$messages[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Rules/Properties/SetPropertyHookParameterRule.php b/src/Rules/Properties/SetPropertyHookParameterRule.php
@@ -146,18 +146,6 @@ public function processNode(Node $node, Scope $scope): array
 				->build();
 		}
 
-		foreach ($this->missingTypehintCheck->getRawGenericTypeAliasesUsage($parameterType) as [$aliasName, $missingParams]) {
-			$errors[] = RuleErrorBuilder::message(sprintf(
-				'Set hook for property %s::$%s has parameter $%s with generic type alias %s but does not specify its types: %s',
-				$classReflection->getDisplayName(),
-				$hookReflection->getHookedPropertyName(),
-				$parameter->getName(),
-				$aliasName,
-				$missingParams,
-			))
-				->identifier('missingType.generics')
-				->build();
-		}
 
 		foreach ($this->missingTypehintCheck->getCallablesWithMissingSignature($parameterType) as $callableType) {
 			$errors[] = RuleErrorBuilder::message(sprintf(
diff --git a/src/Type/UsefulTypeAliasResolver.php b/src/Type/UsefulTypeAliasResolver.php
@@ -119,7 +119,7 @@ private function resolveLocalTypeAlias(string $aliasName, NameScope $nameScope):
 			// with empty args. If all params have declared defaults, isResolvable() will be true and
 			// the type is immediately expanded to the concrete default form. When at least one param
 			// has no default, the GenericTypeAliasType stays unresolved so that
-			// MissingTypehintCheck::getRawGenericTypeAliasesUsage() can detect the bare-usage error.
+			// MissingTypehintCheck::getNonGenericObjectTypesWithGenericClass() can detect the bare-usage error.
 			if ($unresolvedAlias->isGeneric()) {
 				$appType = $unresolvedAlias->createApplicationType($this->typeNodeResolver, []);
 				$resolvedAliasType = $appType->isResolvable() ? $appType->resolve() : $appType;
