Stop using deprecated method

Author: ondrejmirtes

src/Analyser/MutatingScope.php

@@ -1135,7 +1135,7 @@ private function resolveType(Expr $node): Type
 					foreach ($rightTypes as $rightType) {
 						$resultType = $this->calculateFromScalars($node, $leftType, $rightType);
 						if ($generalize) {
-							$resultType = TypeUtils::generalizeType($resultType, GeneralizePrecision::lessSpecific());
+							$resultType = $resultType->generalize(GeneralizePrecision::lessSpecific());
 						}
 						$resultTypes[] = $resultType;
 					}
@@ -5193,7 +5193,7 @@ private static function generalizeType(Type $a, Type $b): Type
 				continue;
 			}
 
-			$resultTypes[] = TypeUtils::generalizeType(TypeCombinator::union(...$constantTypes['a'], ...$constantTypes['b']), GeneralizePrecision::moreSpecific());
+			$resultTypes[] = TypeCombinator::union(...$constantTypes['a'], ...$constantTypes['b'])->generalize(GeneralizePrecision::moreSpecific());
 		}
 
 		if (count($constantArrays['a']) > 0) {

src/Reflection/Php/PhpClassReflectionExtension.php

@@ -47,7 +47,6 @@
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypehintHelper;
-use PHPStan\Type\TypeUtils;
 use ReflectionClass;
 use ReflectionParameter;
 use function array_key_exists;
@@ -974,7 +973,7 @@ private function inferAndCachePropertyTypes(
 				continue;
 			}
 
-			$propertyType = TypeUtils::generalizeType($propertyType, GeneralizePrecision::lessSpecific());
+			$propertyType = $propertyType->generalize(GeneralizePrecision::lessSpecific());
 			if ($propertyType instanceof ConstantArrayType) {
 				$propertyType = new ArrayType(new MixedType(true), new MixedType(true));
 			}

src/Type/ArrayType.php

@@ -155,7 +155,7 @@ function () use ($level, $isMixedKeyType, $isMixedItemType): string {
 
 	public function generalizeValues(): self
 	{
-		return new self($this->keyType, TypeUtils::generalizeType($this->itemType, GeneralizePrecision::lessSpecific()));
+		return new self($this->keyType, $this->itemType->generalize(GeneralizePrecision::lessSpecific()));
 	}
 
 	public function getKeysArray(): self

src/Type/Constant/ConstantArrayType.php

@@ -29,7 +29,6 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 use function array_keys;
@@ -499,7 +498,7 @@ public function unsetOffset(Type $offsetType): Type
 			$arrays[] = new self($tmp->keyTypes, $tmp->valueTypes, $tmp->nextAutoIndex, array_keys($tmp->keyTypes));
 		}
 
-		return TypeUtils::generalizeType(TypeCombinator::union(...$arrays), GeneralizePrecision::moreSpecific());
+		return TypeCombinator::union(...$arrays)->generalize(GeneralizePrecision::moreSpecific());
 	}
 
 	public function isIterableAtLeastOnce(): TrinaryLogic
@@ -630,8 +629,8 @@ public function generalize(GeneralizePrecision $precision): Type
 		}
 
 		$arrayType = new ArrayType(
-			TypeUtils::generalizeType($this->getKeyType(), $precision),
-			TypeUtils::generalizeType($this->getItemType(), $precision),
+			$this->getKeyType()->generalize($precision),
+			$this->getItemType()->generalize($precision),
 		);
 
 		if (count($this->keyTypes) > count($this->optionalKeys)) {
@@ -648,7 +647,7 @@ public function generalizeValues(): ArrayType
 	{
 		$valueTypes = [];
 		foreach ($this->valueTypes as $valueType) {
-			$valueTypes[] = TypeUtils::generalizeType($valueType, GeneralizePrecision::lessSpecific());
+			$valueTypes[] = $valueType->generalize(GeneralizePrecision::lessSpecific());
 		}
 
 		return new self($this->keyTypes, $valueTypes, $this->nextAutoIndex, $this->optionalKeys);

src/Type/IntersectionType.php

@@ -156,7 +156,7 @@ function () use ($level): string {
 					if ($type instanceof AccessoryType) {
 						continue;
 					}
-					$typeNames[] = TypeUtils::generalizeType($type, GeneralizePrecision::lessSpecific())->describe($level);
+					$typeNames[] = $type->generalize(GeneralizePrecision::lessSpecific())->describe($level);
 				}
 
 				return implode('&', $typeNames);

src/Type/Php/ArgumentBasedFunctionReturnTypeExtension.php

@@ -10,7 +10,6 @@
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeUtils;
 
 class ArgumentBasedFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
@@ -55,8 +54,8 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$argumentKeyType = $argumentType->getIterableKeyType();
 		$argumentValueType = $argumentType->getIterableValueType();
 		if ($argument->unpack) {
-			$argumentKeyType = TypeUtils::generalizeType($argumentKeyType, GeneralizePrecision::moreSpecific());
-			$argumentValueType = TypeUtils::generalizeType($argumentValueType->getIterableValueType(), GeneralizePrecision::moreSpecific());
+			$argumentKeyType = $argumentKeyType->generalize(GeneralizePrecision::moreSpecific());
+			$argumentValueType = $argumentValueType->getIterableValueType()->generalize(GeneralizePrecision::moreSpecific());
 		}
 
 		return new ArrayType(

src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php

@@ -12,7 +12,6 @@
 use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use PHPStan\Type\UnionType;
 
 class ArrayMergeFunctionDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -43,7 +42,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 				}
 			}
 
-			$keyTypes[] = TypeUtils::generalizeType($argType->getIterableKeyType(), GeneralizePrecision::moreSpecific());
+			$keyTypes[] = $argType->getIterableKeyType()->generalize(GeneralizePrecision::moreSpecific());
 			$valueTypes[] = $argType->getIterableValueType();
 
 			if (!$argType->isIterableAtLeastOnce()->yes()) {