octoleo/rector
1
1
Fork 0
mirror of https://github.com/rectorphp/rector.git synced 2024-06-13 14:42:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

add trigger warning about deprecated resolve() and getStaticType() methods in NodeTypeResolver + update all packages (#976)

Browse Source
This commit is contained in:
Tomas Votruba 2021-10-07 21:28:27 +02:00 committed by GitHub
parent d060796fa7
commit 82b689d713
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
55 changed files with 78 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packages-tests/NodeTypeResolver/PerNodeTypeResolver/ClassAndInterfaceTypeResolver/ClassTypeResolverTest.php
View File

@ -26,7 +26,7 @@ final class ClassTypeResolverTest extends AbstractNodeTypeResolverTest
{
$variableNodes = $this->getNodesForFileOfType($file, Class_::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[$nodePosition]);
$this->assertInstanceOf(TypeWithClassName::class, $resolvedType);
/** @var TypeWithClassName $resolvedType */
@ -54,7 +54,7 @@ final class ClassTypeResolverTest extends AbstractNodeTypeResolverTest
$variableNodes = $this->getNodesForFileOfType($file, Class_::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[0]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[0]);
$this->assertInstanceOf(TypeWithClassName::class, $resolvedType);
/** @var TypeWithClassName $resolvedType */

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/ClassAndInterfaceTypeResolver/InterfaceTypeResolverTest.php
View File

@ -23,7 +23,7 @@ final class InterfaceTypeResolverTest extends AbstractNodeTypeResolverTest
{
$variableNodes = $this->getNodesForFileOfType($file, Interface_::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[$nodePosition]);
$this->assertInstanceOf(TypeWithClassName::class, $resolvedType);
/** @var TypeWithClassName $resolvedType */

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/ParamTypeResolver/ParamTypeResolverTest.php
View File

@ -23,7 +23,7 @@ final class ParamTypeResolverTest extends AbstractNodeTypeResolverTest
{
$variableNodes = $this->getNodesForFileOfType($file, Param::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[$nodePosition]);
$this->assertInstanceOf(TypeWithClassName::class, $resolvedType);

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/PropertyFetchTypeResolver/AbstractPropertyFetchTypeResolverTest.php
View File

@ -22,7 +22,7 @@ abstract class AbstractPropertyFetchTypeResolverTest extends AbstractNodeTypeRes
$expectedFileInfo = $inputFileInfoAndExpectedFileInfo->getExpectedFileInfo();
$propertyFetchNodes = $this->getNodesForFileOfType($inputFileInfo->getRealPath(), PropertyFetch::class);
$resolvedType = $this->nodeTypeResolver->resolve($propertyFetchNodes[0]);
$resolvedType = $this->nodeTypeResolver->getType($propertyFetchNodes[0]);
$expectedType = include $expectedFileInfo->getRealPath();

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/PropertyTypeResolver/PropertyTypeResolverTest.php
View File

@ -28,7 +28,7 @@ final class PropertyTypeResolverTest extends AbstractNodeTypeResolverTest
{
$propertyNodes = $this->getNodesForFileOfType($file, Property::class);
$resolvedType = $this->nodeTypeResolver->resolve($propertyNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($propertyNodes[$nodePosition]);
// type is as expected
$expectedTypeClass = $expectedType::class;

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/TraitTypeResolver/TraitTypeResolverTest.php
View File

@ -25,7 +25,7 @@ final class TraitTypeResolverTest extends AbstractNodeTypeResolverTest
{
$variableNodes = $this->getNodesForFileOfType($file, Trait_::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[$nodePosition]);
$this->assertEquals($expectedType, $resolvedType);
}

2
packages-tests/NodeTypeResolver/PerNodeTypeResolver/VariableTypeResolver/VariableTypeResolverTest.php
View File

@ -23,7 +23,7 @@ final class VariableTypeResolverTest extends AbstractNodeTypeResolverTest
{
$variableNodes = $this->getNodesForFileOfType($file, Variable::class);
$resolvedType = $this->nodeTypeResolver->resolve($variableNodes[$nodePosition]);
$resolvedType = $this->nodeTypeResolver->getType($variableNodes[$nodePosition]);
$this->assertInstanceOf(TypeWithClassName::class, $resolvedType);
/** @var TypeWithClassName $resolvedType */

2
packages/NodeCollector/NodeAnalyzer/ArrayCallableMethodMatcher.php
View File

@ -60,7 +60,7 @@ final class ArrayCallableMethodMatcher
$calleeType = $firstItemValue instanceof ClassConstFetch
// static ::class reference?
? $this->resolveClassConstFetchType($firstItemValue)
: $this->nodeTypeResolver->resolve($firstItemValue);
: $this->nodeTypeResolver->getType($firstItemValue);
if (! $calleeType instanceof TypeWithClassName) {
return null;

2
packages/NodeNestingScope/ContextAnalyzer.php
View File

@ -83,7 +83,7 @@ final class ContextAnalyzer
foreach ($loopNodes as $loopNode) {
$loopObjectType = new ObjectType($loopNode);
$parentType = $this->nodeTypeResolver->resolve($node);
$parentType = $this->nodeTypeResolver->getType($node);
$superType = $parentType->isSuperTypeOf($loopObjectType);
$isLoopType = $superType->yes();

8
packages/NodeTypeResolver/NodeTypeResolver.php
View File

@ -128,6 +128,10 @@ final class NodeTypeResolver
*/
public function resolve(Node $node): Type
{
$errorMessage = sprintf('Method "%s" is deprecated. Use "getType()" instead', __METHOD__);
trigger_error($errorMessage, E_USER_WARNING);
sleep(3);
return $this->getType($node);
}
@ -231,6 +235,10 @@ final class NodeTypeResolver
*/
public function getStaticType(Node $node): Type
{
$errorMessage = sprintf('Method "%s" is deprecated. Use "getType()" instead', __METHOD__);
trigger_error($errorMessage, E_USER_WARNING);
sleep(3);
if ($node instanceof Param || $node instanceof New_ || $node instanceof Return_) {
return $this->getType($node);
}

2
packages/NodeTypeResolver/NodeTypeResolver/ClassMethodOrClassConstTypeResolver.php
View File

@ -45,6 +45,6 @@ final class ClassMethodOrClassConstTypeResolver implements NodeTypeResolverInter
return new ObjectWithoutClassType();
}
return $this->nodeTypeResolver->resolve($classLike);
return $this->nodeTypeResolver->getType($classLike);
}
}

2
packages/NodeTypeResolver/NodeTypeResolver/ParamTypeResolver.php
View File

@ -110,7 +110,7 @@ final class ParamTypeResolver implements NodeTypeResolverInterface
return null;
}
$paramStaticType = $this->nodeTypeResolver->resolve($node);
$paramStaticType = $this->nodeTypeResolver->getType($node);
return NodeTraverser::STOP_TRAVERSAL;
}

2
packages/NodeTypeResolver/NodeTypeResolver/PropertyFetchTypeResolver.php
View File

@ -81,7 +81,7 @@ final class PropertyFetchTypeResolver implements NodeTypeResolverInterface
return new MixedType();
}
$varType = $this->nodeTypeResolver->resolve($propertyFetch->var);
$varType = $this->nodeTypeResolver->getType($propertyFetch->var);
if (! $varType instanceof ObjectType) {
return new MixedType();
}

2
packages/NodeTypeResolver/NodeTypeResolver/PropertyTypeResolver.php
View File

@ -44,6 +44,6 @@ final class PropertyTypeResolver implements NodeTypeResolverInterface
$propertyFetch = new PropertyFetch(new Variable('this'), (string) $node->props[0]->name);
$propertyFetch->setAttribute(AttributeKey::SCOPE, $node->getAttribute(AttributeKey::SCOPE));
return $this->nodeTypeResolver->resolve($propertyFetch);
return $this->nodeTypeResolver->getType($propertyFetch);
}
}

2
packages/NodeTypeResolver/NodeTypeResolver/ReturnTypeResolver.php
View File

@ -39,6 +39,6 @@ final class ReturnTypeResolver implements NodeTypeResolverInterface
return new VoidType();
}
return $this->nodeTypeResolver->resolve($node->expr);
return $this->nodeTypeResolver->getType($node->expr);
}
}

4
packages/NodeTypeResolver/NodeTypeResolver/StaticCallMethodCallTypeResolver.php
View File

@ -66,9 +66,9 @@ final class StaticCallMethodCallTypeResolver implements NodeTypeResolverInterfac
}
if ($node instanceof MethodCall) {
$callerType = $this->nodeTypeResolver->resolve($node->var);
$callerType = $this->nodeTypeResolver->getType($node->var);
} else {
$callerType = $this->nodeTypeResolver->resolve($node->class);
$callerType = $this->nodeTypeResolver->getType($node->class);
}
foreach ($callerType->getReferencedClasses() as $referencedClass) {

6
packages/NodeTypeResolver/TypeAnalyzer/ArrayTypeAnalyzer.php
View File

@ -35,7 +35,7 @@ final class ArrayTypeAnalyzer
public function isArrayType(Node $node): bool
{
$nodeStaticType = $this->nodeTypeResolver->resolve($node);
$nodeStaticType = $this->nodeTypeResolver->getType($node);
$nodeStaticType = $this->pregMatchTypeCorrector->correct($node, $nodeStaticType);
if ($this->isIntersectionArrayType($nodeStaticType)) {
@ -119,9 +119,9 @@ final class ArrayTypeAnalyzer
// also possible 3rd party vendor
if ($node instanceof PropertyFetch) {
$propertyOwnerStaticType = $this->nodeTypeResolver->resolve($node->var);
$propertyOwnerStaticType = $this->nodeTypeResolver->getType($node->var);
} else {
$propertyOwnerStaticType = $this->nodeTypeResolver->resolve($node->class);
$propertyOwnerStaticType = $this->nodeTypeResolver->getType($node->class);
}
if ($propertyOwnerStaticType instanceof ThisType) {

2
packages/NodeTypeResolver/TypeAnalyzer/CountableTypeAnalyzer.php
View File

@ -30,7 +30,7 @@ final class CountableTypeAnalyzer
public function isCountableType(Node $node): bool
{
$nodeType = $this->nodeTypeResolver->resolve($node);
$nodeType = $this->nodeTypeResolver->getType($node);
$nodeType = $this->pregMatchTypeCorrector->correct($node, $nodeType);
foreach ($this->countableObjectTypes as $countableObjectType) {

2
rules/Autodiscovery/Analyzer/ValueObjectClassAnalyzer.php
View File

@ -51,7 +51,7 @@ final class ValueObjectClassAnalyzer
// resolve constructor types
foreach ($constructClassMethod->params as $param) {
$paramType = $this->nodeTypeResolver->resolve($param);
$paramType = $this->nodeTypeResolver->getType($param);
if (! $paramType instanceof ObjectType) {
continue;
}

2
rules/CodeQuality/NodeManipulator/ClassMethodParameterTypeManipulator.php
View File

@ -55,7 +55,7 @@ final class ClassMethodParameterTypeManipulator
continue;
}
$paramType = $this->nodeTypeResolver->resolve($param);
$paramType = $this->nodeTypeResolver->getType($param);
if (! $paramType->isSuperTypeOf($objectType)->yes()) {
continue;
}

2
rules/CodeQuality/NodeManipulator/ClassMethodReturnTypeManipulator.php
View File

@ -46,7 +46,7 @@ final class ClassMethodReturnTypeManipulator
return null;
}
$paramType = $this->nodeTypeResolver->resolve($returnType);
$paramType = $this->nodeTypeResolver->getType($returnType);
if (! $paramType->isSuperTypeOf($objectType)->yes()) {
return null;
}

2
rules/CodeQuality/Rector/ClassMethod/DateTimeToDateTimeInterfaceRector.php
View File

@ -207,7 +207,7 @@ CODE_SAMPLE
return false;
}
$type = $this->nodeTypeResolver->resolve($return->expr);
$type = $this->nodeTypeResolver->getType($return->expr);
return $type instanceof ObjectType && $type->getClassName() === self::DATE_TIME;
}
}

4
rules/CodeQuality/TypeResolver/AssignVariableTypeResolver.php
View File

@ -18,8 +18,8 @@ final class AssignVariableTypeResolver
public function resolve(Assign $assign): Type
{
$variableType = $this->nodeTypeResolver->resolve($assign->var);
$exprType = $this->nodeTypeResolver->resolve($assign->expr);
$variableType = $this->nodeTypeResolver->getType($assign->var);
$exprType = $this->nodeTypeResolver->getType($assign->expr);
if ($exprType instanceof UnionType) {
$variableType = $exprType;

2
rules/CodingStyle/NodeFactory/ArrayCallableToMethodCallFactory.php
View File

@ -45,7 +45,7 @@ final class ArrayCallableToMethodCallFactory
return null;
}
$firstItemType = $this->nodeTypeResolver->resolve($firstItem->value);
$firstItemType = $this->nodeTypeResolver->getType($firstItem->value);
if (! $firstItemType instanceof TypeWithClassName) {
return null;
}

2
rules/CodingStyle/Rector/Encapsed/EncapsedStringsToSprintfRector.php
View File

@ -118,7 +118,7 @@ CODE_SAMPLE
private function collectExpr(Expr $expr): void
{
$type = $this->nodeTypeResolver->resolve($expr);
$type = $this->nodeTypeResolver->getType($expr);
$found = false;
foreach (self::FORMAT_SPECIFIERS as $key => $types) {

2
rules/DeadCode/NodeAnalyzer/CallCollectionAnalyzer.php
View File

@ -25,7 +25,7 @@ final class CallCollectionAnalyzer
{
foreach ($calls as $call) {
$callerRoot = $call instanceof StaticCall ? $call->class : $call->var;
$callerType = $this->nodeTypeResolver->resolve($callerRoot);
$callerType = $this->nodeTypeResolver->getType($callerRoot);
if (! $callerType instanceof TypeWithClassName) {
continue;

2
rules/DeadCode/NodeManipulator/LivingCodeManipulator.php
View File

@ -79,7 +79,7 @@ final class LivingCodeManipulator
}
if ($expr instanceof ArrayDimFetch) {
$type = $this->nodeTypeResolver->resolve($expr->var);
$type = $this->nodeTypeResolver->getType($expr->var);
if ($type instanceof ObjectType) {
$objectType = new ObjectType('ArrayAccess');

2
rules/DeadCode/Rector/Assign/RemoveAssignOfVoidReturnFunctionRector.php
View File

@ -89,7 +89,7 @@ CODE_SAMPLE
return null;
}
$exprType = $this->nodeTypeResolver->resolve($node->expr);
$exprType = $this->nodeTypeResolver->getType($node->expr);
if (! $exprType instanceof VoidType) {
return null;
}

4
rules/DeadCode/Rector/Cast/RecastingRemovalRector.php
View File

@ -123,8 +123,8 @@ CODE_SAMPLE
$phpPropertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch($expr);
if (! $phpPropertyReflection instanceof PhpPropertyReflection) {
$propertyType = $expr instanceof StaticPropertyFetch
? $this->nodeTypeResolver->resolve($expr->class)
: $this->nodeTypeResolver->resolve($expr->var);
? $this->nodeTypeResolver->getType($expr->class)
: $this->nodeTypeResolver->getType($expr->var);
// need to UnionType check due rectify with RecastingRemovalRector + CountOnNullRector
// cause add (array) cast on $node->args

4
rules/DeadCode/Rector/If_/RemoveDeadInstanceOfRector.php
View File

@ -118,8 +118,8 @@ CODE_SAMPLE
return null;
}
$classType = $this->nodeTypeResolver->resolve($instanceof->class);
$exprType = $this->nodeTypeResolver->resolve($instanceof->expr);
$classType = $this->nodeTypeResolver->getType($instanceof->class);
$exprType = $this->nodeTypeResolver->getType($instanceof->expr);
$isSameStaticTypeOrSubtype = $classType->equals($exprType) || $classType->isSuperTypeOf($exprType)
->yes();

2
rules/DeadCode/SideEffect/SideEffectNodeDetector.php
View File

@ -53,7 +53,7 @@ final class SideEffectNodeDetector
return true;
}
$exprStaticType = $this->nodeTypeResolver->resolve($expr);
$exprStaticType = $this->nodeTypeResolver->getType($expr);
if ($exprStaticType instanceof ConstantType) {
return false;
}

2
rules/DeadCode/UselessIfCondBeforeForeachDetector.php
View File

@ -53,7 +53,7 @@ final class UselessIfCondBeforeForeachDetector
}
// is array though?
$arrayType = $this->nodeTypeResolver->resolve($empty->expr);
$arrayType = $this->nodeTypeResolver->getType($empty->expr);
if (! $arrayType instanceof ArrayType) {
return false;
}

2
rules/Defluent/NodeAnalyzer/FluentChainMethodCallNodeAnalyzer.php
View File

@ -192,7 +192,7 @@ final class FluentChainMethodCallNodeAnalyzer
$node = $node->var;
}
$variableType = $this->nodeTypeResolver->resolve($node);
$variableType = $this->nodeTypeResolver->getType($node);
if ($variableType instanceof MixedType) {
return false;
}

4
rules/Defluent/NodeAnalyzer/NewFluentChainMethodCallNodeAnalyzer.php
View File

@ -50,12 +50,12 @@ final class NewFluentChainMethodCallNodeAnalyzer
return null;
}
$newType = $this->nodeTypeResolver->resolve($onlyArgValue);
$newType = $this->nodeTypeResolver->getType($onlyArgValue);
if ($newType instanceof MixedType) {
return null;
}
$parentMethodCallReturnType = $this->nodeTypeResolver->resolve($methodCall);
$parentMethodCallReturnType = $this->nodeTypeResolver->getType($methodCall);
if (! $newType->equals($parentMethodCallReturnType)) {
return null;
}

2
rules/MockeryToProphecy/Rector/ClassMethod/MockeryCreateMockToProphizeRector.php
View File

@ -91,7 +91,7 @@ CODE_SAMPLE
return null;
}
$callerType = $this->nodeTypeResolver->resolve($node->class);
$callerType = $this->nodeTypeResolver->getType($node->class);
if (! $callerType->isSuperTypeOf(new ObjectType('Mockery'))->yes()) {
return null;
}

2
rules/MockeryToProphecy/Rector/StaticCall/MockeryCloseRemoveRector.php
View File

@ -39,7 +39,7 @@ final class MockeryCloseRemoveRector extends AbstractRector
return null;
}
$callerType = $this->nodeTypeResolver->resolve($node->class);
$callerType = $this->nodeTypeResolver->getType($node->class);
if (! $callerType->isSuperTypeOf(new ObjectType('Mockery'))->yes()) {
return null;
}

2
rules/Naming/Guard/BreakingVariableRenameGuard.php
View File

@ -227,7 +227,7 @@ final class BreakingVariableRenameGuard
*/
private function isDateTimeAtNamingConvention(Param $param): bool
{
$type = $this->nodeTypeResolver->resolve($param);
$type = $this->nodeTypeResolver->getType($param);
$type = $this->typeUnwrapper->unwrapFirstObjectTypeFromUnionType($type);
if (! $type instanceof TypeWithClassName) {
return false;

2
rules/Naming/Guard/DateTimeAtNamingConventionGuard.php
View File

@ -37,7 +37,7 @@ final class DateTimeAtNamingConventionGuard implements ConflictingNameGuardInter
private function isDateTimeAtNamingConvention(PropertyRename $propertyRename): bool
{
$type = $this->nodeTypeResolver->resolve($propertyRename->getProperty());
$type = $this->nodeTypeResolver->getType($propertyRename->getProperty());
$type = $this->typeUnwrapper->unwrapFirstObjectTypeFromUnionType($type);
if (! $type instanceof TypeWithClassName) {

2
rules/Php71/NodeAnalyzer/CountableAnalyzer.php
View File

@ -29,7 +29,7 @@ final class CountableAnalyzer
return false;
}
$callerObjectType = $this->nodeTypeResolver->resolve($expr->var);
$callerObjectType = $this->nodeTypeResolver->getType($expr->var);
$propertyName = $this->nodeNameResolver->getName($expr->name);
if (! is_string($propertyName)) {

2
rules/Php74/Rector/MethodCall/ChangeReflectionTypeToStringToGetNameRector.php
View File

@ -116,7 +116,7 @@ CODE_SAMPLE
return null;
}
$type = $this->nodeTypeResolver->resolve($node->expr);
$type = $this->nodeTypeResolver->getType($node->expr);
if (! $type instanceof UnionType) {
return $this->nodeFactory->createMethodCall($node->expr, self::GET_NAME);
}

2
rules/Php74/Rector/StaticCall/ExportToReflectionFunctionRector.php
View File

@ -72,7 +72,7 @@ CODE_SAMPLE
return null;
}
$callerType = $this->nodeTypeResolver->resolve($node->class);
$callerType = $this->nodeTypeResolver->getType($node->class);
if (! $callerType->isSuperTypeOf(new ObjectType('ReflectionFunction'))->yes()) {
return null;
}

2
rules/Php80/NodeAnalyzer/PromotedPropertyCandidateResolver.php
View File

@ -177,7 +177,7 @@ final class PromotedPropertyCandidateResolver
return false;
}
$matchedParamType = $this->nodeTypeResolver->resolve($param);
$matchedParamType = $this->nodeTypeResolver->getType($param);
if ($param->default !== null) {
$defaultValueType = $this->nodeTypeResolver->getType($param->default);
$matchedParamType = $this->typeFactory->createMixedPassedOrUnionType(

2
rules/RemovingStatic/Rector/ClassMethod/LocallyCalledStaticMethodToNonStaticRector.php
View File

@ -155,7 +155,7 @@ CODE_SAMPLE
$className = $classMethod->getAttribute(AttributeKey::CLASS_NAME);
$objectType = new ObjectType($className);
$callerType = $this->nodeTypeResolver->resolve($staticCall->class);
$callerType = $this->nodeTypeResolver->getType($staticCall->class);
return $objectType->equals($callerType);
}
}

2
rules/Renaming/Rector/PropertyFetch/RenamePropertyRector.php
View File

@ -125,7 +125,7 @@ final class RenamePropertyRector extends AbstractRector implements ConfigurableR
continue;
}
$nodeVarType = $this->nodeTypeResolver->resolve($propertyFetch->var);
$nodeVarType = $this->nodeTypeResolver->getType($propertyFetch->var);
if ($nodeVarType instanceof ThisType && $class instanceof ClassLike) {
$this->renameProperty($class, $renamedProperty);
}

2
rules/TypeDeclaration/NodeAnalyzer/CallTypesResolver.php
View File

@ -77,7 +77,7 @@ final class CallTypesResolver
if ($typeStrictness->equals(TypeStrictness::STRICTNESS_TYPE_DECLARATION())) {
$argValueType = $this->nodeTypeResolver->getNativeType($arg->value);
} else {
$argValueType = $this->nodeTypeResolver->resolve($arg->value);
$argValueType = $this->nodeTypeResolver->getType($arg->value);
}
// "self" in another object is not correct, this make it independent

2
rules/TypeDeclaration/Rector/ClassMethod/AddArrayParamDocTypeRector.php
View File

@ -138,7 +138,7 @@ CODE_SAMPLE
}
// not an array type
$paramType = $this->nodeTypeResolver->resolve($param->type);
$paramType = $this->nodeTypeResolver->getType($param->type);
// weird case for maybe interface
if ($paramType->isIterable()->maybe() && ($paramType instanceof ObjectType)) {

4
rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictTypedCallRector.php
View File

@ -142,7 +142,7 @@ CODE_SAMPLE
private function processArrowFunction(ArrowFunction $arrowFunction): ?ArrowFunction
{
$resolvedType = $this->nodeTypeResolver->resolve($arrowFunction->expr);
$resolvedType = $this->nodeTypeResolver->getType($arrowFunction->expr);
// void type is not accepted for arrow functions - https://www.php.net/manual/en/functions.arrow.php#125673
if ($resolvedType instanceof VoidType) {
@ -213,7 +213,7 @@ CODE_SAMPLE
Identifier | Name | NullableType | PhpParserUnionType $returnedStrictTypeNode,
ClassMethod | Function_ | Closure $functionLike
): Closure | ClassMethod | Function_ {
$resolvedType = $this->nodeTypeResolver->resolve($return);
$resolvedType = $this->nodeTypeResolver->getType($return);
if ($resolvedType instanceof UnionType) {
if (! $returnedStrictTypeNode instanceof NullableType) {

2
rules/TypeDeclaration/TypeInferer/ParamTypeInferer.php
View File

@ -34,7 +34,7 @@ final class ParamTypeInferer
$inferedType = $this->genericClassStringTypeNormalizer->normalize($paramType);
if ($param->default instanceof Node) {
$paramDefaultType = $this->nodeTypeResolver->resolve($param->default);
$paramDefaultType = $this->nodeTypeResolver->getType($param->default);
if (! $paramDefaultType instanceof $inferedType) {
return new MixedType();
}

4
rules/TypeDeclaration/TypeInferer/ParamTypeInferer/PHPUnitDataProviderParamTypeInferer.php
View File

@ -159,7 +159,7 @@ final class PHPUnitDataProviderParamTypeInferer implements ParamTypeInfererInter
private function getTypeFromClassMethodYield(Array_ $classMethodYieldArrayNode): MixedType | ConstantArrayType
{
$arrayTypes = $this->nodeTypeResolver->resolve($classMethodYieldArrayNode);
$arrayTypes = $this->nodeTypeResolver->getType($classMethodYieldArrayNode);
// impossible to resolve
if (! $arrayTypes instanceof ConstantArrayType) {
@ -200,7 +200,7 @@ final class PHPUnitDataProviderParamTypeInferer implements ParamTypeInfererInter
continue;
}
$paramOnPositionTypes[] = $this->nodeTypeResolver->resolve($singleDataProvidedSetItem->value);
$paramOnPositionTypes[] = $this->nodeTypeResolver->getType($singleDataProvidedSetItem->value);
}
}

2
rules/TypeDeclaration/TypeInferer/ParamTypeInferer/SplFixedArrayParamTypeInferer.php
View File

@ -25,7 +25,7 @@ final class SplFixedArrayParamTypeInferer implements ParamTypeInfererInterface
return new MixedType();
}
$paramType = $this->nodeTypeResolver->resolve($param->type);
$paramType = $this->nodeTypeResolver->getType($param->type);
return $this->splArrayFixedTypeNarrower->narrow($paramType);
}
}

4
src/NodeManipulator/MagicPropertyFetchAnalyzer.php
View File

@ -33,7 +33,7 @@ final class MagicPropertyFetchAnalyzer
public function isMagicOnType(PropertyFetch | StaticPropertyFetch $expr, Type $type): bool
{
$varNodeType = $this->nodeTypeResolver->resolve($expr);
$varNodeType = $this->nodeTypeResolver->getType($expr);
if ($varNodeType instanceof ErrorType) {
return true;
@ -65,7 +65,7 @@ final class MagicPropertyFetchAnalyzer
if ($expr instanceof PropertyFetch) {
$propertyFetchType = $scope->getType($expr->var);
} else {
$propertyFetchType = $this->nodeTypeResolver->resolve($expr->class);
$propertyFetchType = $this->nodeTypeResolver->getType($expr->class);
}
if (! $propertyFetchType instanceof TypeWithClassName) {

4
src/PhpParser/AstResolver.php
View File

@ -216,9 +216,9 @@ final class AstResolver
public function resolveClassMethodFromCall(MethodCall | StaticCall $call): ?ClassMethod
{
if ($call instanceof MethodCall) {
$callerStaticType = $this->nodeTypeResolver->resolve($call->var);
$callerStaticType = $this->nodeTypeResolver->getType($call->var);
} else {
$callerStaticType = $this->nodeTypeResolver->resolve($call->class);
$callerStaticType = $this->nodeTypeResolver->getType($call->class);
}
if (! $callerStaticType instanceof TypeWithClassName) {

2
src/PhpParser/NodeFinder/LocalConstantFinder.php
View File

@ -27,7 +27,7 @@ final class LocalConstantFinder
return null;
}
$constantClassType = $this->nodeTypeResolver->resolve($classConstFetch->class);
$constantClassType = $this->nodeTypeResolver->getType($classConstFetch->class);
if (! $constantClassType instanceof TypeWithClassName) {
return null;
}

2
src/PhpParser/NodeFinder/LocalMethodCallFinder.php
View File

@ -45,7 +45,7 @@ final class LocalMethodCallFinder
$matchingMethodCalls = [];
foreach ($methodCalls as $methodCall) {
$callerType = $this->nodeTypeResolver->resolve($methodCall->var);
$callerType = $this->nodeTypeResolver->getType($methodCall->var);
if (! $callerType instanceof TypeWithClassName) {
continue;
}

10
src/Reflection/ReflectionResolver.php
View File

@ -76,7 +76,7 @@ final class ReflectionResolver
public function resolveMethodReflectionFromStaticCall(StaticCall $staticCall): ?MethodReflection
{
$objectType = $this->nodeTypeResolver->resolve($staticCall->class);
$objectType = $this->nodeTypeResolver->getType($staticCall->class);
/** @var array<class-string> $classes */
$classes = TypeUtils::getDirectClassNames($objectType);
@ -100,7 +100,7 @@ final class ReflectionResolver
public function resolveMethodReflectionFromMethodCall(MethodCall $methodCall): ?MethodReflection
{
$callerType = $this->nodeTypeResolver->resolve($methodCall->var);
$callerType = $this->nodeTypeResolver->getType($methodCall->var);
if (! $callerType instanceof TypeWithClassName) {
return null;
}
@ -143,7 +143,7 @@ final class ReflectionResolver
public function resolveMethodReflectionFromNew(New_ $new): ?MethodReflection
{
$newClassType = $this->nodeTypeResolver->resolve($new->class);
$newClassType = $this->nodeTypeResolver->getType($new->class);
if (! $newClassType instanceof TypeWithClassName) {
return null;
}
@ -156,8 +156,8 @@ final class ReflectionResolver
PropertyFetch | StaticPropertyFetch $propertyFetch
): ?PhpPropertyReflection {
$fetcheeType = $propertyFetch instanceof PropertyFetch
? $this->nodeTypeResolver->resolve($propertyFetch->var)
: $this->nodeTypeResolver->resolve($propertyFetch->class);
? $this->nodeTypeResolver->getType($propertyFetch->var)
: $this->nodeTypeResolver->getType($propertyFetch->class);
if (! $fetcheeType instanceof TypeWithClassName) {
return null;