Adds metadata field type validation against Entity property type

lib/Doctrine/ORM/Mapping/DefaultTypedFieldMapper.php

@@ -7,6 +7,27 @@
 use DateInterval;
 use DateTime;
 use DateTimeImmutable;
+use Doctrine\DBAL\Types\AsciiStringType;
+use Doctrine\DBAL\Types\BigIntType;
+use Doctrine\DBAL\Types\BooleanType;
+use Doctrine\DBAL\Types\DateImmutableType;
+use Doctrine\DBAL\Types\DateIntervalType;
+use Doctrine\DBAL\Types\DateTimeImmutableType;
+use Doctrine\DBAL\Types\DateTimeType;
+use Doctrine\DBAL\Types\DateTimeTzImmutableType;
+use Doctrine\DBAL\Types\DateTimeTzType;
+use Doctrine\DBAL\Types\DateType;
+use Doctrine\DBAL\Types\DecimalType;
+use Doctrine\DBAL\Types\FloatType;
+use Doctrine\DBAL\Types\GuidType;
+use Doctrine\DBAL\Types\IntegerType;
+use Doctrine\DBAL\Types\JsonType;
+use Doctrine\DBAL\Types\SimpleArrayType;
+use Doctrine\DBAL\Types\SmallIntType;
+use Doctrine\DBAL\Types\StringType;
+use Doctrine\DBAL\Types\TextType;
+use Doctrine\DBAL\Types\TimeImmutableType;
+use Doctrine\DBAL\Types\TimeType;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\DBAL\Types\Types;
 use ReflectionEnum;
@@ -36,12 +57,47 @@ final class DefaultTypedFieldMapper implements TypedFieldMapper
         'string' => Types::STRING,
     ];
 
+    /** It maps built-in Doctrine types to PHP types */
+    private const BUILTIN_TYPES_MAP = [
+        AsciiStringType::class => 'string',
+        BigIntType::class => 'string',
+        BooleanType::class => 'bool',
+        DateType::class => DateTime::class,
+        DateImmutableType::class => DateTimeImmutable::class,
+        DateIntervalType::class => DateInterval::class,
+        DateTimeType::class => DateTime::class,
+        DateTimeImmutableType::class => DateTimeImmutable::class,
+        DateTimeTzType::class => DateTime::class,
+        DateTimeTzImmutableType::class => DateTimeImmutable::class,
+        DecimalType::class => 'string',
+        FloatType::class => 'float',
+        GuidType::class => 'string',
+        IntegerType::class => 'int',
+        JsonType::class => 'array',
+        SimpleArrayType::class => 'array',
+        SmallIntType::class => 'int',
+        StringType::class => 'string',
+        TextType::class => 'string',
+        TimeType::class => DateTime::class,
+        TimeImmutableType::class => DateTimeImmutable::class,
+    ];
+
     /** @param array<class-string|ScalarName, class-string<Type>|string> $typedFieldMappings */
     public function __construct(array $typedFieldMappings = [])
     {
         $this->typedFieldMappings = array_merge(self::DEFAULT_TYPED_FIELD_MAPPINGS, $typedFieldMappings);
     }
 
+    /**
+     * @internal
+     *
+     * @param class-string<Type> $typeName
+     */
+    public function getBuiltInType(string $typeName): string
+    {
+        return self::BUILTIN_TYPES_MAP[$typeName] ?? $typeName;
+    }
+
     /**
      * {@inheritDoc}
      */

lib/Doctrine/ORM/Tools/SchemaValidator.php

@@ -9,9 +9,14 @@
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Doctrine\ORM\Mapping\ClassMetadataInfo;
+use Doctrine\ORM\Mapping\DefaultTypedFieldMapper;
+use ReflectionNamedType;
 
 use function array_diff;
+use function array_filter;
 use function array_key_exists;
+use function array_map;
+use function array_push;
 use function array_search;
 use function array_values;
 use function class_exists;
@@ -20,11 +25,14 @@
 use function get_class;
 use function implode;
 use function in_array;
+use function sprintf;
 
 /**
  * Performs strict validation of the mapping schema
  *
  * @link        www.doctrine-project.com
+ *
+ * @psalm-import-type FieldMapping from ClassMetadataInfo
  */
 class SchemaValidator
 {
@@ -92,6 +100,8 @@ public function validateClass(ClassMetadataInfo $class)
             }
         }
 
+        array_push($ce, ...$this->validatePropertiesTypes($class));
+
         if ($class->isEmbeddedClass && count($class->associationMappings) > 0) {
             $ce[] = "Embeddable '" . $class->name . "' does not support associations";
 
@@ -298,4 +308,47 @@ public function getUpdateSchemaList(): array
 
         return $schemaTool->getUpdateSchemaSql($allMetadata, true);
     }
+
+    /** @return list<string> containing the found issues */
+    private function validatePropertiesTypes(ClassMetadataInfo $class): array
+    {
+        return array_values(
+            array_filter(
+                array_map(
+                    /** @param FieldMapping $fieldMapping */
+                    static function (array $fieldMapping) use ($class): string|null {
+                        $fieldName    = $fieldMapping['fieldName'];
+                        $propertyType = $class->reflFields[$fieldName]?->getType();
+
+                        // If the field type is not a built-in type, we cannot check it
+                        if (! Type::hasType($fieldMapping['type'])) {
+                            return null;
+                        }
+
+                        // If the property type is not a named type, we cannot check it
+                        if (! ($propertyType instanceof ReflectionNamedType)) {
+                            return null;
+                        }
+
+                        $metadataFieldType = (new DefaultTypedFieldMapper())->getBuiltInType(get_class(Type::getType($fieldMapping['type'])));
+
+                        // If the property type is the same as the metadata field type, we are ok
+                        if ($metadataFieldType === $propertyType->getName()) {
+                            return null;
+                        }
+
+                        return sprintf(
+                            "The field '%s#%s' has the property type '%s' that differs from the metadata field type '%s'.",
+                            $class->name,
+                            $fieldName,
+                            $propertyType->getName(),
+                            $metadataFieldType,
+                        );
+                    },
+                    $class->fieldMappings,
+                ),
+                static fn (?string $issue) => $issue !== null,
+            )
+        );
+    }
 }

tests/Doctrine/Tests/ORM/Tools/SchemaValidatorTest.php

@@ -45,21 +45,21 @@ protected function setUp(): void
     public function testCmsModelSet(string $path): void
     {
         $this->em->getConfiguration()
-                 ->getMetadataDriverImpl()
-                 ->addPaths([$path]);
+            ->getMetadataDriverImpl()
+            ->addPaths([$path]);
 
         self::assertEmpty($this->validator->validateMapping());
     }
 
     public static function modelSetProvider(): array
     {
         return [
-            'cms'        => [__DIR__ . '/../../Models/CMS'],
-            'company'    => [__DIR__ . '/../../Models/Company'],
-            'ecommerce'  => [__DIR__ . '/../../Models/ECommerce'],
-            'forum'      => [__DIR__ . '/../../Models/Forum'],
+            'cms' => [__DIR__ . '/../../Models/CMS'],
+            'company' => [__DIR__ . '/../../Models/Company'],
+            'ecommerce' => [__DIR__ . '/../../Models/ECommerce'],
+            'forum' => [__DIR__ . '/../../Models/Forum'],
             'navigation' => [__DIR__ . '/../../Models/Navigation'],
-            'routing'    => [__DIR__ . '/../../Models/Routing'],
+            'routing' => [__DIR__ . '/../../Models/Routing'],
         ];
     }
 
@@ -229,6 +229,31 @@ public function testAbstractChildClassNotPresentInDiscriminator(): void
 
         self::assertEmpty($ce);
     }
+
+    public function testMetadataFieldTypeNotCoherentWithEntityPropertyType(): void
+    {
+        $class = $this->em->getClassMetadata(InvalidEntity3::class);
+        $ce    = $this->validator->validateClass($class);
+
+        self::assertEquals(
+            ["The field 'Doctrine\Tests\ORM\Tools\InvalidEntity3#property' has the property type 'int' that differs from the metadata field type 'bool'."],
+            $ce
+        );
+    }
+
+    public function testMetadataFieldTypeNotCoherentWithEntityPropertyTypeWithInheritance(): void
+    {
+        $class = $this->em->getClassMetadata(InvalidChildEntity::class);
+        $ce    = $this->validator->validateClass($class);
+
+        self::assertEquals(
+            [
+                "The field 'Doctrine\Tests\ORM\Tools\InvalidChildEntity#property' has the property type 'int' that differs from the metadata field type 'bool'.",
+                "The field 'Doctrine\Tests\ORM\Tools\InvalidChildEntity#anotherProperty' has the property type 'string' that differs from the metadata field type 'bool'.",
+            ],
+            $ce
+        );
+    }
 }
 
 /** @MappedSuperclass */
@@ -675,3 +700,31 @@ abstract class Issue9095AbstractChild extends Issue9095Parent
 class Issue9095Child extends Issue9095AbstractChild
 {
 }
+
+/** @Entity */
+class InvalidEntity3
+{
+    /**
+     * @var int
+     * @Id
+     * @Column
+     */
+    protected $key;
+
+    /**
+     * @Column(type="boolean")
+     */
+    protected int $property;
+}
+
+/** @Entity */
+class InvalidChildEntity extends InvalidEntity3
+{
+    /** @Column(type="string") */
+    protected int $property;
+
+    /**
+     * @Column(type="boolean")
+     */
+    private string $anotherProperty;
+}