feature: introducing proper handling of value-of in combination wit…

…h backed enums This introduces both: - a bugfix for a regression introduced by `31eaf83c4` which prevents backed enums are incorrectly identified as literals - an additional feature so that `value-of` can be used with backed enums to assert any of the enum cases values Signed-off-by: Maximilian Bösing <[email protected]>
vimeo · Aug 25, 2023 · 5948559 · 5948559
1 parent 31eaf83
commit 5948559
Show file tree

Hide file tree

Showing 3 changed files with 82 additions and 2 deletions.
diff --git a/src/Psalm/Internal/Type/SimpleAssertionReconciler.php b/src/Psalm/Internal/Type/SimpleAssertionReconciler.php
@@ -83,6 +83,7 @@
 use function count;
 use function explode;
 use function get_class;
+use function in_array;
 use function is_int;
 use function min;
 use function strlen;
@@ -533,7 +534,10 @@ public static function reconcile(
         }
 
         if ($assertion_type instanceof TValueOf) {
-            return $assertion_type->type;
+            return self::reconcileValueOf(
+                $codebase,
+                $assertion_type
+            );
         }
 
         return null;
@@ -2951,6 +2955,58 @@ private static function reconcileClassConstant(
         return TypeCombiner::combine(array_values($matched_class_constant_types), $codebase);
     }
 
+    private static function reconcileValueOf(
+        Codebase $codebase,
+        TValueOf $assertion_type
+    ): ?Union {
+        $reconciled_types = [];
+
+        // For now, only enums are supported here
+        foreach ($assertion_type->type->getAtomicTypes() as $atomic_type) {
+            $class_name = null;
+            $enum_case_to_assert = null;
+            if ($atomic_type instanceof TClassConstant) {
+                $class_name = $atomic_type->fq_classlike_name;
+                $enum_case_to_assert = $atomic_type->const_name;
+            } elseif ($atomic_type instanceof TNamedObject) {
+                $class_name = $atomic_type->value;
+            } else {
+                return null;
+            }
+
+            if (!$codebase->classOrInterfaceOrEnumExists($class_name)) {
+                return null;
+            }
+
+            $class_storage = $codebase->classlike_storage_provider->get($class_name);
+            if (!$class_storage->is_enum) {
+                return null;
+            }
+
+            if (!in_array($class_storage->enum_type, ['string', 'int'], true)) {
+                return null;
+            }
+
+            // For value-of<MyBackedEnum>, the assertion is meant to return *ANY* value of *ANY* enum case
+            if ($enum_case_to_assert === null) {
+                foreach ($class_storage->enum_cases as $enum_case) {
+                    $reconciled_types[] = Type::getLiteral($enum_case->value);
+                }
+
+                continue;
+            }
+
+            $enum_case = $class_storage->enum_cases[$atomic_type->const_name] ?? null;
+            if ($enum_case === null) {
+                return null;
+            }
+
+            $reconciled_types[] = Type::getLiteral($enum_case->value);
+        }
+
+        return new Union($reconciled_types);
+    }
+
     /**
      * @psalm-assert-if-true TCallableObject|TObjectWithProperties|TNamedObject $type
      */

diff --git a/src/Psalm/Type.php b/src/Psalm/Type.php
@@ -58,6 +58,7 @@
 use function explode;
 use function get_class;
 use function implode;
+use function is_int;
 use function preg_quote;
 use function preg_replace;
 use function stripos;
@@ -258,6 +259,19 @@ public static function getNumericString(): Union
         return new Union([$type]);
     }
 
+    /**
+     * @param int|string $value
+     * @return TLiteralString|TLiteralInt
+     */
+    public static function getLiteral($value)
+    {
+        if (is_int($value)) {
+            return new TLiteralInt($value);
+        }
+
+        return new TLiteralString($value);
+    }
+
     public static function getString(?string $value = null): Union
     {
         return new Union([$value === null ? new TString() : self::getAtomicStringFromLiteral($value)]);

diff --git a/tests/AssertAnnotationTest.php b/tests/AssertAnnotationTest.php
@@ -2194,6 +2194,10 @@ function assertSomeString(string $foo): void
                     function assertSomeInt(int $foo): void
                     {}
 
+                    /** @psalm-assert value-of<StringEnum|IntEnum> $foo */
+                    function assertAnyEnumValue(string|int $foo): void
+                    {}
+
                     /** @param "foo"|"bar" $foo */
                     function takesSomeStringFromEnum(string $foo): StringEnum
                     {
@@ -2216,8 +2220,14 @@ function takesSomeIntFromEnum(int $foo): IntEnum
 
                     assertSomeInt($int);
                     takesSomeIntFromEnum($int);
+
+                    /** @var string|int $potentialEnumValue */
+                    $potentialEnumValue = null;
+                    assertAnyEnumValue($potentialEnumValue);
                 ',
-                'assertions' => [],
+                'assertions' => [
+                    '$potentialEnumValue===' => "'bar'|'baz'|'foo'|1|2|3",
+                ],
                 'ignored_issues' => [],
                 'php_version' => '8.1',
             ],