Drop Flyweight pattern

There is a growing need for types with parameters, and that pattern was
probably used out of concerns that are no longer relevant anyway.

docs/en/reference/types.rst

@@ -905,3 +905,50 @@ hook it into the database platform:
 This would allow using a money type in the ORM for example and
 have Doctrine automatically convert it back and forth to the
 database.
+
+It is also possible to register type instances directly, in case you
+need to pass parameters to your instance::
+
+    <?php
+    namespace My\Project\Types;
+
+    use Doctrine\DBAL\Types\Type;
+    use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+    final class EncryptedType extends StringType
+    {
+        public function __construct(
+            private string $cipher,
+            private string $secretName,
+            private SecretStore $secretStore
+        ) {
+        }
+
+        public function convertToPHPValue($value, AbstractPlatform $platform): string
+        {
+            return openssl_decrypt(
+                $value,
+                $this->cipher,
+                $this->secretStore->fetch($this->secretName)
+            );
+        }
+
+        public function convertToDatabaseValue($value, AbstractPlatform $platform): string
+        {
+            return openssl_encrypt(
+                $value,
+                $this->cipher,
+                $this->secretStore->fetch($this->secretName)
+            );
+        }
+    }
+
+To do that, you can obtain the ``TypeRegistry`` singleton from ``Type``
+and register your type in it::
+
+    <?php
+    Type::getTypeRegistry()->register('encrypted', new EncryptedType(
+        'aes-256-cbc-hmac-sha256',
+        '/path/to/secret',
+        $secretStore
+    ));

src/Types/Type.php

@@ -121,7 +121,6 @@ private static function createTypeRegistry(): TypeRegistry
 
     /**
      * Factory method to create type instances.
-     * Type instances are implemented as flyweights.
      *
      * @param string $name The name of the type.
      *

src/Types/TypeRegistry.php

@@ -12,16 +12,14 @@
 use Doctrine\DBAL\Types\Exception\UnknownColumnType;
 
 use function array_search;
-use function in_array;
 
 /**
  * The type registry is responsible for holding a map of all known DBAL types.
- * The types are stored using the flyweight pattern so that one type only exists as exactly one instance.
  */
 final class TypeRegistry
 {
     /**
-     * Map of type names and their corresponding flyweight objects.
+     * Map of type names and their corresponding objects.
      *
      * @var array<string, Type>
      */
@@ -56,9 +54,9 @@ public function get(string $name): Type
      */
     public function lookupName(Type $type): string
     {
-        $name = $this->findTypeName($type);
+        $name = array_search($type, $this->instances, true);
 
-        if ($name === null) {
+        if ($name === false) {
             throw TypeNotRegistered::new($type);
         }
 
@@ -84,10 +82,6 @@ public function register(string $name, Type $type): void
             throw TypesAlreadyExists::new($name);
         }
 
-        if ($this->findTypeName($type) !== null) {
-            throw TypeAlreadyRegistered::new($type);
-        }
-
         $this->instances[$name] = $type;
     }
 
@@ -102,10 +96,6 @@ public function override(string $name, Type $type): void
             throw TypeNotFound::new($name);
         }
 
-        if (! in_array($this->findTypeName($type), [$name, null], true)) {
-            throw TypeAlreadyRegistered::new($type);
-        }
-
         $this->instances[$name] = $type;
     }
 
@@ -120,15 +110,4 @@ public function getMap(): array
     {
         return $this->instances;
     }
-
-    private function findTypeName(Type $type): ?string
-    {
-        $name = array_search($type, $this->instances, true);
-
-        if ($name === false) {
-            return null;
-        }
-
-        return $name;
-    }
 }

tests/Types/TypeRegistryTest.php

@@ -84,7 +84,7 @@ public function testRegister(): void
         self::assertSame($newType, $this->registry->get('some'));
     }
 
-    public function testRegisterWithAlradyRegisteredName(): void
+    public function testRegisterWithAlreadyRegisteredName(): void
     {
         $this->registry->register('some', new TextType());
 
@@ -97,9 +97,11 @@ public function testRegisterWithAlreadyRegisteredInstance(): void
         $newType = new TextType();
 
         $this->registry->register('some', $newType);
-
-        $this->expectException(Exception::class);
-        $this->registry->register('other', $newType);
+        $this->registry->register('sameButDifferent', $newType);
+        self::assertSame(
+            $this->registry->get('some'),
+            $this->registry->get('sameButDifferent')
+        );
     }
 
     public function testOverride(): void
@@ -123,17 +125,6 @@ public function testOverrideAllowsExistingInstance(): void
         self::assertSame($type, $this->registry->get('some'));
     }
 
-    public function testOverrideWithAlreadyRegisteredInstance(): void
-    {
-        $newType = new TextType();
-
-        $this->registry->register('first', $newType);
-        $this->registry->register('second', new StringType());
-
-        $this->expectException(Exception::class);
-        $this->registry->override('second', $newType);
-    }
-
     public function testOverrideWithUnknownType(): void
     {
         $this->expectException(Exception::class);