Auto-detect values for EnumType columns

psalm-baseline.xml

@@ -212,14 +212,14 @@
     </ParamNameMismatch>
   </file>
   <file src="src/Internal/Hydration/AbstractHydrator.php">
-    <ReferenceConstraintViolation>
-      <code><![CDATA[return $rowData;]]></code>
-      <code><![CDATA[return $rowData;]]></code>
-    </ReferenceConstraintViolation>
     <PossiblyUndefinedArrayOffset>
       <code><![CDATA[$newObject['args']]]></code>
       <code><![CDATA[$newObject['args']]]></code>
     </PossiblyUndefinedArrayOffset>
+    <ReferenceConstraintViolation>
+      <code><![CDATA[return $rowData;]]></code>
+      <code><![CDATA[return $rowData;]]></code>
+    </ReferenceConstraintViolation>
   </file>
   <file src="src/Internal/Hydration/ArrayHydrator.php">
     <PossiblyInvalidArgument>
@@ -402,6 +402,7 @@
   <file src="src/Mapping/DefaultTypedFieldMapper.php">
     <LessSpecificReturnStatement>
       <code><![CDATA[$mapping]]></code>
+      <code><![CDATA[$mapping]]></code>
     </LessSpecificReturnStatement>
     <MoreSpecificReturnType>
       <code><![CDATA[array]]></code>

src/Mapping/ClassMetadata.php

@@ -7,6 +7,8 @@
 use BackedEnum;
 use BadMethodCallException;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\EnumType;
+use Doctrine\DBAL\Types\Types;
 use Doctrine\Deprecations\Deprecation;
 use Doctrine\Instantiator\Instantiator;
 use Doctrine\Instantiator\InstantiatorInterface;
@@ -23,6 +25,7 @@
 use ReflectionProperty;
 use Stringable;
 
+use function array_column;
 use function array_diff;
 use function array_intersect;
 use function array_key_exists;
@@ -1119,9 +1122,7 @@ private function validateAndCompleteTypedFieldMapping(array $mapping): array
     {
         $field = $this->reflClass->getProperty($mapping['fieldName']);
 
-        $mapping = $this->typedFieldMapper->validateAndComplete($mapping, $field);
-
-        return $mapping;
+        return $this->typedFieldMapper->validateAndComplete($mapping, $field);
     }
 
     /**
@@ -1232,6 +1233,10 @@ protected function validateAndCompleteFieldMapping(array $mapping): FieldMapping
             if (! empty($mapping->id)) {
                 $this->containsEnumIdentifier = true;
             }
+
+            if (class_exists(EnumType::class) && $mapping->type === Types::ENUM && ! isset($mapping->options['values'])) {
+                $mapping->options['values'] = array_column($mapping->enumType::cases(), 'value');
+            }
         }
 
         return $mapping;

src/Mapping/DefaultTypedFieldMapper.php

@@ -49,30 +49,37 @@ public function validateAndComplete(array $mapping, ReflectionProperty $field):
     {
         $type = $field->getType();
 
+        if (! $type instanceof ReflectionNamedType) {
+            return $mapping;
+        }
+
         if (
-            ! isset($mapping['type'])
-            && ($type instanceof ReflectionNamedType)
+            ! $type->isBuiltin()
+            && enum_exists($type->getName())
+            && (! isset($mapping['type']) || $mapping['type'] === 'enum')
         ) {
-            if (! $type->isBuiltin() && enum_exists($type->getName())) {
-                $reflection = new ReflectionEnum($type->getName());
-                if (! $reflection->isBacked()) {
-                    throw MappingException::backedEnumTypeRequired(
-                        $field->class,
-                        $mapping['fieldName'],
-                        $type->getName(),
-                    );
-                }
+            $reflection = new ReflectionEnum($type->getName());
+            if (! $reflection->isBacked()) {
+                throw MappingException::backedEnumTypeRequired(
+                    $field->class,
+                    $mapping['fieldName'],
+                    $type->getName(),
+                );
+            }
 
-                assert(is_a($type->getName(), BackedEnum::class, true));
-                $mapping['enumType'] = $type->getName();
-                $type                = $reflection->getBackingType();
+            assert(is_a($type->getName(), BackedEnum::class, true));
+            $mapping['enumType'] = $type->getName();
+            $type                = $reflection->getBackingType();
 
-                assert($type instanceof ReflectionNamedType);
-            }
+            assert($type instanceof ReflectionNamedType);
+        }
 
-            if (isset($this->typedFieldMappings[$type->getName()])) {
-                $mapping['type'] = $this->typedFieldMappings[$type->getName()];
-            }
+        if (isset($mapping['type'])) {
+            return $mapping;
+        }
+
+        if (isset($this->typedFieldMappings[$type->getName()])) {
+            $mapping['type'] = $this->typedFieldMappings[$type->getName()];
         }
 
         return $mapping;

tests/Tests/Models/Enums/CardNativeEnum.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\Enums;
+
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+
+#[Entity]
+class CardNativeEnum
+{
+    /** @var int|null */
+    #[Id]
+    #[GeneratedValue]
+    #[Column(type: Types::INTEGER)]
+    public $id;
+
+    /** @var Suit */
+    #[Column(type: Types::ENUM, enumType: Suit::class, options: ['values' => ['H', 'D', 'C', 'S']])]
+    public $suit;
+}

tests/Tests/Models/Enums/TypedCardNativeEnum.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\Models\Enums;
+
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+
+#[Entity]
+class TypedCardNativeEnum
+{
+    #[Id]
+    #[GeneratedValue]
+    #[Column]
+    public int $id;
+
+    #[Column(type: Types::ENUM)]
+    public Suit $suit;
+}

tests/Tests/ORM/Functional/EnumTest.php

@@ -4,6 +4,7 @@
 
 namespace Doctrine\Tests\ORM\Functional;
 
+use Doctrine\DBAL\Types\EnumType;
 use Doctrine\ORM\AbstractQuery;
 use Doctrine\ORM\Mapping\Column;
 use Doctrine\ORM\Mapping\Driver\AttributeDriver;
@@ -13,17 +14,20 @@
 use Doctrine\Tests\Models\DataTransferObjects\DtoWithArrayOfEnums;
 use Doctrine\Tests\Models\DataTransferObjects\DtoWithEnum;
 use Doctrine\Tests\Models\Enums\Card;
+use Doctrine\Tests\Models\Enums\CardNativeEnum;
 use Doctrine\Tests\Models\Enums\CardWithDefault;
 use Doctrine\Tests\Models\Enums\CardWithNullable;
 use Doctrine\Tests\Models\Enums\Product;
 use Doctrine\Tests\Models\Enums\Quantity;
 use Doctrine\Tests\Models\Enums\Scale;
 use Doctrine\Tests\Models\Enums\Suit;
 use Doctrine\Tests\Models\Enums\TypedCard;
+use Doctrine\Tests\Models\Enums\TypedCardNativeEnum;
 use Doctrine\Tests\Models\Enums\Unit;
 use Doctrine\Tests\OrmFunctionalTestCase;
 use PHPUnit\Framework\Attributes\DataProvider;
 
+use function class_exists;
 use function dirname;
 use function sprintf;
 use function uniqid;
@@ -55,7 +59,7 @@ public function testEnumMapping(string $cardClass): void
         $this->_em->flush();
         $this->_em->clear();
 
-        $fetchedCard = $this->_em->find(Card::class, $card->id);
+        $fetchedCard = $this->_em->find($cardClass, $card->id);
 
         $this->assertInstanceOf(Suit::class, $fetchedCard->suit);
         $this->assertEquals(Suit::Clubs, $fetchedCard->suit);
@@ -447,13 +451,16 @@ public function testEnumWithNonMatchingDatabaseValueThrowsException(string $card
         $this->_em->find($cardClass, $card->id);
     }
 
-    /** @return array<string, array{class-string}> */
-    public static function provideCardClasses(): array
+    /** @return iterable<string, array{class-string}> */
+    public static function provideCardClasses(): iterable
     {
-        return [
-            Card::class => [Card::class],
-            TypedCard::class => [TypedCard::class],
-        ];
+        yield Card::class => [Card::class];
+        yield TypedCard::class => [TypedCard::class];
+
+        if (class_exists(EnumType::class)) {
+            yield CardNativeEnum::class => [CardNativeEnum::class];
+            yield TypedCardNativeEnum::class => [TypedCardNativeEnum::class];
+        }
     }
 
     public function testItAllowsReadingAttributes(): void