function ExpressionParser::parseArguments

Parses arguments.

Return value

Node

Throws

SyntaxError

File

vendor/twig/twig/src/ExpressionParser.php, line 621

Class

ExpressionParser

Parses expressions.

Namespace

Twig

Code

public function parseArguments() {
    $namedArguments = false;
    $definition = false;
    if (func_num_args() > 1) {
        $definition = func_get_arg(1);
    }
    if (func_num_args() > 0) {
        trigger_deprecation('twig/twig', '3.15', 'Passing arguments to "%s()" is deprecated.', __METHOD__);
        $namedArguments = func_get_arg(0);
    }
    $args = [];
    $stream = $this->parser
        ->getStream();
    $stream->expect(Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
    $hasSpread = false;
    while (!$stream->test(Token::PUNCTUATION_TYPE, ')')) {
        if ($args) {
            $stream->expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
            // if the comma above was a trailing comma, early exit the argument parse loop
            if ($stream->test(Token::PUNCTUATION_TYPE, ')')) {
                break;
            }
        }
        if ($definition) {
            $token = $stream->expect(Token::NAME_TYPE, null, 'An argument must be a name');
            $value = new ContextVariable($token->getValue(), $this->parser
                ->getCurrentToken()
                ->getLine());
        }
        else {
            if ($stream->nextIf(Token::SPREAD_TYPE)) {
                $hasSpread = true;
                $value = new SpreadUnary($this->parseExpression(), $stream->getCurrent()
                    ->getLine());
            }
            elseif ($hasSpread) {
                throw new SyntaxError('Normal arguments must be placed before argument unpacking.', $stream->getCurrent()
                    ->getLine(), $stream->getSourceContext());
            }
            else {
                $value = $this->parseExpression();
            }
        }
        $name = null;
        if ($namedArguments && (($token = $stream->nextIf(Token::OPERATOR_TYPE, '=')) || !$definition && ($token = $stream->nextIf(Token::PUNCTUATION_TYPE, ':')))) {
            if (!$value instanceof NameExpression) {
                throw new SyntaxError(\sprintf('A parameter name must be a string, "%s" given.', \get_class($value)), $token->getLine(), $stream->getSourceContext());
            }
            $name = $value->getAttribute('name');
            if ($definition) {
                $value = $this->getPrimary();
                if (!$this->checkConstantExpression($value)) {
                    throw new SyntaxError('A default value for an argument must be a constant (a boolean, a string, a number, a sequence, or a mapping).', $token->getLine(), $stream->getSourceContext());
                }
            }
            else {
                $value = $this->parseExpression();
            }
        }
        if ($definition) {
            if (null === $name) {
                $name = $value->getAttribute('name');
                $value = new ConstantExpression(null, $this->parser
                    ->getCurrentToken()
                    ->getLine());
                $value->setAttribute('is_implicit', true);
            }
            $args[$name] = $value;
        }
        else {
            if (null === $name) {
                $args[] = $value;
            }
            else {
                $args[$name] = $value;
            }
        }
    }
    $stream->expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
    return new Nodes($args);
}