support union types on closure callbacks and exception callbacks

src/Illuminate/Events/Dispatcher.php

@@ -77,9 +77,15 @@ public function __construct(ContainerContract $container = null)
     public function listen($events, $listener = null)
     {
         if ($events instanceof Closure) {
-            return $this->listen($this->firstClosureParameterType($events), $events);
+            return collect($this->firstClosureParameterTypes($events))
+                ->each(function ($event) use ($events) {
+                    $this->listen($event, $events);
+                });
         } elseif ($events instanceof QueuedClosure) {
-            return $this->listen($this->firstClosureParameterType($events->closure), $events->resolve());
+            return collect($this->firstClosureParameterTypes($events->closure))
+                ->each(function ($event) use ($events) {
+                    $this->listen($event, $events->resolve());
+                });
         } elseif ($listener instanceof QueuedClosure) {
             $listener = $listener->resolve();
         }

src/Illuminate/Foundation/Exceptions/Handler.php

@@ -332,11 +332,13 @@ public function render($request, Throwable $e)
         $e = $this->prepareException($this->mapException($e));
 
         foreach ($this->renderCallbacks as $renderCallback) {
-            if (is_a($e, $this->firstClosureParameterType($renderCallback))) {
-                $response = $renderCallback($e, $request);
+            foreach ($this->firstClosureParameterTypes($renderCallback) as $type) {
+                if (is_a($e, $type)) {
+                    $response = $renderCallback($e, $request);
 
-                if (! is_null($response)) {
-                    return $response;
+                    if (! is_null($response)) {
+                        return $response;
+                    }
                 }
             }
         }

src/Illuminate/Foundation/Exceptions/ReportableHandler.php

@@ -59,7 +59,13 @@ public function __invoke(Throwable $e)
      */
     public function handles(Throwable $e)
     {
-        return is_a($e, $this->firstClosureParameterType($this->callback));
+        foreach ($this->firstClosureParameterTypes($this->callback) as $type) {
+            if (is_a($e, $type)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**

src/Illuminate/Support/Reflector.php

@@ -84,7 +84,7 @@ public static function getParameterClassNames($parameter)
         $type = $parameter->getType();
 
         if (! $type instanceof ReflectionUnionType) {
-            return [static::getParameterClassName($parameter)];
+            return array_filter([static::getParameterClassName($parameter)]);
         }
 
         $unionTypes = [];
@@ -97,7 +97,7 @@ public static function getParameterClassNames($parameter)
             $unionTypes[] = static::getTypeName($parameter, $listedType);
         }
 
-        return $unionTypes;
+        return array_filter($unionTypes);
     }
 
     /**

src/Illuminate/Support/Traits/ReflectsClosures.php

@@ -10,47 +10,79 @@
 trait ReflectsClosures
 {
     /**
-     * Get the class names / types of the parameters of the given Closure.
+     * Get the class name of the first parameter of the given Closure.
      *
      * @param  \Closure  $closure
-     * @return array
+     * @return string
      *
      * @throws \ReflectionException
+     * @throws \RuntimeException
      */
-    protected function closureParameterTypes(Closure $closure)
+    protected function firstClosureParameterType(Closure $closure)
     {
-        $reflection = new ReflectionFunction($closure);
+        $types = array_values($this->closureParameterTypes($closure));
 
-        return collect($reflection->getParameters())->mapWithKeys(function ($parameter) {
-            if ($parameter->isVariadic()) {
-                return [$parameter->getName() => null];
-            }
+        if (! $types) {
+            throw new RuntimeException('The given Closure has no parameters.');
+        }
 
-            return [$parameter->getName() => Reflector::getParameterClassName($parameter)];
-        })->all();
+        if ($types[0] === null) {
+            throw new RuntimeException('The first parameter of the given Closure is missing a type hint.');
+        }
+
+        return $types[0];
     }
 
     /**
-     * Get the class name of the first parameter of the given Closure.
+     * Get the class names of the first parameter of the given Closure, including union types.
      *
      * @param  \Closure  $closure
-     * @return string
+     * @return array
      *
      * @throws \ReflectionException
      * @throws \RuntimeException
      */
-    protected function firstClosureParameterType(Closure $closure)
+    protected function firstClosureParameterTypes(Closure $closure)
     {
-        $types = array_values($this->closureParameterTypes($closure));
+        $reflection = new ReflectionFunction($closure);
 
-        if (! $types) {
+        $types = collect($reflection->getParameters())->mapWithKeys(function ($parameter) {
+            if ($parameter->isVariadic()) {
+                return [$parameter->getName() => null];
+            }
+
+            return [$parameter->getName() => Reflector::getParameterClassNames($parameter)];
+        })->filter()->values()->all();
+
+        if (empty($types)) {
             throw new RuntimeException('The given Closure has no parameters.');
         }
 
-        if ($types[0] === null) {
+        if (isset($types[0]) && empty($types[0])) {
             throw new RuntimeException('The first parameter of the given Closure is missing a type hint.');
         }
 
         return $types[0];
     }
+
+    /**
+     * Get the class names / types of the parameters of the given Closure.
+     *
+     * @param  \Closure  $closure
+     * @return array
+     *
+     * @throws \ReflectionException
+     */
+    protected function closureParameterTypes(Closure $closure)
+    {
+        $reflection = new ReflectionFunction($closure);
+
+        return collect($reflection->getParameters())->mapWithKeys(function ($parameter) {
+            if ($parameter->isVariadic()) {
+                return [$parameter->getName() => null];
+            }
+
+            return [$parameter->getName() => Reflector::getParameterClassName($parameter)];
+        })->all();
+    }
 }

tests/Support/SupportReflectsClosuresTest.php

@@ -64,6 +64,44 @@ public function testItThrowsWhenNoFirstParameterType()
         });
     }
 
+    public function testItWorksWithUnionTypes()
+    {
+        $types = ReflectsClosuresClass::reflectFirstAll(function (ExampleParameter $a, $b) {
+            //
+        });
+
+        $this->assertEquals([
+            ExampleParameter::class,
+        ], $types);
+
+        $types = ReflectsClosuresClass::reflectFirstAll(function (ExampleParameter|AnotherExampleParameter $a, $b) {
+            //
+        });
+
+        $this->assertEquals([
+            ExampleParameter::class,
+            AnotherExampleParameter::class,
+        ], $types);
+    }
+
+    public function testItWorksWithUnionTypesWithNoTypeHints()
+    {
+        $this->expectException(RuntimeException::class);
+
+        $types = ReflectsClosuresClass::reflectFirstAll(function ($a, $b) {
+            //
+        });
+    }
+
+    public function testItWorksWithUnionTypesWithNoArguments()
+    {
+        $this->expectException(RuntimeException::class);
+
+        $types = ReflectsClosuresClass::reflectFirstAll(function () {
+            //
+        });
+    }
+
     private function assertParameterTypes($expected, $closure)
     {
         $types = ReflectsClosuresClass::reflect($closure);
@@ -85,9 +123,19 @@ public static function reflectFirst($closure)
     {
         return (new static)->firstClosureParameterType($closure);
     }
+
+    public static function reflectFirstAll($closure)
+    {
+        return (new static)->firstClosureParameterTypes($closure);
+    }
 }
 
 class ExampleParameter
 {
     //
 }
+
+class AnotherExampleParameter
+{
+    //
+}