Remove myclabs/php-enum dependency (#2388)

* next * use TypeKind in PHPStan enum type check * turn ObjectReference into constant enumlike * prefer selt/this to constant enum
rectorphp · May 29, 2022 · db57fba · db57fba
1 parent 953f9c7
commit db57fba
Show file tree

Hide file tree

Showing 110 changed files with 336 additions and 311 deletions.
diff --git a/composer.json b/composer.json
@@ -14,7 +14,6 @@
         "composer/semver": "^3.3",
         "composer/xdebug-handler": "^3.0",
         "doctrine/inflector": "^2.0",
-        "myclabs/php-enum": "^1.8",
         "nette/utils": "^3.2.7",
         "nikic/php-parser": "^4.13.2",
         "ondram/ci-detector": "^4.1",

diff --git a/ecs.php b/ecs.php
@@ -58,8 +58,12 @@
         // buggy - @todo fix on Symplify master
         DocBlockLineLengthFixer::class,
 
-        // double to Double false positive
-        PhpdocTypesFixer::class => [__DIR__ . '/rules/Php74/Rector/Double/RealToFloatTypeCastRector.php'],
+        PhpdocTypesFixer::class => [
+            // double to Double false positive
+            __DIR__ . '/rules/Php74/Rector/Double/RealToFloatTypeCastRector.php',
+            // skip for enum types
+            __DIR__ . '/rules/Php70/Rector/MethodCall/ThisCallOnStaticMethodToStaticCallRector.php',
+        ],
 
         // breaking and handled better by Rector PHPUnit code quality set, removed in symplify dev-main
         PhpUnitStrictFixer::class,

diff --git a/packages-tests/NodeTypeResolver/StaticTypeMapper/StaticTypeMapperTest.php b/packages-tests/NodeTypeResolver/StaticTypeMapper/StaticTypeMapperTest.php
@@ -63,7 +63,7 @@ public function testMapPHPStanTypeToPHPStanPhpDocTypeNode(): void
 
         $phpStanDocTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode(
             $iterableType,
-            TypeKind::ANY()
+            TypeKind::ANY
         );
         $this->assertInstanceOf(ArrayTypeNode::class, $phpStanDocTypeNode);
 
@@ -77,7 +77,7 @@ public function testMixed(): void
 
         $phpStanDocTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode(
             $mixedType,
-            TypeKind::ANY()
+            TypeKind::ANY
         );
         $this->assertInstanceOf(IdentifierTypeNode::class, $phpStanDocTypeNode);
     }

diff --git a/packages-tests/PHPStanStaticTypeMapper/TypeMapper/ArrayTypeMapperTest.php b/packages-tests/PHPStanStaticTypeMapper/TypeMapper/ArrayTypeMapperTest.php
@@ -31,7 +31,7 @@ protected function setUp(): void
      */
     public function testWithoutKeys(ArrayType $arrayType, string $expectedResult): void
     {
-        $actualTypeNode = $this->arrayTypeMapper->mapToPHPStanPhpDocTypeNode($arrayType, TypeKind::ANY());
+        $actualTypeNode = $this->arrayTypeMapper->mapToPHPStanPhpDocTypeNode($arrayType, TypeKind::ANY);
         $this->assertSame($expectedResult, (string) $actualTypeNode);
     }
 
@@ -40,7 +40,7 @@ public function testWithoutKeys(ArrayType $arrayType, string $expectedResult): v
      */
     public function testWithKeys(ArrayType $arrayType, string $expectedResult): void
     {
-        $actualTypeNode = $this->arrayTypeMapper->mapToPHPStanPhpDocTypeNode($arrayType, TypeKind::ANY());
+        $actualTypeNode = $this->arrayTypeMapper->mapToPHPStanPhpDocTypeNode($arrayType, TypeKind::ANY);
         $this->assertSame($expectedResult, (string) $actualTypeNode);
     }
 

diff --git a/packages/BetterPhpDocParser/PhpDocManipulator/PhpDocTypeChanger.php b/packages/BetterPhpDocParser/PhpDocManipulator/PhpDocTypeChanger.php
@@ -78,7 +78,7 @@ public function changeVarType(PhpDocInfo $phpDocInfo, Type $newType): void
         // override existing type
         $newPHPStanPhpDocType = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode(
             $newType,
-            TypeKind::PROPERTY()
+            TypeKind::PROPERTY
         );
 
         $currentVarTagValueNode = $phpDocInfo->getVarTagValueNode();
@@ -108,7 +108,7 @@ public function changeReturnType(PhpDocInfo $phpDocInfo, Type $newType): bool
         // override existing type
         $newPHPStanPhpDocType = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode(
             $newType,
-            TypeKind::RETURN()
+            TypeKind::RETURN
         );
 
         $currentReturnTagValueNode = $phpDocInfo->getReturnTagValue();
@@ -132,7 +132,7 @@ public function changeParamType(PhpDocInfo $phpDocInfo, Type $newType, Param $pa
             return;
         }
 
-        $phpDocType = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode($newType, TypeKind::PARAM());
+        $phpDocType = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode($newType, TypeKind::PARAM);
         $paramTagValueNode = $phpDocInfo->getParamTagValueByName($paramName);
 
         // override existing type

diff --git a/packages/FamilyTree/Reflection/FamilyRelationsAnalyzer.php b/packages/FamilyTree/Reflection/FamilyRelationsAnalyzer.php
@@ -106,7 +106,7 @@ public function getPossibleUnionPropertyType(
             $varType = new UnionType([$varType, new NullType()]);
             $propertyTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode(
                 $varType,
-                TypeKind::PROPERTY()
+                TypeKind::PROPERTY
             );
 
             return new PropertyType($varType, $propertyTypeNode);

diff --git a/packages/NodeCollector/NodeAnalyzer/ArrayCallableMethodMatcher.php b/packages/NodeCollector/NodeAnalyzer/ArrayCallableMethodMatcher.php
@@ -149,7 +149,7 @@ private function resolveClassConstFetchType(ClassConstFetch $classConstFetch): M
     {
         $classConstantReference = $this->valueResolver->getValue($classConstFetch);
 
-        if (ObjectReference::STATIC()->getValue() === $classConstantReference) {
+        if ($classConstantReference === ObjectReference::STATIC) {
             $classLike = $this->betterNodeFinder->findParentType($classConstFetch, Class_::class);
             if (! $classLike instanceof ClassLike) {
                 return new MixedType();

diff --git a/packages/NodeTypeResolver/NodeTypeResolver/NameTypeResolver.php b/packages/NodeTypeResolver/NodeTypeResolver/NameTypeResolver.php
@@ -48,7 +48,7 @@ public function getNodeClasses(): array
      */
     public function resolve(Node $node): Type
     {
-        if ($node->toString() === ObjectReference::PARENT()->getValue()) {
+        if ($node->toString() === ObjectReference::PARENT) {
             return $this->resolveParent($node);
         }
 
@@ -99,11 +99,7 @@ private function resolveFullyQualifiedName(Name $name): string
     {
         $nameValue = $name->toString();
 
-        if (in_array(
-            $nameValue,
-            [ObjectReference::SELF()->getValue(), ObjectReference::STATIC()->getValue(), 'this'],
-            true
-        )) {
+        if (in_array($nameValue, [ObjectReference::SELF, ObjectReference::STATIC, 'this'], true)) {
             $classLike = $this->betterNodeFinder->findParentType($name, ClassLike::class);
             if (! $classLike instanceof ClassLike) {
                 return $name->toString();

diff --git a/packages/NodeTypeResolver/NodeTypeResolver/NewTypeResolver.php b/packages/NodeTypeResolver/NodeTypeResolver/NewTypeResolver.php
@@ -47,11 +47,7 @@ public function resolve(Node $node): Type
     {
         if ($node->class instanceof Name) {
             $className = $this->nodeNameResolver->getName($node->class);
-            if (! in_array(
-                $className,
-                [ObjectReference::SELF()->getValue(), ObjectReference::PARENT()->getValue()],
-                true
-            )) {
+            if (! in_array($className, [ObjectReference::SELF, ObjectReference::PARENT], true)) {
                 return new ObjectType($className);
             }
         }

diff --git a/packages/NodeTypeResolver/PhpDocNodeVisitor/ClassRenamePhpDocNodeVisitor.php b/packages/NodeTypeResolver/PhpDocNodeVisitor/ClassRenamePhpDocNodeVisitor.php
@@ -62,7 +62,7 @@ public function enterNode(Node $node): ?Node
 
             $newTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode(
                 $oldToNewType->getNewType(),
-                TypeKind::ANY()
+                TypeKind::ANY
             );
 
             $parentType = $node->getAttribute(PhpDocAttributeKey::PARENT);

diff --git a/packages/PHPStanStaticTypeMapper/Contract/TypeMapperInterface.php b/packages/PHPStanStaticTypeMapper/Contract/TypeMapperInterface.php
@@ -23,12 +23,14 @@ public function getNodeClass(): string;
 
     /**
      * @param TType $type
+     * @param TypeKind::* $typeKind
      */
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode;
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode;
 
     /**
      * @param TType $type
+     * @param TypeKind::* $typeKind
      * @return Name|ComplexType|null
      */
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): ?Node;
+    public function mapToPhpParserNode(Type $type, string $typeKind): ?Node;
 }
diff --git a/packages/PHPStanStaticTypeMapper/Enum/TypeKind.php b/packages/PHPStanStaticTypeMapper/Enum/TypeKind.php
@@ -4,33 +4,25 @@
 
 namespace Rector\PHPStanStaticTypeMapper\Enum;
 
-use MyCLabs\Enum\Enum;
-
-/**
- * @method static TypeKind PROPERTY()
- * @method static TypeKind RETURN()
- * @method static TypeKind PARAM()
- * @method static TypeKind ANY()
- */
-final class TypeKind extends Enum
+final class TypeKind
 {
     /**
      * @var string
      */
-    private const PROPERTY = 'property';
+    public const PROPERTY = 'property';
 
     /**
      * @var string
      */
-    private const RETURN = 'return';
+    public const RETURN = 'return';
 
     /**
      * @var string
      */
-    private const PARAM = 'param';
+    public const PARAM = 'param';
 
     /**
      * @var string
      */
-    private const ANY = 'any';
+    public const ANY = 'any';
 }
diff --git a/packages/PHPStanStaticTypeMapper/PHPStanStaticTypeMapper.php b/packages/PHPStanStaticTypeMapper/PHPStanStaticTypeMapper.php
@@ -26,7 +26,10 @@ public function __construct(
     ) {
     }
 
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode
+    /**
+     * @param TypeKind::* $typeKind
+     */
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode
     {
         foreach ($this->typeMappers as $typeMapper) {
             if (! is_a($type, $typeMapper->getNodeClass(), true)) {
@@ -51,7 +54,10 @@ public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): Type
         throw new NotImplementedYetException(__METHOD__ . ' for ' . $type::class);
     }
 
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): Name | ComplexType | null
+    /**
+     * @param TypeKind::* $typeKind
+     */
+    public function mapToPhpParserNode(Type $type, string $typeKind): Name | ComplexType | null
     {
         foreach ($this->typeMappers as $typeMapper) {
             if (! is_a($type, $typeMapper->getNodeClass(), true)) {

diff --git a/packages/PHPStanStaticTypeMapper/TypeMapper/AccessoryNonEmptyStringTypeMapper.php b/packages/PHPStanStaticTypeMapper/TypeMapper/AccessoryNonEmptyStringTypeMapper.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Type;
 use Rector\PHPStanStaticTypeMapper\Contract\TypeMapperInterface;
-use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 
 /**
  * @implements TypeMapperInterface<AccessoryNonEmptyStringType>
@@ -29,15 +28,15 @@ public function getNodeClass(): string
     /**
      * @param AccessoryNonEmptyStringType $type
      */
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode
     {
         return new IdentifierTypeNode('string');
     }
 
     /**
      * @param AccessoryNonEmptyStringType $type
      */
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): ?Node
+    public function mapToPhpParserNode(Type $type, string $typeKind): ?Node
     {
         return new Name('string');
     }

diff --git a/packages/PHPStanStaticTypeMapper/TypeMapper/AccessoryNumericStringTypeMapper.php b/packages/PHPStanStaticTypeMapper/TypeMapper/AccessoryNumericStringTypeMapper.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\Accessory\AccessoryNumericStringType;
 use PHPStan\Type\Type;
 use Rector\PHPStanStaticTypeMapper\Contract\TypeMapperInterface;
-use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 
 /**
  * @implements TypeMapperInterface<AccessoryNumericStringType>
@@ -29,15 +28,15 @@ public function getNodeClass(): string
     /**
      * @param AccessoryNumericStringType $type
      */
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode
     {
         return new IdentifierTypeNode('string');
     }
 
     /**
      * @param AccessoryNumericStringType $type
      */
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): ?Node
+    public function mapToPhpParserNode(Type $type, string $typeKind): ?Node
     {
         return new Name('string');
     }

diff --git a/packages/PHPStanStaticTypeMapper/TypeMapper/ArrayShapeTypeMapper.php b/packages/PHPStanStaticTypeMapper/TypeMapper/ArrayShapeTypeMapper.php
@@ -50,7 +50,7 @@ public function mapConstantArrayType(ConstantArrayType $constantArrayType): Arra
 
             $valueDocTypeNode = $this->phpStanStaticTypeMapper->mapToPHPStanPhpDocTypeNode(
                 $valueType,
-                TypeKind::RETURN()
+                TypeKind::RETURN
             );
 
             $arrayShapeItemNodes[] = new ArrayShapeItemNode(

diff --git a/packages/PHPStanStaticTypeMapper/TypeMapper/ArrayTypeMapper.php b/packages/PHPStanStaticTypeMapper/TypeMapper/ArrayTypeMapper.php
@@ -83,17 +83,18 @@ public function getNodeClass(): string
     }
 
     /**
+     * @param TypeKind::* $typeKind
      * @param ArrayType $type
      */
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode
     {
         $itemType = $type->getItemType();
 
         if ($itemType instanceof UnionType && ! $type instanceof ConstantArrayType) {
             return $this->createArrayTypeNodeFromUnionType($itemType, $typeKind);
         }
 
-        if ($type instanceof ConstantArrayType && $typeKind->equals(TypeKind::RETURN())) {
+        if ($type instanceof ConstantArrayType && $typeKind === TypeKind::RETURN) {
             $arrayShapeNode = $this->arrayShapeTypeMapper->mapConstantArrayType($type);
             if ($arrayShapeNode instanceof TypeNode) {
                 return $arrayShapeNode;
@@ -121,14 +122,17 @@ public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): Type
     /**
      * @param ArrayType $type
      */
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): ?Node
+    public function mapToPhpParserNode(Type $type, string $typeKind): ?Node
     {
         return new Name('array');
     }
 
+    /**
+     * @param TypeKind::* $typeKind
+     */
     private function createArrayTypeNodeFromUnionType(
         UnionType $unionType,
-        TypeKind $typeKind
+        string $typeKind
     ): SpacingAwareArrayTypeNode {
         $unionedArrayType = [];
         foreach ($unionType->getTypes() as $unionedType) {
@@ -183,9 +187,12 @@ private function isGenericArrayCandidate(ArrayType $arrayType): bool
         return false;
     }
 
+    /**
+     * @param TypeKind::* $typeKind
+     */
     private function createGenericArrayType(
         ArrayType $arrayType,
-        TypeKind $typeKind,
+        string $typeKind,
         bool $withKey = false
     ): GenericTypeNode {
         $itemType = $arrayType->getItemType();
@@ -248,10 +255,13 @@ private function isIntegerKeyAndNonNestedArray(ArrayType $arrayType): bool
         return ! $arrayType->getItemType() instanceof ArrayType;
     }
 
+    /**
+     * @param TypeKind::* $typeKind
+     */
     private function narrowConstantArrayTypeOfUnionType(
         ArrayType $arrayType,
         Type $itemType,
-        TypeKind $typeKind
+        string $typeKind
     ): ?TypeNode {
         if ($arrayType instanceof ConstantArrayType && $itemType instanceof UnionType) {
             $narrowedItemType = $this->unionTypeCommonTypeNarrower->narrowToSharedObjectType($itemType);
@@ -272,9 +282,12 @@ private function narrowConstantArrayTypeOfUnionType(
         return null;
     }
 
+    /**
+     * @param TypeKind::* $typeKind
+     */
     private function createTypeNodeFromGenericClassStringType(
         GenericClassStringType $genericClassStringType,
-        TypeKind $typeKind
+        string $typeKind
     ): IdentifierTypeNode|GenericTypeNode {
         $genericType = $genericClassStringType->getGenericType();
         if ($genericType instanceof ObjectType && ! $this->reflectionProvider->hasClass($genericType->getClassName())) {

diff --git a/packages/PHPStanStaticTypeMapper/TypeMapper/BooleanTypeMapper.php b/packages/PHPStanStaticTypeMapper/TypeMapper/BooleanTypeMapper.php
@@ -14,7 +14,6 @@
 use Rector\Core\Php\PhpVersionProvider;
 use Rector\Core\ValueObject\PhpVersionFeature;
 use Rector\PHPStanStaticTypeMapper\Contract\TypeMapperInterface;
-use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 
 /**
  * @implements TypeMapperInterface<BooleanType>
@@ -37,7 +36,7 @@ public function getNodeClass(): string
     /**
      * @param BooleanType $type
      */
-    public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): TypeNode
+    public function mapToPHPStanPhpDocTypeNode(Type $type, string $typeKind): TypeNode
     {
         if ($this->isFalseBooleanTypeWithUnion($type)) {
             return new IdentifierTypeNode('false');
@@ -54,7 +53,7 @@ public function mapToPHPStanPhpDocTypeNode(Type $type, TypeKind $typeKind): Type
     /**
      * @param BooleanType $type
      */
-    public function mapToPhpParserNode(Type $type, TypeKind $typeKind): ?Node
+    public function mapToPhpParserNode(Type $type, string $typeKind): ?Node
     {
         if (! $this->phpVersionProvider->isAtLeastPhpVersion(PhpVersionFeature::SCALAR_TYPES)) {
             return null;