Added mixed type (#1678)

Author: norberttech

src/lib/types/src/Flow/Types/DSL/functions.php

@@ -27,6 +27,7 @@
     EnumType,
     FloatType,
     IntegerType,
+    MixedType,
     NullType,
     ObjectType,
     ResourceType,
@@ -276,6 +277,12 @@ function type_null() : NullType
     return new NullType();
 }
 
+#[DocumentationDSL(module: Module::TYPES, type: DSLType::TYPE)]
+function type_mixed() : MixedType
+{
+    return new MixedType();
+}
+
 #[DocumentationDSL(module: Module::TYPES, type: DSLType::TYPE)]
 function type_positive_integer() : PositiveIntegerType
 {

src/lib/types/src/Flow/Types/Exception/InvalidTypeException.php

@@ -8,7 +8,7 @@
 
 final class InvalidTypeException extends InvalidArgumentException
 {
-    private function __construct(string $message, ?\Throwable $previous = null)
+    public function __construct(string $message, ?\Throwable $previous = null)
     {
         parent::__construct($message, 0, $previous);
     }

src/lib/types/src/Flow/Types/Type/Logical/OptionalType.php

@@ -4,9 +4,9 @@
 
 namespace Flow\Types\Type\Logical;
 
-use Flow\Types\Exception\InvalidArgumentException;
+use Flow\Types\Exception\InvalidTypeException;
+use Flow\Types\Type\{Native\MixedType, Type, TypeFactory};
 use Flow\Types\Type\Native\UnionType;
-use Flow\Types\Type\{Type, TypeFactory};
 
 /**
  * @template T
@@ -18,16 +18,20 @@
     /**
      * @param Type<T> $base
      *
-     * @throws InvalidArgumentException
+     * @throws InvalidTypeException
      */
     public function __construct(private Type $base)
     {
+        if ($base instanceof MixedType) {
+            throw new InvalidTypeException('Optional type cannot be created from MixedType, mixed is a standalone type');
+        }
+
         if ($base instanceof UnionType) {
-            throw new InvalidArgumentException('Optional type cannot be created from a union type');
+            throw new InvalidTypeException('Optional type cannot be created from a union type');
         }
 
         if ($base instanceof self) {
-            throw new InvalidArgumentException('Optional type cannot be created from an optional type');
+            throw new InvalidTypeException('Optional type cannot be created from an optional type');
         }
     }
 

src/lib/types/src/Flow/Types/Type/Native/MixedType.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Types\Type\Native;
+
+use Flow\Types\Type\Type;
+
+/**
+ * @implements Type<mixed>
+ */
+final class MixedType implements Type
+{
+    public function assert(mixed $value) : mixed
+    {
+        return $value;
+    }
+
+    public function cast(mixed $value) : mixed
+    {
+        return $value;
+    }
+
+    public function isValid(mixed $value) : bool
+    {
+        return true;
+    }
+
+    public function normalize() : array
+    {
+        return [
+            'type' => 'mixed',
+        ];
+    }
+
+    public function toString() : string
+    {
+        return 'mixed';
+    }
+}

src/lib/types/src/Flow/Types/Type/Native/UnionType.php

@@ -24,6 +24,10 @@
      */
     public function __construct(private Type $left, private Type $right)
     {
+        if ($left instanceof MixedType || $right instanceof MixedType) {
+            throw new InvalidTypeException('UnionType cannot be mixed with MixedType, mixed is a standalone type');
+        }
+
         $types = [];
 
         if ($this->left instanceof self) {

src/lib/types/src/Flow/Types/Type/TypeFactory.php

@@ -12,6 +12,7 @@
     type_float,
     type_integer,
     type_json,
+    type_mixed,
     type_non_empty_string,
     type_null,
     type_object,
@@ -74,6 +75,7 @@ public static function fromArray(array $data) : Type
             /** @phpstan-ignore argument.type */
             'optional' => OptionalType::fromArray($data),
             'scalar' => type_scalar(),
+            'mixed' => type_mixed(),
             default => throw new InvalidArgumentException("Unknown type '{$data['type']}'"),
         };
     }

src/lib/types/tests/Flow/Types/Tests/Unit/Type/Logical/OptionalTypeTest.php

@@ -4,7 +4,13 @@
 
 namespace Flow\Types\Tests\Unit\Type\Logical;
 
-use function Flow\Types\DSL\{type_float, type_from_array, type_integer, type_optional, type_string, type_union};
+use function Flow\Types\DSL\{type_float,
+    type_from_array,
+    type_integer,
+    type_mixed,
+    type_optional,
+    type_string,
+    type_union};
 use Flow\Types\Type\Logical\OptionalType;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
@@ -40,12 +46,33 @@ public function test_creating_optional_type_from_another_optional_type() : void
         type_optional(type_optional(type_float()));
     }
 
+    public function test_creating_optional_type_from_mixed_type() : void
+    {
+        $this->expectExceptionMessage('Optional type cannot be created from MixedType, mixed is a standalone type');
+
+        type_optional(type_mixed());
+    }
+
+    public function test_creating_optional_type_from_optional_type() : void
+    {
+        $this->expectExceptionMessage('Optional type cannot be created from an optional type');
+
+        type_optional(type_optional(type_float()));
+    }
+
     public function test_creating_optional_type_from_union_type() : void
     {
         $this->expectExceptionMessage('Optional type cannot be created from a union type');
         type_optional(type_union(type_float(), type_string()));
     }
 
+    public function test_creating_optional_type_from_union_type_with_mixed() : void
+    {
+        $this->expectExceptionMessage('Optional type cannot be created from a union type');
+
+        type_optional(type_union(type_float(), type_integer()));
+    }
+
     public function test_normalizing_optional_type() : void
     {
         self::assertEquals(

src/lib/types/tests/Flow/Types/Tests/Unit/Type/Native/MixedTypeTest.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Flow\Types\Tests\Unit\Type\Native;
+
+use function Flow\Types\DSL\{type_from_array, type_mixed};
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+
+final class MixedTypeTest extends TestCase
+{
+    public static function mixed_data_provider() : \Generator
+    {
+        yield [null, null];
+        yield [true, true];
+        yield [false, false];
+        yield [0, 0];
+        yield [1, 1];
+        yield [0.0, 0.0];
+        yield [1.0, 1.0];
+        yield ['string', 'string'];
+        yield [[], []];
+        yield [[1], [1]];
+        yield [[1 => 2], [1 => 2]];
+        yield [(object) [], (object) []];
+        yield [(object) ['a' => 'b'], (object) ['a' => 'b']];
+    }
+
+    #[DataProvider('mixed_data_provider')]
+    public function test_assert_is_valid_and_cast(mixed $value, mixed $expected) : void
+    {
+        self::assertEquals($expected, type_mixed()->assert($value));
+        self::assertEquals($expected, type_mixed()->cast($value));
+        self::assertTrue(type_mixed()->isValid($value));
+    }
+
+    public function test_normalize() : void
+    {
+        self::assertEquals(['type' => 'mixed'], type_mixed()->normalize());
+
+        self::assertEquals(
+            type_mixed(),
+            type_from_array(type_mixed()->normalize())
+        );
+    }
+
+    public function test_to_string() : void
+    {
+        self::assertEquals('mixed', type_mixed()->toString());
+    }
+}

src/lib/types/tests/Flow/Types/Tests/Unit/Type/Native/UnionTypeTest.php

@@ -8,6 +8,7 @@
     type_float,
     type_from_array,
     type_integer,
+    type_mixed,
     type_null,
     type_optional,
     type_string,
@@ -145,6 +146,14 @@ public function test_types() : void
         );
     }
 
+    public function test_union_with_mixed_type() : void
+    {
+        $this->expectException(InvalidTypeException::class);
+        $this->expectExceptionMessage('UnionType cannot be mixed with MixedType, mixed is a standalone type');
+
+        type_union(type_integer(), type_mixed());
+    }
+
     /**
      * @param UnionType<mixed, mixed> $type
      */