function CallExpression::getArguments

Same name in this branch

1. 11.1.x vendor/mck89/peast/lib/Peast/Syntax/Node/CallExpression.php \Peast\Syntax\Node\CallExpression::getArguments()

File

vendor/twig/twig/src/Node/Expression/CallExpression.php, line 133

Class

CallExpression

Namespace

Twig\Node\Expression

Code

protected function getArguments($callable, $arguments) {
    trigger_deprecation('twig/twig', '3.12', 'The "%s()" method is deprecated, use Twig\\Util\\CallableArgumentsExtractor::getArguments() instead.', __METHOD__);
    $callType = $this->getAttribute('type');
    $callName = $this->getAttribute('name');
    $parameters = [];
    $named = false;
    foreach ($arguments as $name => $node) {
        if (!\is_int($name)) {
            $named = true;
            $name = $this->normalizeName($name);
        }
        elseif ($named) {
            throw new SyntaxError(\sprintf('Positional arguments cannot be used after named arguments for %s "%s".', $callType, $callName), $this->getTemplateLine(), $this->getSourceContext());
        }
        $parameters[$name] = $node;
    }
    $isVariadic = $this->getAttribute('twig_callable')
        ->isVariadic();
    if (!$named && !$isVariadic) {
        return $parameters;
    }
    if (!$callable) {
        if ($named) {
            $message = \sprintf('Named arguments are not supported for %s "%s".', $callType, $callName);
        }
        else {
            $message = \sprintf('Arbitrary positional arguments are not supported for %s "%s".', $callType, $callName);
        }
        throw new \LogicException($message);
    }
    [
        $callableParameters,
        $isPhpVariadic,
    ] = $this->getCallableParameters($callable, $isVariadic);
    $arguments = [];
    $names = [];
    $missingArguments = [];
    $optionalArguments = [];
    $pos = 0;
    foreach ($callableParameters as $callableParameter) {
        $name = $this->normalizeName($callableParameter->name);
        if (\PHP_VERSION_ID >= 80000 && 'range' === $callable) {
            if ('start' === $name) {
                $name = 'low';
            }
            elseif ('end' === $name) {
                $name = 'high';
            }
        }
        $names[] = $name;
        if (\array_key_exists($name, $parameters)) {
            if (\array_key_exists($pos, $parameters)) {
                throw new SyntaxError(\sprintf('Argument "%s" is defined twice for %s "%s".', $name, $callType, $callName), $this->getTemplateLine(), $this->getSourceContext());
            }
            if (\count($missingArguments)) {
                throw new SyntaxError(\sprintf('Argument "%s" could not be assigned for %s "%s(%s)" because it is mapped to an internal PHP function which cannot determine default value for optional argument%s "%s".', $name, $callType, $callName, implode(', ', $names), \count($missingArguments) > 1 ? 's' : '', implode('", "', $missingArguments)), $this->getTemplateLine(), $this->getSourceContext());
            }
            $arguments = array_merge($arguments, $optionalArguments);
            $arguments[] = $parameters[$name];
            unset($parameters[$name]);
            $optionalArguments = [];
        }
        elseif (\array_key_exists($pos, $parameters)) {
            $arguments = array_merge($arguments, $optionalArguments);
            $arguments[] = $parameters[$pos];
            unset($parameters[$pos]);
            $optionalArguments = [];
            ++$pos;
        }
        elseif ($callableParameter->isDefaultValueAvailable()) {
            $optionalArguments[] = new ConstantExpression($callableParameter->getDefaultValue(), -1);
        }
        elseif ($callableParameter->isOptional()) {
            if (!$parameters) {
                break;
            }
            else {
                $missingArguments[] = $name;
            }
        }
        else {
            throw new SyntaxError(\sprintf('Value for argument "%s" is required for %s "%s".', $name, $callType, $callName), $this->getTemplateLine(), $this->getSourceContext());
        }
    }
    if ($isVariadic) {
        $arbitraryArguments = $isPhpVariadic ? new VariadicExpression([], -1) : new ArrayExpression([], -1);
        foreach ($parameters as $key => $value) {
            if (\is_int($key)) {
                $arbitraryArguments->addElement($value);
            }
            else {
                $arbitraryArguments->addElement($value, new ConstantExpression($key, -1));
            }
            unset($parameters[$key]);
        }
        if ($arbitraryArguments->count()) {
            $arguments = array_merge($arguments, $optionalArguments);
            $arguments[] = $arbitraryArguments;
        }
    }
    if ($parameters) {
        $unknownParameter = null;
        foreach ($parameters as $parameter) {
            if ($parameter instanceof Node) {
                $unknownParameter = $parameter;
                break;
            }
        }
        throw new SyntaxError(\sprintf('Unknown argument%s "%s" for %s "%s(%s)".', \count($parameters) > 1 ? 's' : '', implode('", "', array_keys($parameters)), $callType, $callName, implode(', ', $names)), $unknownParameter ? $unknownParameter->getTemplateLine() : $this->getTemplateLine(), $unknownParameter ? $unknownParameter->getSourceContext() : $this->getSourceContext());
    }
    return $arguments;
}