Improve detection of the type from a PHP variable

Author: GromNaN

lib/Doctrine/ODM/MongoDB/Types/InvalidTypeException.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ODM\MongoDB\Types;
+
+use InvalidArgumentException;
+
+use function sprintf;
+
+final class InvalidTypeException extends InvalidArgumentException
+{
+    public static function invalidTypeName(string $name): self
+    {
+        return new self(sprintf('Invalid type specified "%s".', $name));
+    }
+}

lib/Doctrine/ODM/MongoDB/Types/Type.php

@@ -4,17 +4,16 @@
 
 namespace Doctrine\ODM\MongoDB\Types;
 
+use DateTimeImmutable;
 use DateTimeInterface;
 use Doctrine\ODM\MongoDB\Mapping\MappingException;
 use Doctrine\ODM\MongoDB\Types;
-use InvalidArgumentException;
 use MongoDB\BSON\ObjectId;
 
 use function end;
 use function explode;
 use function gettype;
 use function is_object;
-use function sprintf;
 use function str_replace;
 
 /**
@@ -140,48 +139,52 @@ public static function registerType(string $name, string $class): void
     /**
      * Get a Type instance.
      *
-     * @throws InvalidArgumentException
+     * @throws InvalidTypeException
      */
     public static function getType(string $type): Type
     {
         if (! isset(self::$typesMap[$type])) {
-            throw new InvalidArgumentException(sprintf('Invalid type specified "%s".', $type));
+            throw InvalidTypeException::invalidTypeName($type);
         }
 
-        if (! isset(self::$typeObjects[$type])) {
-            $className                = self::$typesMap[$type];
-            self::$typeObjects[$type] = new $className();
-        }
-
-        return self::$typeObjects[$type];
+        return self::$typeObjects[$type] ??= new (self::$typesMap[$type]);
     }
 
     /**
      * Get a Type instance based on the type of the passed php variable.
      *
      * @param mixed $variable
-     *
-     * @throws InvalidArgumentException
      */
     public static function getTypeFromPHPVariable($variable): ?Type
     {
         if (is_object($variable)) {
+            if ($variable instanceof DateTimeImmutable) {
+                return self::getType(self::DATE_IMMUTABLE);
+            }
+
             if ($variable instanceof DateTimeInterface) {
-                return self::getType('date');
+                return self::getType(self::DATE);
             }
 
             if ($variable instanceof ObjectId) {
-                return self::getType('id');
+                return self::getType(self::OBJECTID);
             }
-        } else {
-            $type = gettype($variable);
-            switch ($type) {
-                case 'integer':
-                    return self::getType('int');
+
+            // Try the variable class as type name
+            try {
+                return self::getType($variable::class);
+            } catch (InvalidTypeException) {
+                return null;
             }
         }
 
-        return null;
+        return match (gettype($variable)) {
+            'integer' => self::getType('int'),
+            'boolean' => self::getType('bool'),
+            'double' => self::getType('float'),
+            'string' => self::getType('string'),
+            default => null,
+        };
     }
 
     /**

tests/Doctrine/ODM/MongoDB/Tests/Types/TypeTest.php

@@ -20,6 +20,7 @@
 
 use function get_debug_type;
 use function md5;
+use function sprintf;
 use function str_pad;
 use function str_repeat;
 use function time;
@@ -126,6 +127,39 @@ public function testConvertImmutableDate(): void
         self::assertInstanceOf(UTCDateTime::class, Type::convertPHPToDatabaseValue($date));
     }
 
+    #[DataProvider('provideTypeFromPHPVariable')]
+    public function testGetTypeFromPHPVariable(?Type $expectedType, mixed $variable): void
+    {
+        $type = Type::getTypeFromPHPVariable($variable);
+
+        if ($expectedType === null) {
+            self::assertNull($type);
+        } elseif ($type === null) {
+            self::fail(sprintf('Type is null, expected "%s"', $expectedType::class));
+        } else {
+            self::assertInstanceOf($expectedType::class, $type, $type::class);
+        }
+    }
+
+    public static function provideTypeFromPHPVariable(): array
+    {
+        return [
+            'null' => [null, null],
+            'bool' => [Type::getType(Type::BOOL), true],
+            'int' => [Type::getType(Type::INT), 1],
+            'float' => [Type::getType(Type::FLOAT), 3.14],
+            'string' => [Type::getType(Type::STRING), 'ohai'],
+            'DateTime' => [Type::getType(Type::DATE), new DateTime()],
+            'DateTimeImmutable' => [Type::getType(Type::DATE_IMMUTABLE), new DateTimeImmutable()],
+            'ObjectId' => [Type::getType(Type::OBJECTID), new ObjectId()],
+            'unknown object' => [
+                null,
+                new class () {
+                },
+            ],
+        ];
+    }
+
     private static function assertSameTypeAndValue(mixed $expected, mixed $actual): void
     {
         self::assertSame(get_debug_type($expected), get_debug_type($actual));