vendor/twig/twig/src/ExpressionParser.php line 430

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  * (c) Armin Ronacher
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Twig;
  15. use Twig\Error\SyntaxError;
  16. use Twig\Node\Expression\AbstractExpression;
  17. use Twig\Node\Expression\ArrayExpression;
  18. use Twig\Node\Expression\ArrowFunctionExpression;
  19. use Twig\Node\Expression\AssignNameExpression;
  20. use Twig\Node\Expression\Binary\AbstractBinary;
  21. use Twig\Node\Expression\Binary\ConcatBinary;
  22. use Twig\Node\Expression\BlockReferenceExpression;
  23. use Twig\Node\Expression\ConditionalExpression;
  24. use Twig\Node\Expression\ConstantExpression;
  25. use Twig\Node\Expression\GetAttrExpression;
  26. use Twig\Node\Expression\MethodCallExpression;
  27. use Twig\Node\Expression\NameExpression;
  28. use Twig\Node\Expression\ParentExpression;
  29. use Twig\Node\Expression\TestExpression;
  30. use Twig\Node\Expression\Unary\AbstractUnary;
  31. use Twig\Node\Expression\Unary\NegUnary;
  32. use Twig\Node\Expression\Unary\NotUnary;
  33. use Twig\Node\Expression\Unary\PosUnary;
  34. use Twig\Node\Node;
  36. /**
  37.  * Parses expressions.
  38.  *
  39.  * This parser implements a "Precedence climbing" algorithm.
  40.  *
  41.  * @see https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
  42.  * @see https://en.wikipedia.org/wiki/Operator-precedence_parser
  43.  *
  44.  * @author Fabien Potencier <fabien@symfony.com>
  45.  */
  46. class ExpressionParser
  47. {
  48.     public const OPERATOR_LEFT = 1;
  49.     public const OPERATOR_RIGHT = 2;
  51.     private $parser;
  52.     private $env;
  53.     /** @var array<string, array{precedence: int, class: class-string<AbstractUnary>}> */
  54.     private $unaryOperators;
  55.     /** @var array<string, array{precedence: int, class: class-string<AbstractBinary>, associativity: self::OPERATOR_*}> */
  56.     private $binaryOperators;
  58.     public function __construct(Parser $parser, Environment $env)
  59.     {
  60.         $this->parser = $parser;
  61.         $this->env = $env;
  62.         $this->unaryOperators = $env->getUnaryOperators();
  63.         $this->binaryOperators = $env->getBinaryOperators();
  64.     }
  66.     public function parseExpression($precedence = 0, $allowArrow = false)
  67.     {
  68.         if ($allowArrow && $arrow = $this->parseArrow()) {
  69.             return $arrow;
  70.         }
  72.         $expr = $this->getPrimary();
  73.         $token = $this->parser->getCurrentToken();
  74.         while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
  75.             $op = $this->binaryOperators[$token->getValue()];
  76.             $this->parser->getStream()->next();
  78.             if ('is not' === $token->getValue()) {
  79.                 $expr = $this->parseNotTestExpression($expr);
  80.             } elseif ('is' === $token->getValue()) {
  81.                 $expr = $this->parseTestExpression($expr);
  82.             } elseif (isset($op['callable'])) {
  83.                 $expr = $op['callable']($this->parser, $expr);
  84.             } else {
  85.                 $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence'], true);
  86.                 $class = $op['class'];
  87.                 $expr = new $class($expr, $expr1, $token->getLine());
  88.             }
  90.             $token = $this->parser->getCurrentToken();
  91.         }
  93.         if (0 === $precedence) {
  94.             return $this->parseConditionalExpression($expr);
  95.         }
  97.         return $expr;
  98.     }
  100.     /**
  101.      * @return ArrowFunctionExpression|null
  102.      */
  103.     private function parseArrow()
  104.     {
  105.         $stream = $this->parser->getStream();
  107.         // short array syntax (one argument, no parentheses)?
  108.         if ($stream->look(1)->test(/* Token::ARROW_TYPE */ 12)) {
  109.             $line = $stream->getCurrent()->getLine();
  110.             $token = $stream->expect(/* Token::NAME_TYPE */ 5);
  111.             $names = [new AssignNameExpression($token->getValue(), $token->getLine())];
  112.             $stream->expect(/* Token::ARROW_TYPE */ 12);
  114.             return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  115.         }
  117.         // first, determine if we are parsing an arrow function by finding => (long form)
  118.         $i = 0;
  119.         if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  120.             return null;
  121.         }
  122.         ++$i;
  123.         while (true) {
  124.             // variable name
  125.             ++$i;
  126.             if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  127.                 break;
  128.             }
  129.             ++$i;
  130.         }
  131.         if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  132.             return null;
  133.         }
  134.         ++$i;
  135.         if (!$stream->look($i)->test(/* Token::ARROW_TYPE */ 12)) {
  136.             return null;
  137.         }
  139.         // yes, let's parse it properly
  140.         $token = $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '(');
  141.         $line = $token->getLine();
  143.         $names = [];
  144.         while (true) {
  145.             $token = $stream->expect(/* Token::NAME_TYPE */ 5);
  146.             $names[] = new AssignNameExpression($token->getValue(), $token->getLine());
  148.             if (!$stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  149.                 break;
  150.             }
  151.         }
  152.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ')');
  153.         $stream->expect(/* Token::ARROW_TYPE */ 12);
  155.         return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  156.     }
  158.     private function getPrimary(): AbstractExpression
  159.     {
  160.         $token = $this->parser->getCurrentToken();
  162.         if ($this->isUnary($token)) {
  163.             $operator = $this->unaryOperators[$token->getValue()];
  164.             $this->parser->getStream()->next();
  165.             $expr = $this->parseExpression($operator['precedence']);
  166.             $class = $operator['class'];
  168.             return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
  169.         } elseif ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  170.             $this->parser->getStream()->next();
  171.             $expr = $this->parseExpression();
  172.             $this->parser->getStream()->expect(/* Token::PUNCTUATION_TYPE */ 9, ')', 'An opened parenthesis is not properly closed');
  174.             return $this->parsePostfixExpression($expr);
  175.         }
  177.         return $this->parsePrimaryExpression();
  178.     }
  180.     private function parseConditionalExpression($expr): AbstractExpression
  181.     {
  182.         while ($this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, '?')) {
  183.             if (!$this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  184.                 $expr2 = $this->parseExpression();
  185.                 if ($this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  186.                     $expr3 = $this->parseExpression();
  187.                 } else {
  188.                     $expr3 = new ConstantExpression('', $this->parser->getCurrentToken()->getLine());
  189.                 }
  190.             } else {
  191.                 $expr2 = $expr;
  192.                 $expr3 = $this->parseExpression();
  193.             }
  195.             $expr = new ConditionalExpression($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
  196.         }
  198.         return $expr;
  199.     }
  201.     private function isUnary(Token $token): bool
  202.     {
  203.         return $token->test(/* Token::OPERATOR_TYPE */ 8) && isset($this->unaryOperators[$token->getValue()]);
  204.     }
  206.     private function isBinary(Token $token): bool
  207.     {
  208.         return $token->test(/* Token::OPERATOR_TYPE */ 8) && isset($this->binaryOperators[$token->getValue()]);
  209.     }
  211.     public function parsePrimaryExpression()
  212.     {
  213.         $token = $this->parser->getCurrentToken();
  214.         switch ($token->getType()) {
  215.             case /* Token::NAME_TYPE */ 5:
  216.                 $this->parser->getStream()->next();
  217.                 switch ($token->getValue()) {
  218.                     case 'true':
  219.                     case 'TRUE':
  220.                         $node = new ConstantExpression(true, $token->getLine());
  221.                         break;
  223.                     case 'false':
  224.                     case 'FALSE':
  225.                         $node = new ConstantExpression(false, $token->getLine());
  226.                         break;
  228.                     case 'none':
  229.                     case 'NONE':
  230.                     case 'null':
  231.                     case 'NULL':
  232.                         $node = new ConstantExpression(null, $token->getLine());
  233.                         break;
  235.                     default:
  236.                         if ('(' === $this->parser->getCurrentToken()->getValue()) {
  237.                             $node = $this->getFunctionNode($token->getValue(), $token->getLine());
  238.                         } else {
  239.                             $node = new NameExpression($token->getValue(), $token->getLine());
  240.                         }
  241.                 }
  242.                 break;
  244.             case /* Token::NUMBER_TYPE */ 6:
  245.                 $this->parser->getStream()->next();
  246.                 $node = new ConstantExpression($token->getValue(), $token->getLine());
  247.                 break;
  249.             case /* Token::STRING_TYPE */ 7:
  250.             case /* Token::INTERPOLATION_START_TYPE */ 10:
  251.                 $node = $this->parseStringExpression();
  252.                 break;
  254.             case /* Token::OPERATOR_TYPE */ 8:
  255.                 if (preg_match(Lexer::REGEX_NAME, $token->getValue(), $matches) && $matches[0] == $token->getValue()) {
  256.                     // in this context, string operators are variable names
  257.                     $this->parser->getStream()->next();
  258.                     $node = new NameExpression($token->getValue(), $token->getLine());
  259.                     break;
  260.                 }
  262.                 if (isset($this->unaryOperators[$token->getValue()])) {
  263.                     $class = $this->unaryOperators[$token->getValue()]['class'];
  264.                     if (!\in_array($class, [NegUnary::class, PosUnary::class])) {
  265.                         throw new SyntaxError(sprintf('Unexpected unary operator "%s".', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  266.                     }
  268.                     $this->parser->getStream()->next();
  269.                     $expr = $this->parsePrimaryExpression();
  271.                     $node = new $class($expr, $token->getLine());
  272.                     break;
  273.                 }
  275.                 // no break
  276.             default:
  277.                 if ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '[')) {
  278.                     $node = $this->parseArrayExpression();
  279.                 } elseif ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '{')) {
  280.                     $node = $this->parseHashExpression();
  281.                 } elseif ($token->test(/* Token::OPERATOR_TYPE */ 8, '=') && ('==' === $this->parser->getStream()->look(-1)->getValue() || '!=' === $this->parser->getStream()->look(-1)->getValue())) {
  282.                     throw new SyntaxError(sprintf('Unexpected operator of value "%s". Did you try to use "===" or "!==" for strict comparison? Use "is same as(value)" instead.', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  283.                 } else {
  284.                     throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s".', Token::typeToEnglish($token->getType()), $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  285.                 }
  286.         }
  288.         return $this->parsePostfixExpression($node);
  289.     }
  291.     public function parseStringExpression()
  292.     {
  293.         $stream = $this->parser->getStream();
  295.         $nodes = [];
  296.         // a string cannot be followed by another string in a single expression
  297.         $nextCanBeString = true;
  298.         while (true) {
  299.             if ($nextCanBeString && $token = $stream->nextIf(/* Token::STRING_TYPE */ 7)) {
  300.                 $nodes[] = new ConstantExpression($token->getValue(), $token->getLine());
  301.                 $nextCanBeString = false;
  302.             } elseif ($stream->nextIf(/* Token::INTERPOLATION_START_TYPE */ 10)) {
  303.                 $nodes[] = $this->parseExpression();
  304.                 $stream->expect(/* Token::INTERPOLATION_END_TYPE */ 11);
  305.                 $nextCanBeString = true;
  306.             } else {
  307.                 break;
  308.             }
  309.         }
  311.         $expr = array_shift($nodes);
  312.         foreach ($nodes as $node) {
  313.             $expr = new ConcatBinary($expr, $node, $node->getTemplateLine());
  314.         }
  316.         return $expr;
  317.     }
  319.     public function parseArrayExpression()
  320.     {
  321.         $stream = $this->parser->getStream();
  322.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '[', 'An array element was expected');
  324.         $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  325.         $first = true;
  326.         while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  327.             if (!$first) {
  328.                 $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'An array element must be followed by a comma');
  330.                 // trailing ,?
  331.                 if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  332.                     break;
  333.                 }
  334.             }
  335.             $first = false;
  337.             $node->addElement($this->parseExpression());
  338.         }
  339.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']', 'An opened array is not properly closed');
  341.         return $node;
  342.     }
  344.     public function parseHashExpression()
  345.     {
  346.         $stream = $this->parser->getStream();
  347.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '{', 'A hash element was expected');
  349.         $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  350.         $first = true;
  351.         while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, '}')) {
  352.             if (!$first) {
  353.                 $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'A hash value must be followed by a comma');
  355.                 // trailing ,?
  356.                 if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '}')) {
  357.                     break;
  358.                 }
  359.             }
  360.             $first = false;
  362.             // a hash key can be:
  363.             //
  364.             //  * a number -- 12
  365.             //  * a string -- 'a'
  366.             //  * a name, which is equivalent to a string -- a
  367.             //  * an expression, which must be enclosed in parentheses -- (1 + 2)
  368.             if ($token = $stream->nextIf(/* Token::NAME_TYPE */ 5)) {
  369.                 $key = new ConstantExpression($token->getValue(), $token->getLine());
  371.                 // {a} is a shortcut for {a:a}
  372.                 if ($stream->test(Token::PUNCTUATION_TYPE, [',', '}'])) {
  373.                     $value = new NameExpression($key->getAttribute('value'), $key->getTemplateLine());
  374.                     $node->addElement($value, $key);
  375.                     continue;
  376.                 }
  377.             } elseif (($token = $stream->nextIf(/* Token::STRING_TYPE */ 7)) || $token = $stream->nextIf(/* Token::NUMBER_TYPE */ 6)) {
  378.                 $key = new ConstantExpression($token->getValue(), $token->getLine());
  379.             } elseif ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  380.                 $key = $this->parseExpression();
  381.             } else {
  382.                 $current = $stream->getCurrent();
  384.                 throw new SyntaxError(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s".', Token::typeToEnglish($current->getType()), $current->getValue()), $current->getLine(), $stream->getSourceContext());
  385.             }
  387.             $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ':', 'A hash key must be followed by a colon (:)');
  388.             $value = $this->parseExpression();
  390.             $node->addElement($value, $key);
  391.         }
  392.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '}', 'An opened hash is not properly closed');
  394.         return $node;
  395.     }
  397.     public function parsePostfixExpression($node)
  398.     {
  399.         while (true) {
  400.             $token = $this->parser->getCurrentToken();
  401.             if (/* Token::PUNCTUATION_TYPE */ 9 == $token->getType()) {
  402.                 if ('.' == $token->getValue() || '[' == $token->getValue()) {
  403.                     $node = $this->parseSubscriptExpression($node);
  404.                 } elseif ('|' == $token->getValue()) {
  405.                     $node = $this->parseFilterExpression($node);
  406.                 } else {
  407.                     break;
  408.                 }
  409.             } else {
  410.                 break;
  411.             }
  412.         }
  414.         return $node;
  415.     }
  417.     public function getFunctionNode($name, $line)
  418.     {
  419.         switch ($name) {
  420.             case 'parent':
  421.                 $this->parseArguments();
  422.                 if (!\count($this->parser->getBlockStack())) {
  423.                     throw new SyntaxError('Calling "parent" outside a block is forbidden.', $line, $this->parser->getStream()->getSourceContext());
  424.                 }
  426.                 if (!$this->parser->getParent() && !$this->parser->hasTraits()) {
  427.                     throw new SyntaxError('Calling "parent" on a template that does not extend nor "use" another template is forbidden.', $line, $this->parser->getStream()->getSourceContext());
  428.                 }
  430.                 return new ParentExpression($this->parser->peekBlockStack(), $line);
  431.             case 'block':
  432.                 $args = $this->parseArguments();
  433.                 if (\count($args) < 1) {
  434.                     throw new SyntaxError('The "block" function takes one argument (the block name).', $line, $this->parser->getStream()->getSourceContext());
  435.                 }
  437.                 return new BlockReferenceExpression($args->getNode(0), \count($args) > 1 ? $args->getNode(1) : null, $line);
  438.             case 'attribute':
  439.                 $args = $this->parseArguments();
  440.                 if (\count($args) < 2) {
  441.                     throw new SyntaxError('The "attribute" function takes at least two arguments (the variable and the attributes).', $line, $this->parser->getStream()->getSourceContext());
  442.                 }
  444.                 return new GetAttrExpression($args->getNode(0), $args->getNode(1), \count($args) > 2 ? $args->getNode(2) : null, Template::ANY_CALL, $line);
  445.             default:
  446.                 if (null !== $alias = $this->parser->getImportedSymbol('function', $name)) {
  447.                     $arguments = new ArrayExpression([], $line);
  448.                     foreach ($this->parseArguments() as $n) {
  449.                         $arguments->addElement($n);
  450.                     }
  452.                     $node = new MethodCallExpression($alias['node'], $alias['name'], $arguments, $line);
  453.                     $node->setAttribute('safe', true);
  455.                     return $node;
  456.                 }
  458.                 $args = $this->parseArguments(true);
  459.                 $class = $this->getFunctionNodeClass($name, $line);
  461.                 return new $class($name, $args, $line);
  462.         }
  463.     }
  465.     public function parseSubscriptExpression($node)
  466.     {
  467.         $stream = $this->parser->getStream();
  468.         $token = $stream->next();
  469.         $lineno = $token->getLine();
  470.         $arguments = new ArrayExpression([], $lineno);
  471.         $type = Template::ANY_CALL;
  472.         if ('.' == $token->getValue()) {
  473.             $token = $stream->next();
  474.             if (
  475.                 /* Token::NAME_TYPE */ 5 == $token->getType()
  476.                 ||
  477.                 /* Token::NUMBER_TYPE */ 6 == $token->getType()
  478.                 ||
  479.                 (/* Token::OPERATOR_TYPE */ 8 == $token->getType() && preg_match(Lexer::REGEX_NAME, $token->getValue()))
  480.             ) {
  481.                 $arg = new ConstantExpression($token->getValue(), $lineno);
  483.                 if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  484.                     $type = Template::METHOD_CALL;
  485.                     foreach ($this->parseArguments() as $n) {
  486.                         $arguments->addElement($n);
  487.                     }
  488.                 }
  489.             } else {
  490.                 throw new SyntaxError(sprintf('Expected name or number, got value "%s" of type %s.', $token->getValue(), Token::typeToEnglish($token->getType())), $lineno, $stream->getSourceContext());
  491.             }
  493.             if ($node instanceof NameExpression && null !== $this->parser->getImportedSymbol('template', $node->getAttribute('name'))) {
  494.                 if (!$arg instanceof ConstantExpression) {
  495.                     throw new SyntaxError(sprintf('Dynamic macro names are not supported (called on "%s").', $node->getAttribute('name')), $token->getLine(), $stream->getSourceContext());
  496.                 }
  498.                 $name = $arg->getAttribute('value');
  500.                 $node = new MethodCallExpression($node, 'macro_'.$name, $arguments, $lineno);
  501.                 $node->setAttribute('safe', true);
  503.                 return $node;
  504.             }
  505.         } else {
  506.             $type = Template::ARRAY_CALL;
  508.             // slice?
  509.             $slice = false;
  510.             if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  511.                 $slice = true;
  512.                 $arg = new ConstantExpression(0, $token->getLine());
  513.             } else {
  514.                 $arg = $this->parseExpression();
  515.             }
  517.             if ($stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  518.                 $slice = true;
  519.             }
  521.             if ($slice) {
  522.                 if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  523.                     $length = new ConstantExpression(null, $token->getLine());
  524.                 } else {
  525.                     $length = $this->parseExpression();
  526.                 }
  528.                 $class = $this->getFilterNodeClass('slice', $token->getLine());
  529.                 $arguments = new Node([$arg, $length]);
  530.                 $filter = new $class($node, new ConstantExpression('slice', $token->getLine()), $arguments, $token->getLine());
  532.                 $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']');
  534.                 return $filter;
  535.             }
  537.             $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']');
  538.         }
  540.         return new GetAttrExpression($node, $arg, $arguments, $type, $lineno);
  541.     }
  543.     public function parseFilterExpression($node)
  544.     {
  545.         $this->parser->getStream()->next();
  547.         return $this->parseFilterExpressionRaw($node);
  548.     }
  550.     public function parseFilterExpressionRaw($node, $tag = null)
  551.     {
  552.         while (true) {
  553.             $token = $this->parser->getStream()->expect(/* Token::NAME_TYPE */ 5);
  555.             $name = new ConstantExpression($token->getValue(), $token->getLine());
  556.             if (!$this->parser->getStream()->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  557.                 $arguments = new Node();
  558.             } else {
  559.                 $arguments = $this->parseArguments(true, false, true);
  560.             }
  562.             $class = $this->getFilterNodeClass($name->getAttribute('value'), $token->getLine());
  564.             $node = new $class($node, $name, $arguments, $token->getLine(), $tag);
  566.             if (!$this->parser->getStream()->test(/* Token::PUNCTUATION_TYPE */ 9, '|')) {
  567.                 break;
  568.             }
  570.             $this->parser->getStream()->next();
  571.         }
  573.         return $node;
  574.     }
  576.     /**
  577.      * Parses arguments.
  578.      *
  579.      * @param bool $namedArguments Whether to allow named arguments or not
  580.      * @param bool $definition     Whether we are parsing arguments for a function definition
  581.      *
  582.      * @return Node
  583.      *
  584.      * @throws SyntaxError
  585.      */
  586.     public function parseArguments($namedArguments = false, $definition = false, $allowArrow = false)
  587.     {
  588.         $args = [];
  589.         $stream = $this->parser->getStream();
  591.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '(', 'A list of arguments must begin with an opening parenthesis');
  592.         while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  593.             if (!empty($args)) {
  594.                 $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'Arguments must be separated by a comma');
  596.                 // if the comma above was a trailing comma, early exit the argument parse loop
  597.                 if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  598.                     break;
  599.                 }
  600.             }
  602.             if ($definition) {
  603.                 $token = $stream->expect(/* Token::NAME_TYPE */ 5, null, 'An argument must be a name');
  604.                 $value = new NameExpression($token->getValue(), $this->parser->getCurrentToken()->getLine());
  605.             } else {
  606.                 $value = $this->parseExpression(0, $allowArrow);
  607.             }
  609.             $name = null;
  610.             if ($namedArguments && $token = $stream->nextIf(/* Token::OPERATOR_TYPE */ 8, '=')) {
  611.                 if (!$value instanceof NameExpression) {
  612.                     throw new SyntaxError(sprintf('A parameter name must be a string, "%s" given.', \get_class($value)), $token->getLine(), $stream->getSourceContext());
  613.                 }
  614.                 $name = $value->getAttribute('name');
  616.                 if ($definition) {
  617.                     $value = $this->parsePrimaryExpression();
  619.                     if (!$this->checkConstantExpression($value)) {
  620.                         throw new SyntaxError('A default value for an argument must be a constant (a boolean, a string, a number, or an array).', $token->getLine(), $stream->getSourceContext());
  621.                     }
  622.                 } else {
  623.                     $value = $this->parseExpression(0, $allowArrow);
  624.                 }
  625.             }
  627.             if ($definition) {
  628.                 if (null === $name) {
  629.                     $name = $value->getAttribute('name');
  630.                     $value = new ConstantExpression(null, $this->parser->getCurrentToken()->getLine());
  631.                 }
  632.                 $args[$name] = $value;
  633.             } else {
  634.                 if (null === $name) {
  635.                     $args[] = $value;
  636.                 } else {
  637.                     $args[$name] = $value;
  638.                 }
  639.             }
  640.         }
  641.         $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ')', 'A list of arguments must be closed by a parenthesis');
  643.         return new Node($args);
  644.     }
  646.     public function parseAssignmentExpression()
  647.     {
  648.         $stream = $this->parser->getStream();
  649.         $targets = [];
  650.         while (true) {
  651.             $token = $this->parser->getCurrentToken();
  652.             if ($stream->test(/* Token::OPERATOR_TYPE */ 8) && preg_match(Lexer::REGEX_NAME, $token->getValue())) {
  653.                 // in this context, string operators are variable names
  654.                 $this->parser->getStream()->next();
  655.             } else {
  656.                 $stream->expect(/* Token::NAME_TYPE */ 5, null, 'Only variables can be assigned to');
  657.             }
  658.             $value = $token->getValue();
  659.             if (\in_array(strtr($value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), ['true', 'false', 'none', 'null'])) {
  660.                 throw new SyntaxError(sprintf('You cannot assign a value to "%s".', $value), $token->getLine(), $stream->getSourceContext());
  661.             }
  662.             $targets[] = new AssignNameExpression($value, $token->getLine());
  664.             if (!$stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  665.                 break;
  666.             }
  667.         }
  669.         return new Node($targets);
  670.     }
  672.     public function parseMultitargetExpression()
  673.     {
  674.         $targets = [];
  675.         while (true) {
  676.             $targets[] = $this->parseExpression();
  677.             if (!$this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  678.                 break;
  679.             }
  680.         }
  682.         return new Node($targets);
  683.     }
  685.     private function parseNotTestExpression(Node $node): NotUnary
  686.     {
  687.         return new NotUnary($this->parseTestExpression($node), $this->parser->getCurrentToken()->getLine());
  688.     }
  690.     private function parseTestExpression(Node $node): TestExpression
  691.     {
  692.         $stream = $this->parser->getStream();
  693.         list($name, $test) = $this->getTest($node->getTemplateLine());
  695.         $class = $this->getTestNodeClass($test);
  696.         $arguments = null;
  697.         if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  698.             $arguments = $this->parseArguments(true);
  699.         } elseif ($test->hasOneMandatoryArgument()) {
  700.             $arguments = new Node([0 => $this->parsePrimaryExpression()]);
  701.         }
  703.         if ('defined' === $name && $node instanceof NameExpression && null !== $alias = $this->parser->getImportedSymbol('function', $node->getAttribute('name'))) {
  704.             $node = new MethodCallExpression($alias['node'], $alias['name'], new ArrayExpression([], $node->getTemplateLine()), $node->getTemplateLine());
  705.             $node->setAttribute('safe', true);
  706.         }
  708.         return new $class($node, $name, $arguments, $this->parser->getCurrentToken()->getLine());
  709.     }
  711.     private function getTest(int $line): array
  712.     {
  713.         $stream = $this->parser->getStream();
  714.         $name = $stream->expect(/* Token::NAME_TYPE */ 5)->getValue();
  716.         if ($test = $this->env->getTest($name)) {
  717.             return [$name, $test];
  718.         }
  720.         if ($stream->test(/* Token::NAME_TYPE */ 5)) {
  721.             // try 2-words tests
  722.             $name = $name.' '.$this->parser->getCurrentToken()->getValue();
  724.             if ($test = $this->env->getTest($name)) {
  725.                 $stream->next();
  727.                 return [$name, $test];
  728.             }
  729.         }
  731.         $e = new SyntaxError(sprintf('Unknown "%s" test.', $name), $line, $stream->getSourceContext());
  732.         $e->addSuggestions($name, array_keys($this->env->getTests()));
  734.         throw $e;
  735.     }
  737.     private function getTestNodeClass(TwigTest $test): string
  738.     {
  739.         if ($test->isDeprecated()) {
  740.             $stream = $this->parser->getStream();
  741.             $message = sprintf('Twig Test "%s" is deprecated', $test->getName());
  743.             if ($test->getDeprecatedVersion()) {
  744.                 $message .= sprintf(' since version %s', $test->getDeprecatedVersion());
  745.             }
  746.             if ($test->getAlternative()) {
  747.                 $message .= sprintf('. Use "%s" instead', $test->getAlternative());
  748.             }
  749.             $src = $stream->getSourceContext();
  750.             $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $stream->getCurrent()->getLine());
  752.             @trigger_error($message, \E_USER_DEPRECATED);
  753.         }
  755.         return $test->getNodeClass();
  756.     }
  758.     private function getFunctionNodeClass(string $name, int $line): string
  759.     {
  760.         if (!$function = $this->env->getFunction($name)) {
  761.             $e = new SyntaxError(sprintf('Unknown "%s" function.', $name), $line, $this->parser->getStream()->getSourceContext());
  762.             $e->addSuggestions($name, array_keys($this->env->getFunctions()));
  764.             throw $e;
  765.         }
  767.         if ($function->isDeprecated()) {
  768.             $message = sprintf('Twig Function "%s" is deprecated', $function->getName());
  769.             if ($function->getDeprecatedVersion()) {
  770.                 $message .= sprintf(' since version %s', $function->getDeprecatedVersion());
  771.             }
  772.             if ($function->getAlternative()) {
  773.                 $message .= sprintf('. Use "%s" instead', $function->getAlternative());
  774.             }
  775.             $src = $this->parser->getStream()->getSourceContext();
  776.             $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  778.             @trigger_error($message, \E_USER_DEPRECATED);
  779.         }
  781.         return $function->getNodeClass();
  782.     }
  784.     private function getFilterNodeClass(string $name, int $line): string
  785.     {
  786.         if (!$filter = $this->env->getFilter($name)) {
  787.             $e = new SyntaxError(sprintf('Unknown "%s" filter.', $name), $line, $this->parser->getStream()->getSourceContext());
  788.             $e->addSuggestions($name, array_keys($this->env->getFilters()));
  790.             throw $e;
  791.         }
  793.         if ($filter->isDeprecated()) {
  794.             $message = sprintf('Twig Filter "%s" is deprecated', $filter->getName());
  795.             if ($filter->getDeprecatedVersion()) {
  796.                 $message .= sprintf(' since version %s', $filter->getDeprecatedVersion());
  797.             }
  798.             if ($filter->getAlternative()) {
  799.                 $message .= sprintf('. Use "%s" instead', $filter->getAlternative());
  800.             }
  801.             $src = $this->parser->getStream()->getSourceContext();
  802.             $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  804.             @trigger_error($message, \E_USER_DEPRECATED);
  805.         }
  807.         return $filter->getNodeClass();
  808.     }
  810.     // checks that the node only contains "constant" elements
  811.     private function checkConstantExpression(Node $node): bool
  812.     {
  813.         if (!($node instanceof ConstantExpression || $node instanceof ArrayExpression
  814.             || $node instanceof NegUnary || $node instanceof PosUnary
  815.         )) {
  816.             return false;
  817.         }
  819.         foreach ($node as $n) {
  820.             if (!$this->checkConstantExpression($n)) {
  821.                 return false;
  822.             }
  823.         }
  825.         return true;
  826.     }
  827. }