/**

     * Resolve the given type from the container.

     *

     * @param  string  $abstract

     * @param  array   $parameters

     * @return mixed

     */

    public function make($abstract, array $parameters = [])

    {

        $abstract = $this->getAlias($abstract);

        // If an instance of the type is currently being managed as a singleton we'll

        // just return an existing instance instead of instantiating new instances

        // so the developer can keep using the same objects instance every time.

        if (isset($this->instances[$abstract])) {

            return $this->instances[$abstract];

        }

        $concrete = $this->getConcrete($abstract);

        // We're ready to instantiate an instance of the concrete type registered for

        // the binding. This will instantiate the types, as well as resolve any of

        // its "nested" dependencies recursively until all have gotten resolved.

        if ($this->isBuildable($concrete, $abstract)) {

            $object = $this->build($concrete, $parameters);

        } else {

            $object = $this->make($concrete, $parameters);

        }

        // If we defined any extenders for this type, we'll need to spin through them

        // and apply them to the object being built. This allows for the extension

        // of services, such as changing configuration or decorating the object.

        foreach ($this->getExtenders($abstract) as $extender) {

            $object = $extender($object, $this);

        }

        // If the requested type is registered as a singleton we'll want to cache off

        // the instances in "memory" so we can return it later without creating an

        // entirely new instance of an object on each subsequent request for it.

        if ($this->isShared($abstract)) {

            $this->instances[$abstract] = $object;

        }

        $this->fireResolvingCallbacks($abstract, $object);

        $this->resolved[$abstract] = true;

        return $object;

    }

    /**

     * Get the concrete type for a given abstract.

     *

     * @param  string  $abstract

     * @return mixed   $concrete

     */

    protected function getConcrete($abstract)

    {

        if (! is_null($concrete = $this->getContextualConcrete($abstract))) {

            return $concrete;

        }

        // If we don't have a registered resolver or concrete for the type, we'll just

        // assume each type is a concrete name and will attempt to resolve it as is

        // since the container should be able to resolve concretes automatically.

        if (! isset($this->bindings[$abstract])) {

            if ($this->missingLeadingSlash($abstract) &&

                isset($this->bindings['\\'.$abstract])) {

                $abstract = '\\'.$abstract;

            }

            return $abstract;

        }

        return $this->bindings[$abstract]['concrete'];

    }

    /**

     * Instantiate a concrete instance of the given type.

     *

     * @param  string  $concrete

     * @param  array   $parameters

     * @return mixed

     *

     * @throws \Illuminate\Contracts\Container\BindingResolutionException

     */

    public function build($concrete, array $parameters = [])

    {

        // If the concrete type is actually a Closure, we will just execute it and

        // hand back the results of the functions, which allows functions to be

        // used as resolvers for more fine-tuned resolution of these objects.

        if ($concrete instanceof Closure) {

            return $concrete($this, $parameters);

        }

        $reflector = new ReflectionClass($concrete);

        // If the type is not instantiable, the developer is attempting to resolve

        // an abstract type such as an Interface of Abstract Class and there is

        // no binding registered for the abstractions so we need to bail out.

        if (! $reflector->isInstantiable()) {

            $message = "Target [$concrete] is not instantiable.";

            throw new BindingResolutionContractException($message);

        }

        $this->buildStack[] = $concrete;

        $constructor = $reflector->getConstructor();

        // If there are no constructors, that means there are no dependencies then

        // we can just resolve the instances of the objects right away, without

        // resolving any other types or dependencies out of these containers.

        if (is_null($constructor)) {

            array_pop($this->buildStack);

            return new $concrete;

        }

        $dependencies = $constructor->getParameters();

        // Once we have all the constructor's parameters we can create each of the

        // dependency instances and then use the reflection instances to make a

        // new instance of this class, injecting the created dependencies in.

        $parameters = $this->keyParametersByArgument(

            $dependencies, $parameters

        );

        $instances = $this->getDependencies(

            $dependencies, $parameters

        );

        array_pop($this->buildStack);

        return $reflector->newInstanceArgs($instances);

    }