<form method="POST">
    <h3>Editing: AbstractRouteCollection.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Routing;

use ArrayIterator;
use Countable;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Str;
use IteratorAggregate;
use LogicException;
use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Matcher\Dumper\CompiledUrlMatcherDumper;
use Symfony\Component\Routing\RouteCollection as SymfonyRouteCollection;

abstract class AbstractRouteCollection implements Countable, IteratorAggregate, RouteCollectionInterface
{
    /**
     * Handle the matched route.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Routing\Route|null  $route
     * @return \Illuminate\Routing\Route
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     */
    protected function handleMatchedRoute(Request $request, $route)
    {
        if (! is_null($route)) {
            return $route-&gt;bind($request);
        }

        // If no route was found we will now check if a matching route is specified by
        // another HTTP verb. If it is we will need to throw a MethodNotAllowed and
        // inform the user agent of which HTTP verb it should use for this route.
        $others = $this-&gt;checkForAlternateVerbs($request);

        if (count($others) &gt; 0) {
            return $this-&gt;getRouteForMethods($request, $others);
        }

        throw new NotFoundHttpException;
    }

    /**
     * Determine if any routes match on another HTTP verb.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */
    protected function checkForAlternateVerbs($request)
    {
        $methods = array_diff(Router::$verbs, [$request-&gt;getMethod()]);

        // Here we will spin through all verbs except for the current request verb and
        // check to see if any routes respond to them. If they do, we will return a
        // proper error response with the correct headers on the response string.
        return array_values(array_filter(
            $methods,
            function ($method) use ($request) {
                return ! is_null($this-&gt;matchAgainstRoutes($this-&gt;get($method), $request, false));
            }
        ));
    }

    /**
     * Determine if a route in the array matches the request.
     *
     * @param  \Illuminate\Routing\Route[]  $routes
     * @param  \Illuminate\Http\Request  $request
     * @param  bool  $includingMethod
     * @return \Illuminate\Routing\Route|null
     */
    protected function matchAgainstRoutes(array $routes, $request, $includingMethod = true)
    {
        [$fallbacks, $routes] = collect($routes)-&gt;partition(function ($route) {
            return $route-&gt;isFallback;
        });

        return $routes-&gt;merge($fallbacks)-&gt;first(function (Route $route) use ($request, $includingMethod) {
            return $route-&gt;matches($request, $includingMethod);
        });
    }

    /**
     * Get a route (if necessary) that responds when other available methods are present.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  string[]  $methods
     * @return \Illuminate\Routing\Route
     *
     * @throws \Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException
     */
    protected function getRouteForMethods($request, array $methods)
    {
        if ($request-&gt;method() === 'OPTIONS') {
            return (new Route('OPTIONS', $request-&gt;path(), function () use ($methods) {
                return new Response('', 200, ['Allow' =&gt; implode(',', $methods)]);
            }))-&gt;bind($request);
        }

        $this-&gt;methodNotAllowed($methods, $request-&gt;method());
    }

    /**
     * Throw a method not allowed HTTP exception.
     *
     * @param  array  $others
     * @param  string  $method
     * @return void
     *
     * @throws \Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException
     */
    protected function methodNotAllowed(array $others, $method)
    {
        throw new MethodNotAllowedHttpException(
            $others,
            sprintf(
                'The %s method is not supported for this route. Supported methods: %s.',
                $method,
                implode(', ', $others)
            )
        );
    }

    /**
     * Compile the routes for caching.
     *
     * @return array
     */
    public function compile()
    {
        $compiled = $this-&gt;dumper()-&gt;getCompiledRoutes();

        $attributes = [];

        foreach ($this-&gt;getRoutes() as $route) {
            $attributes[$route-&gt;getName()] = [
                'methods' =&gt; $route-&gt;methods(),
                'uri' =&gt; $route-&gt;uri(),
                'action' =&gt; $route-&gt;getAction(),
                'fallback' =&gt; $route-&gt;isFallback,
                'defaults' =&gt; $route-&gt;defaults,
                'wheres' =&gt; $route-&gt;wheres,
                'bindingFields' =&gt; $route-&gt;bindingFields(),
                'lockSeconds' =&gt; $route-&gt;locksFor(),
                'waitSeconds' =&gt; $route-&gt;waitsFor(),
                'withTrashed' =&gt; $route-&gt;allowsTrashedBindings(),
            ];
        }

        return compact('compiled', 'attributes');
    }

    /**
     * Return the CompiledUrlMatcherDumper instance for the route collection.
     *
     * @return \Symfony\Component\Routing\Matcher\Dumper\CompiledUrlMatcherDumper
     */
    public function dumper()
    {
        return new CompiledUrlMatcherDumper($this-&gt;toSymfonyRouteCollection());
    }

    /**
     * Convert the collection to a Symfony RouteCollection instance.
     *
     * @return \Symfony\Component\Routing\RouteCollection
     */
    public function toSymfonyRouteCollection()
    {
        $symfonyRoutes = new SymfonyRouteCollection;

        $routes = $this-&gt;getRoutes();

        foreach ($routes as $route) {
            if (! $route-&gt;isFallback) {
                $symfonyRoutes = $this-&gt;addToSymfonyRoutesCollection($symfonyRoutes, $route);
            }
        }

        foreach ($routes as $route) {
            if ($route-&gt;isFallback) {
                $symfonyRoutes = $this-&gt;addToSymfonyRoutesCollection($symfonyRoutes, $route);
            }
        }

        return $symfonyRoutes;
    }

    /**
     * Add a route to the SymfonyRouteCollection instance.
     *
     * @param  \Symfony\Component\Routing\RouteCollection  $symfonyRoutes
     * @param  \Illuminate\Routing\Route  $route
     * @return \Symfony\Component\Routing\RouteCollection
     *
     * @throws \LogicException
     */
    protected function addToSymfonyRoutesCollection(SymfonyRouteCollection $symfonyRoutes, Route $route)
    {
        $name = $route-&gt;getName();

        if (
            ! is_null($name)
            &amp;&amp; Str::endsWith($name, '.')
            &amp;&amp; ! is_null($symfonyRoutes-&gt;get($name))
        ) {
            $name = null;
        }

        if (! $name) {
            $route-&gt;name($name = $this-&gt;generateRouteName());

            $this-&gt;add($route);
        } elseif (! is_null($symfonyRoutes-&gt;get($name))) {
            throw new LogicException(&quot;Unable to prepare route [{$route-&gt;uri}] for serialization. Another route has already been assigned name [{$name}].&quot;);
        }

        $symfonyRoutes-&gt;add($route-&gt;getName(), $route-&gt;toSymfonyRoute());

        return $symfonyRoutes;
    }

    /**
     * Get a randomly generated route name.
     *
     * @return string
     */
    protected function generateRouteName()
    {
        return 'generated::'.Str::random();
    }

    /**
     * Get an iterator for the items.
     *
     * @return \ArrayIterator
     */
    #[\ReturnTypeWillChange]
    public function getIterator()
    {
        return new ArrayIterator($this-&gt;getRoutes());
    }

    /**
     * Count the number of items in the collection.
     *
     * @return int
     */
    #[\ReturnTypeWillChange]
    public function count()
    {
        return count($this-&gt;getRoutes());
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>