@param int|string               $key
@param ReflectionParameter|null $parameter

@return mixed
356520
private function bind($key, $parameter)
    {
        if (is_null($parameter->getClass())) {
            return $this->arguments[$key] ?? null;
        }

        $class = $parameter->getClass()->name;

        $object = Arr::first($this->arguments, function ($value) use ($class) {
            return is_subclass_of($value, $class) || is_a($value, $class);
        });

        if (is_null($object)) {
            $object = app()->make($class);

            if (method_exists($object, 'resolveRouteBinding') && isset($this->arguments[$key])) {
                $object = $object->resolveRouteBinding($this->arguments[$key]);
            }
        }

        return $object;
    }
503285
public function getParameter($key)
    {
        $filteredParameters = $this->parameters->filter(
            function ($parameter) use ($key)
            {
                // Must not be identical because of string to integer conversion
                return ($key == $parameter->getName());
            }
        );

        return count($filteredParameters) ? $filteredParameters->first() : null;
    }
334236
public function getParam(string $key)
    {
        $isActionParam = in_array($key, [self::PARAM_CONTROLLER, self::PARAM_ACTION]);
        $params = $isActionParam ? $this->actionParams: $this->params;
        return array_key_exists($key, $params) ? $params[$key] : null;
    }
1307760
public function getParam($key, $default = null)
    {
        if (isset($this->parameters[$key])) {
            return $this->parameters[$key];
        }

        return $default;
    }
52740
public function getValueBy(ParameterInterface $parameter)
    {
        if ($this->isExistBy($parameter) === false) {
            throw new NoBindParameterException('No parameter: ' . (string) $parameter);
        }

        return $this->parameters[$parameter->getHash()];
    }
352489
public function getParam($key = null, $default = null)
    {
        if (!isset($key)) {
            return $this->params;
        }

        foreach ((array) $key as $k) {
            if (isset($this->params[$k])) {
                return $this->params[$k];
            }
        }

        return $default;
    }
866599
private function determineParamValue(\ReflectionParameter $parameter)
    {
        $class = $parameter->getClass();

        if (!empty($class)) {
            // If this is a object we may be able to map it to something in our context
            $className = $class->getName();

            // Determine strong type-based link
            if (isset($this->instances[$className])) {
                return $this->instances[$className];
            }

            // Determine weak type-based link
            if (isset($this->weakLinks[$className])) {
                $lowerClassName = $this->weakLinks[$className];
                return $this->instances[$lowerClassName];
            }
        } else {
            // If this is a primitive type, attempt to determine it by its name
            $varName = $parameter->getName();

            if (isset($this->variablesByName[$varName])) {
                return $this->variablesByName[$varName];
            }
        }

        // We were unable to determine a suitable value based on this context. Pass back its default value if possible.
        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }

        // As a final fallback we will primitive pass NULL and let the function deal with it.
        return null;
    }
373213
public function getParamter($key)
    {
        return isset($this->params[$key]) ? $this->params[$key] : null;
    }
36502
private function getParameterValue(string $id, ReflectionParameter $parameter, ContainerInterface $container)
    {
        if (! ($class = $parameter->getClass())) {
            if ($parameter->isDefaultValueAvailable()) {
                // a default value is available so use that
                return $parameter->getDefaultValue();
            }

            // no default, eek
            throw new FatalNotFoundException("Cannot resolve '" . $parameter->getName() . "' for class '" . $id . "'");
        }

        try {
            // attempt to resolve the value
            return $container->get($class->getName());
        } catch (NotFoundException $e) {
            if ($parameter->isDefaultValueAvailable()) {
                // a default value is available so use that
                return $parameter->getDefaultValue();
            }
            throw $e;
        }
    }
622848
public function getParameter($key)
    {
        if (empty($this->namedParameters[$key])) {
            throw new InvalidKeyException($key);
        }

        return $this->namedParameters[$key];
    }
767130
public function getParameter($parameter)
    {
        return $this->container->hasParameter($parameter) ? $this->container->getParameter($parameter) : null;
    }
1119928
public function get(string $key)
    {
        if ($this->has($key)) {
            return deep_clone($this->parameters[$key]);
        }

        throw ParameterNotFoundExceptionFactory::create($key);
    }
1105260
protected function getDeclaringFunction(ReflectionParameter $parameter): string
	{
		$declaringFunction = $parameter->getDeclaringFunction();

		if($declaringFunction->isClosure())
		{
			return 'Closure';
		}

		if(($class = $parameter->getDeclaringClass()) === null)
		{
			return $declaringFunction->getName();
		}

		return $class->getName() . '::' . $declaringFunction->getName();
	}
865288
private function getReflectionParamData(\ReflectionParameter $param)
    {
        $param_type = self::getPsalmTypeFromReflectionType($param->getType());
        $param_name = (string)$param->getName();

        $is_optional = (bool)$param->isOptional();

        return new FunctionLikeParameter(
            $param_name,
            (bool)$param->isPassedByReference(),
            $param_type,
            null,
            null,
            $is_optional,
            $param_type->isNullable(),
            $param->isVariadic()
        );
    }
183220
public function getParam(String $key) {

		return $this->params[$key] ?? $this->httpErrors[$key] ?? null;

	}
679601
public function getParameter($key, $default = null) {
        $parameter = array_get($this->parameters, $key, $default);

        if ($parameter === null) {
            return $default;
        }

        return $parameter;
    }
1329087
public function get($parameter)
    {
        return isset($this->credentials[$parameter]) ? $this->credentials[$parameter] : null;
    }