fix: reject composite callable parameter types descriptively

.changelog/callable-composite-types.md

@@ -0,0 +1,6 @@
+---
+category: fixed
+type: patch
+---
+
+Rejects union and intersection callable parameters with the documented invalid-type exception instead of an undefined reflection method error.

src/Factory/CallableFactory.php

@@ -20,7 +20,7 @@
 
 use Closure;
 use ReflectionFunction;
-use ReflectionType;
+use ReflectionNamedType;
 use FastForward\Container\Exception\RuntimeException;
 use Psr\Container\ContainerInterface;
 
@@ -77,7 +77,7 @@ private function getArguments(ContainerInterface $container, ReflectionFunction
         $arguments = [];
 
         foreach ($function->getParameters() as $parameter) {
-            if (! $parameter->getType() instanceof ReflectionType || $parameter->getType()->isBuiltin()) {
+            if (! $parameter->getType() instanceof ReflectionNamedType || $parameter->getType()->isBuiltin()) {
                 throw RuntimeException::forInvalidParameterType($parameter->getName());
             }
 

tests/Factory/CallableFactoryTest.php

@@ -99,4 +99,52 @@ public function invokeWillThrowRuntimeExceptionIfParameterIsNotAClass(): void
 
         $factory($container);
     }
+    #[Test]
+    public function unionParameterReceivesInvalidTypeDiagnostic(): void
+    {
+        $factory = new CallableFactory(static fn(ContainerInterface|FactoryInterface $dependency) => $dependency);
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Parameter "dependency" is not a valid type.');
+        $factory($this->prophesize(ContainerInterface::class)->reveal());
+    }
+
+    #[Test]
+    public function intersectionParameterReceivesInvalidTypeDiagnostic(): void
+    {
+        $factory = new CallableFactory(static fn(ContainerInterface&FactoryInterface $dependency) => $dependency);
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Parameter "dependency" is not a valid type.');
+        $factory($this->prophesize(ContainerInterface::class)->reveal());
+    }
+
+    #[Test]
+    public function nullableNamedParameterStillResolvesDependency(): void
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $dependency = $this->prophesize(FactoryInterface::class)->reveal();
+        $container->get(FactoryInterface::class)->willReturn($dependency);
+        $factory = new CallableFactory(static fn(?FactoryInterface $dependency) => $dependency);
+        self::assertSame($dependency, $factory($container->reveal()));
+    }
+
+    #[Test]
+    public function dnfParameterReceivesInvalidTypeDiagnostic(): void
+    {
+        $factory = new CallableFactory(
+            static fn((ContainerInterface&FactoryInterface)|ServiceProviderInterface $dependency) => $dependency
+        );
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Parameter "dependency" is not a valid type.');
+        $factory($this->prophesize(ContainerInterface::class)->reveal());
+    }
+
+    #[Test]
+    public function untypedParameterReceivesInvalidTypeDiagnostic(): void
+    {
+        $factory = new CallableFactory(static fn($dependency) => $dependency);
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Parameter "dependency" is not a valid type.');
+        $factory($this->prophesize(ContainerInterface::class)->reveal());
+    }
+
 }