spiral / framework

src/Core/tests/Internal/Proxy/ProxyClassRendererTest.php

Braces +10 added lines, -4 removed lines

@@ -72,22 +72,28 @@
 
     public static function provideRenderMethod(): iterable
     {
-        $class = new class {
+        $class = new class
+        {
             public const INT_CONST = 42;
 
             #[ExpectedAttribute('public function test1(...$variadic)')]
-            public function test1(...$variadic) {}
+            public function test1(...$variadic)
+            {
+}
             #[ExpectedAttribute('public function test2(string|int $string = self::INT_CONST): string|int')]
             public function test2(string|int $string = self::INT_CONST): string|int {}
             #[ExpectedAttribute('public function test3(object $obj = new \stdClass(new \stdClass(), new \stdClass()))')]
-            public function test3(object $obj = new stdClass(new stdClass(), new stdClass())) {}
+            public function test3(object $obj = new stdClass(new stdClass(), new stdClass()))
+            {
+}
             #[ExpectedAttribute('public function test4(): \\' . ProxyClassRendererTest::class)]
             public function test4(): ProxyClassRendererTest {}
             #[ExpectedAttribute('public function &test5(): string')]
             public function &test5(): string {}
         };
 
-        foreach ((new \ReflectionClass($class))->getMethods() as $method) {
+        foreach ((new \ReflectionClass($class))->getMethods() as $method)
+        {
             $expected = $method->getAttributes(ExpectedAttribute::class)[0]->newInstance();
 
             yield [$method, $expected->value];

src/Core/tests/Internal/Proxy/Stub/MockInterfaceImpl.php

Braces +2 added lines, -1 removed lines

@@ -48,7 +48,8 @@
 
     public function concatMultiple(string $prefix, string &...$byLink): array
     {
-        foreach ($byLink as $k => $link) {
+        foreach ($byLink as $k => $link)
+        {
             $byLink[$k] = $prefix . $link;
             unset($link);
         }

src/Core/tests/Scope/FibersTest.php

Braces +21 added lines, -10 removed lines

@@ -30,7 +30,8 @@ 
 
         FiberHelper::runInFiber(
             self::functionScopedTestDataIterator(),
-            static function (mixed $suspendValue) {
+            static function (mixed $suspendValue)
+            {
                 self::assertNull(ContainerScope::getContainer());
                 self::assertTrue(\in_array($suspendValue, self::TEST_DATA, true));
             },
@@ -63,7 +64,8 @@ 
         );
 
         self::assertCount(5, $result);
-        foreach ($result as $suspendValue) {
+        foreach ($result as $suspendValue)
+        {
             self::assertSame(self::TEST_DATA, $suspendValue);
         }
     }
@@ -81,7 +83,8 @@ 
         );
 
         self::assertCount(2, $result);
-        foreach ($result as $suspendValue) {
+        foreach ($result as $suspendValue)
+        {
             self::assertSame(self::TEST_DATA, $suspendValue);
         }
     }
@@ -92,7 +95,8 @@ 
         $this->expectExceptionMessage('test');
 
         FiberHelper::runInFiber(
-            static function () {
+            static function ()
+            {
                 return (new Container())->runScoped(
                     function (): string {
                         $result = '';
@@ -114,15 +118,19 @@ 
     public function testCatchThrownException(): void
     {
         $result = FiberHelper::runInFiber(
-            static function () {
+            static function ()
+            {
                 return (new Container())->runScoped(
                     function (): string {
                         $result = '';
                         $result .= Fiber::suspend('foo');
                         $result .= Fiber::suspend('bar');
-                        try {
+                        try
+                        {
                             $result .= Fiber::suspend('error');
-                        } catch (\Throwable $e) {
+                        }
+                        catch (\Throwable $e)
+                        {
                             $result .= $e->getMessage();
                         }
                         $result .= Fiber::suspend('baz');
@@ -160,20 +168,23 @@ 
             $c1 = $container ?? new Container();
             $c1->bindSingleton('resource', new stdClass());
 
-            $result = $c1->runScoped(static function (Container $c2) use ($load) {
+            $result = $c1->runScoped(static function (Container $c2) use ($load)
+            {
                 // check local binding
                 self::assertTrue($c2->has('foo'));
                 self::assertInstanceOf(DateTime::class, $c2->get('foo'));
 
                 return $c2->runScoped(
-                    static function (ContainerInterface $c3) use ($load) {
+                    static function (ContainerInterface $c3) use ($load)
+                    {
                         // check local binding
                         self::assertTrue($c3->has('bar'));
 
                         $resource = $c3->get('resource');
                         self::assertInstanceOf(DateTimeImmutable::class, $c3->get('bar'));
                         self::assertInstanceOf(stdClass::class, $resource);
-                        foreach (self::TEST_DATA as $key => $value) {
+                        foreach (self::TEST_DATA as $key => $value)
+                        {
                             $resource->$key = $value;
                             $load === null or $load();
                             Fiber::suspend($value);

src/Core/tests/Scope/FiberHelper.php

Braces +26 added lines, -12 removed lines

@@ -22,11 +22,16 @@ 
     {
         $fiber = new Fiber($callable);
         $value = $fiber->start();
-        while (!$fiber->isTerminated()) {
-            if ($check !== null) {
-                try {
+        while (!$fiber->isTerminated())
+        {
+            if ($check !== null)
+            {
+                try
+                {
                     $value = $check($value);
-                } catch (\Throwable $e) {
+                }
+                catch (\Throwable $e)
+                {
                     $value = $fiber->throw($e);
                     continue;
                 }
@@ -50,14 +55,17 @@ 
         /** Values that were suspended by the fiber. */
         $suspends = [];
         $results = [];
-        foreach ($callables as $key => $callable) {
-            $fiberGenerators[$key] = (static function () use ($callable) {
+        foreach ($callables as $key => $callable)
+        {
+            $fiberGenerators[$key] = (static function () use ($callable)
+            {
                 $fiber = new Fiber($callable);
                 // Get ready
                 yield null;
 
                 $value = yield $fiber->start();
-                while (!$fiber->isTerminated()) {
+                while (!$fiber->isTerminated())
+                {
                     $value = yield $fiber->resume($value);
                 }
                 return $fiber->getReturn();
@@ -67,15 +75,21 @@ 
         }
 
 
-        while ($fiberGenerators !== []) {
-            foreach ($fiberGenerators as $key => $generator) {
-                try {
+        while ($fiberGenerators !== [])
+        {
+            foreach ($fiberGenerators as $key => $generator)
+            {
+                try
+                {
                     $suspends[$key] = $generator->send($suspends[$key]);
-                    if (!$generator->valid()) {
+                    if (!$generator->valid())
+                    {
                         $results[$key] = $generator->getReturn();
                         unset($fiberGenerators[$key]);
                     }
-                } catch (\Throwable $e) {
+                }
+                catch (\Throwable $e)
+                {
                     unset($fiberGenerators[$key]);
                     $results[$key] = $e;
                 }

src/Core/tests/Scope/UseCaseTest.php

Braces +18 added lines, -9 removed lines

@@ -28,7 +28,8 @@ 
         $root = new Container();
         $root->bind('foo', SampleClass::class);
 
-        $root->runScoped(function (ContainerInterface $c1) {
+        $root->runScoped(function (ContainerInterface $c1)
+        {
             $c1->get('foo');
         }, bindings: ['foo' => SampleClass::class]);
 
@@ -61,7 +62,8 @@ 
     {
         $root = new Container();
 
-        $root->runScoped(function (ContainerInterface $c1) use ($theSame, $alias) {
+        $root->runScoped(function (ContainerInterface $c1) use ($theSame, $alias)
+        {
             $obj1 = $c1->get($alias);
             $obj2 = $c1->get($alias);
 
@@ -86,14 +88,16 @@ 
     {
         $root = new Container();
 
-        $root->runScoped(function (ContainerInterface $c1) use ($root) {
+        $root->runScoped(function (ContainerInterface $c1) use ($root)
+        {
             $obj1 = $c1->get('foo');
             $this->weakMap->offsetSet($obj1, true);
 
             self::assertNotSame($root, $c1);
             self::assertInstanceOf(stdClass::class, $obj1);
 
-            $c1->runScoped(function (ContainerInterface $c2) use ($root, $c1, $obj1) {
+            $c1->runScoped(function (ContainerInterface $c2) use ($root, $c1, $obj1)
+            {
                 $obj2 = $c2->get('foo');
                 $this->weakMap->offsetSet($obj2, true);
 
@@ -122,14 +126,16 @@ 
         $root->bindSingleton('bar', [Factory::class, 'makeStdClass']);
         $root->bind(stdClass::class, new stdClass());
 
-        $root->runScoped(function (ContainerInterface $c1) use ($root) {
+        $root->runScoped(function (ContainerInterface $c1) use ($root)
+        {
             $obj1 = $c1->get('foo');
             $this->weakMap->offsetSet($obj1, true);
 
             self::assertInstanceOf(stdClass::class, $obj1);
             // Singleton must be the same
             self::assertSame($c1->get('bar'), $root->get('bar'));
-            $c1->runScoped(function (ContainerInterface $c2) use ($root, $obj1) {
+            $c1->runScoped(function (ContainerInterface $c2) use ($root, $obj1)
+            {
                 $obj2 = $c2->get('foo');
 
                 self::assertInstanceOf(stdClass::class, $obj2);
@@ -262,7 +268,8 @@ 
     {
         $root = new Container();
 
-        $root->invoke(static function () use ($root) {
+        $root->invoke(static function () use ($root)
+        {
             self::assertNotNull(\Spiral\Core\ContainerScope::getContainer());
             self::assertSame($root, \Spiral\Core\ContainerScope::getContainer());
         });
@@ -271,7 +278,8 @@ 
     public function testRegisterContainerOnGet(): void
     {
         $root = new Container();
-        $root->bind('foo', function () use ($root) {
+        $root->bind('foo', function () use ($root)
+        {
             self::assertNotNull(\Spiral\Core\ContainerScope::getContainer());
             self::assertSame($root, \Spiral\Core\ContainerScope::getContainer());
         });
@@ -282,7 +290,8 @@ 
     public function testRegisterContainerOnMake(): void
     {
         $root = new Container();
-        $root->bind('foo', function () use ($root) {
+        $root->bind('foo', function () use ($root)
+        {
             self::assertNotNull(\Spiral\Core\ContainerScope::getContainer());
             self::assertSame($root, \Spiral\Core\ContainerScope::getContainer());
         });

src/Core/src/Container.php

Braces +46 added lines, -21 removed lines

@@ -170,23 +170,29 @@ 
      */
     public function runScope(Scope|array $bindings, callable $scope): mixed
     {
-        if (!\is_array($bindings)) {
+        if (!\is_array($bindings))
+        {
             return $this->runIsolatedScope($bindings, $scope);
         }
 
         $binds = &$this->state->bindings;
         $singletons = &$this->state->singletons;
         $cleanup = $previous = $prevSin = [];
-        foreach ($bindings as $alias => $resolver) {
+        foreach ($bindings as $alias => $resolver)
+        {
             // Store previous bindings
-            if (isset($binds[$alias])) {
+            if (isset($binds[$alias]))
+            {
                 $previous[$alias] = $binds[$alias];
-            } else {
+            }
+            else
+            {
                 // Store bindings to be removed
                 $cleanup[] = $alias;
             }
             // Store previous singletons
-            if (isset($singletons[$alias])) {
+            if (isset($singletons[$alias]))
+            {
                 $prevSin[$alias] = $singletons[$alias];
                 unset($singletons[$alias]);
             }
@@ -194,21 +200,27 @@ 
             $this->binder->bind($alias, $resolver);
         }
 
-        try {
+        try
+        {
             return ContainerScope::getContainer() !== $this
                 ? ContainerScope::runScope($this, $scope)
                 : $scope($this);
-        } finally {
+        }
+        finally
+        {
             // Remove new bindings
-            foreach ($cleanup as $alias) {
+            foreach ($cleanup as $alias)
+            {
                 unset($binds[$alias], $singletons[$alias]);
             }
             // Restore previous bindings
-            foreach ($previous as $alias => $resolver) {
+            foreach ($previous as $alias => $resolver)
+            {
                 $binds[$alias] = $resolver;
             }
             // Restore singletons
-            foreach ($prevSin as $alias => $instance) {
+            foreach ($prevSin as $alias => $instance)
+            {
                 $singletons[$alias] = $instance;
             }
         }
@@ -265,7 +277,8 @@ 
      */
     public function bindSingleton(string $alias, string|array|callable|object $resolver, bool $force = true): void
     {
-        if ($force) {
+        if ($force)
+        {
             $this->binder->removeBinding($alias);
         }
 
@@ -336,8 +349,10 @@ 
         ]);
 
         // Create container services
-        foreach ($container->config as $property => $class) {
-            if (\property_exists($container, $property)) {
+        foreach ($container->config as $property => $class)
+        {
+            if (\property_exists($container, $property))
+            {
                 $container->$property = $constructor->get($property, $class);
             }
         }
@@ -351,7 +366,8 @@ 
     private function closeScope(): void
     {
         /** @psalm-suppress RedundantPropertyInitializationCheck */
-        if (!isset($this->scope)) {
+        if (!isset($this->scope))
+        {
             $this->destruct();
             return;
         }
@@ -360,10 +376,14 @@ 
 
         // Run finalizers
         $errors = [];
-        foreach ($this->state->finalizers as $finalizer) {
-            try {
+        foreach ($this->state->finalizers as $finalizer)
+        {
+            try
+            {
                 $this->invoker->invoke($finalizer);
-            } catch (\Throwable $e) {
+            }
+            catch (\Throwable $e)
+            {
                 $errors[] = $e;
             }
         }
@@ -372,7 +392,8 @@ 
         $this->destruct();
 
         // Throw collected errors
-        if ($errors !== []) {
+        if ($errors !== [])
+        {
             throw new FinalizersException($scopeName, $errors);
         }
     }
@@ -394,18 +415,22 @@ 
         $container->scope->setParent($this, $this->scope);
 
         // Add specific bindings
-        foreach ($config->bindings as $alias => $resolver) {
+        foreach ($config->bindings as $alias => $resolver)
+        {
             $container->binder->bind($alias, $resolver);
         }
 
         return ContainerScope::runScope(
             $container,
             static function (self $container) use ($config, $closure): mixed {
-                try {
+                try
+                {
                     return $config->autowire
                         ? $container->invoke($closure)
                         : $closure($container);
-                } finally {
+                }
+                finally
+                {
                     $container->closeScope();
                 }
             }

src/Core/tests/Scope/SideEffectTest.php

Braces +6 added lines, -3 removed lines

@@ -23,10 +23,12 @@ 
         $root = new Container();
         $root->bind(LoggerInterface::class, KVLogger::class);
 
-        $root->runScope(new Scope(), static function (Container $c1) {
+        $root->runScope(new Scope(), static function (Container $c1)
+        {
             $c1->bind(LoggerInterface::class, FileLogger::class);
 
-            $c1->runScope(new Scope(), static function (LoggerCarrier $carrier, LoggerInterface $logger) {
+            $c1->runScope(new Scope(), static function (LoggerCarrier $carrier, LoggerInterface $logger)
+            {
                 // from the $root container
                 self::assertInstanceOf(KVLogger::class, $carrier->logger);
                 // from the $c1 container
@@ -40,7 +42,8 @@ 
         $root = new Container();
         $root->bind(LoggerInterface::class, KVLogger::class);
 
-        $root->runScope(new Scope(), static function (Container $c1) {
+        $root->runScope(new Scope(), static function (Container $c1)
+        {
             $c1->bind(LoggerInterface::class, FileLogger::class);
 
             self::assertInstanceOf(

src/Core/tests/Internal/Proxy/ProxyTest.php

Braces +14 added lines, -7 removed lines

@@ -32,7 +32,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $proxy->bar(name: 'foo'); // Possible to run
@@ -49,7 +50,8 @@ 
 
         self::expectExceptionMessageMatches('/Call to undefined method/i');
 
-        $root->invoke(static function (#[Proxy] EmptyInterface $proxy) {
+        $root->invoke(static function (#[Proxy] EmptyInterface $proxy)
+        {
             $proxy->bar(name: 'foo'); // Possible to run
         });
     }
@@ -66,7 +68,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             self::assertSame(['foo', 'bar', 'baz', 69], $proxy->extra('foo', 'bar', 'baz', 69));
@@ -88,7 +91,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             self::assertSame(['foo', 'bar', 'baz', 69], $proxy->extraVariadic('foo', 'bar', 'baz', 69));
@@ -112,7 +116,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $str = 'bar';
@@ -134,7 +139,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
 
@@ -159,7 +165,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $str1 = 'bar';

src/Core/src/Internal/Resolver.php

Braces +81 added lines, -38 removed lines

@@ -53,7 +53,8 @@ 
     ): array {
         $state = new ResolvingState($reflection, $parameters);
 
-        foreach ($reflection->getParameters() as $parameter) {
+        foreach ($reflection->getParameters() as $parameter)
+        {
             $this->resolveParameter($parameter, $state, $validate)
             or
             throw new ArgumentResolvingException($reflection, $parameter->getName());
@@ -67,47 +68,59 @@ 
         $positional = true;
         $variadic = false;
         $parameters = $reflection->getParameters();
-        if (\count($parameters) === 0) {
+        if (\count($parameters) === 0)
+        {
             return;
         }
 
         $parameter = null;
-        while (\count($parameters) > 0 || \count($arguments) > 0) {
+        while (\count($parameters) > 0 || \count($arguments) > 0)
+        {
             // get related argument value
             $key = \key($arguments);
 
             // For a variadic parameter it's no sense - named or positional argument will be sent
             // But you can't send positional argument after named in any case
-            if (\is_int($key) && !$positional) {
+            if (\is_int($key) && !$positional)
+            {
                 throw new PositionalArgumentException($reflection, $key);
             }
 
             $positional = $positional && \is_int($key);
 
-            if (!$variadic) {
+            if (!$variadic)
+            {
                 $parameter = \array_shift($parameters);
                 $variadic = $parameter?->isVariadic() ?? false;
             }
 
-            if ($parameter === null) {
+            if ($parameter === null)
+            {
                 throw new UnknownParameterException($reflection, $key);
             }
             $name = $parameter->getName();
 
-            if (($positional || $variadic) && $key !== null) {
+            if (($positional || $variadic) && $key !== null)
+            {
                 /** @psalm-suppress ReferenceReusedFromConfusingScope */
                 $value = \array_shift($arguments);
-            } elseif ($key === null || !\array_key_exists($name, $arguments)) {
-                if ($parameter->isOptional()) {
+            }
+            elseif ($key === null || !\array_key_exists($name, $arguments))
+            {
+                if ($parameter->isOptional())
+                {
                     continue;
                 }
                 throw new MissingRequiredArgumentException($reflection, $name);
-            } else {
+            }
+            else
+            {
                 $value = &$arguments[$name];
                 unset($arguments[$name]);
             }
 
-            if (!$this->validateValueToParameter($parameter, $value)) {
+            if (!$this->validateValueToParameter($parameter, $value))
+            {
                 throw new InvalidArgumentException($reflection, $name);
             }
         }
@@ -115,7 +128,8 @@ 
 
     private function validateValueToParameter(ReflectionParameter $parameter, mixed $value): bool
     {
-        if (!$parameter->hasType() || ($parameter->allowsNull() && $value === null)) {
+        if (!$parameter->hasType() || ($parameter->allowsNull() && $value === null))
+        {
             return true;
         }
         $type = $parameter->getType();
@@ -126,17 +140,21 @@ 
             $type instanceof ReflectionIntersectionType => [false, $type->getTypes()],
         };
 
-        foreach ($types as $t) {
+        foreach ($types as $t)
+        {
             \assert($t instanceof ReflectionNamedType);
-            if (!$this->validateValueNamedType($t, $value)) {
+            if (!$this->validateValueNamedType($t, $value))
+            {
                 // If it is TypeIntersection
-                if ($or) {
+                if ($or)
+                {
                     continue;
                 }
                 return false;
             }
             // If it is not type intersection then we can skip that value after first successful check
-            if ($or) {
+            if ($or)
+            {
                 return true;
             }
         }
@@ -151,7 +169,8 @@ 
     {
         $name = $type->getName();
 
-        if ($type->isBuiltin()) {
+        if ($type->isBuiltin())
+        {
             return match ($name) {
                 'mixed' => true,
                 'string' => \is_string($value),
@@ -184,13 +203,18 @@ 
 
         // Try to resolve parameter by name
         $res = $state->resolveParameterByNameOrPosition($param, $isVariadic);
-        if ($res !== [] || $isVariadic) {
+        if ($res !== [] || $isVariadic)
+        {
             // validate
-            if ($isVariadic) {
-                foreach ($res as $k => &$v) {
+            if ($isVariadic)
+            {
+                foreach ($res as $k => &$v)
+                {
                     $this->processArgument($state, $v, validateWith: $validate ? $param : null, key: $k);
                 }
-            } else {
+            }
+            else
+            {
                 $this->processArgument($state, $res[0], validateWith: $validate ? $param : null);
             }
 
@@ -198,18 +222,22 @@ 
         }
 
         $error = null;
-        while ($hasType) {
+        while ($hasType)
+        {
             /** @var ReflectionIntersectionType|ReflectionUnionType|ReflectionNamedType $refType */
             $refType = $param->getType();
 
-            if ($refType::class === ReflectionNamedType::class) {
-                if ($refType->isBuiltin()) {
+            if ($refType::class === ReflectionNamedType::class)
+            {
+                if ($refType->isBuiltin())
+                {
                     break;
                 }
 
                 if (\interface_exists($refType->getName()) && !empty(
                     $attrs = $param->getAttributes(ProxyAttribute::class)
-                )) {
+                ))
+                {
                     $proxy = Proxy::create(
                         new \ReflectionClass($refType->getName()),
                         $param,
@@ -219,23 +247,33 @@ 
                     return true;
                 }
 
-                try {
-                    if ($this->resolveObject($state, $refType, $param, $validate)) {
+                try
+                {
+                    if ($this->resolveObject($state, $refType, $param, $validate))
+                    {
                         return true;
                     }
-                } catch (Throwable $e) {
+                }
+                catch (Throwable $e)
+                {
                     $error = $e;
                 }
                 break;
             }
 
-            if ($refType::class === ReflectionUnionType::class) {
-                foreach ($refType->getTypes() as $namedType) {
-                    try {
-                        if (!$namedType->isBuiltin() && $this->resolveObject($state, $namedType, $param, $validate)) {
+            if ($refType::class === ReflectionUnionType::class)
+            {
+                foreach ($refType->getTypes() as $namedType)
+                {
+                    try
+                    {
+                        if (!$namedType->isBuiltin() && $this->resolveObject($state, $namedType, $param, $validate))
+                        {
                             return true;
                         }
-                    } catch (Throwable $e) {
+                    }
+                    catch (Throwable $e)
+                    {
                         $error = $e;
                     }
                 }
@@ -245,19 +283,22 @@ 
             throw new UnsupportedTypeException($param->getDeclaringFunction(), $param->getName());
         }
 
-        if ($param->isDefaultValueAvailable()) {
+        if ($param->isDefaultValueAvailable())
+        {
             $argument = $param->getDefaultValue();
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($hasType && $param->allowsNull()) {
+        if ($hasType && $param->allowsNull())
+        {
             $argument = null;
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($error === null) {
+        if ($error === null)
+        {
             return false;
         }
 
@@ -298,12 +339,14 @@ 
         int|string $key = null
     ): void {
         // Resolve Autowire objects
-        if ($value instanceof Autowire) {
+        if ($value instanceof Autowire)
+        {
             $value = $value->resolve($this->factory);
         }
 
         // Validation
-        if ($validateWith !== null && !$this->validateValueToParameter($validateWith, $value)) {
+        if ($validateWith !== null && !$this->validateValueToParameter($validateWith, $value))
+        {
             throw new InvalidArgumentException(
                 $validateWith->getDeclaringFunction(),
                 $validateWith->getName()