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

  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\Attribute\FirstClassTwigCallableReady;
  16. use Twig\Error\SyntaxError;
  17. use Twig\Node\Expression\AbstractExpression;
  18. use Twig\Node\Expression\ArrayExpression;
  19. use Twig\Node\Expression\ArrowFunctionExpression;
  20. use Twig\Node\Expression\AssignNameExpression;
  21. use Twig\Node\Expression\Binary\AbstractBinary;
  22. use Twig\Node\Expression\Binary\ConcatBinary;
  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\TestExpression;
  29. use Twig\Node\Expression\Unary\AbstractUnary;
  30. use Twig\Node\Expression\Unary\NegUnary;
  31. use Twig\Node\Expression\Unary\NotUnary;
  32. use Twig\Node\Expression\Unary\PosUnary;
  33. use Twig\Node\Node;
  35. /**
  36.  * Parses expressions.
  37.  *
  38.  * This parser implements a "Precedence climbing" algorithm.
  39.  *
  40.  * @see https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
  41.  * @see https://en.wikipedia.org/wiki/Operator-precedence_parser
  42.  *
  43.  * @author Fabien Potencier <fabien@symfony.com>
  44.  */
  45. class ExpressionParser
  46. {
  47.     public const OPERATOR_LEFT = 1;
  48.     public const OPERATOR_RIGHT = 2;
  50.     /** @var array<string, array{precedence: int, class: class-string<AbstractUnary>}> */
  51.     private $unaryOperators;
  52.     /** @var array<string, array{precedence: int, class: class-string<AbstractBinary>, associativity: self::OPERATOR_*}> */
  53.     private $binaryOperators;
  54.     private $readyNodes = [];
  56.     public function __construct(
  57.         private Parser $parser,
  58.         private Environment $env,
  59.     ) {
  60.         $this->unaryOperators = $env->getUnaryOperators();
  61.         $this->binaryOperators = $env->getBinaryOperators();
  62.     }
  64.     public function parseExpression($precedence = 0, $allowArrow = false)
  65.     {
  66.         if ($allowArrow && $arrow = $this->parseArrow()) {
  67.             return $arrow;
  68.         }
  70.         $expr = $this->getPrimary();
  71.         $token = $this->parser->getCurrentToken();
  72.         while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
  73.             $op = $this->binaryOperators[$token->getValue()];
  74.             $this->parser->getStream()->next();
  76.             if ('is not' === $token->getValue()) {
  77.                 $expr = $this->parseNotTestExpression($expr);
  78.             } elseif ('is' === $token->getValue()) {
  79.                 $expr = $this->parseTestExpression($expr);
  80.             } elseif (isset($op['callable'])) {
  81.                 $expr = $op['callable']($this->parser, $expr);
  82.             } else {
  83.                 $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence'], true);
  84.                 $class = $op['class'];
  85.                 $expr = new $class($expr, $expr1, $token->getLine());
  86.             }
  88.             $token = $this->parser->getCurrentToken();
  89.         }
  91.         if (0 === $precedence) {
  92.             return $this->parseConditionalExpression($expr);
  93.         }
  95.         return $expr;
  96.     }
  98.     /**
  99.      * @return ArrowFunctionExpression|null
  100.      */
  101.     private function parseArrow()
  102.     {
  103.         $stream = $this->parser->getStream();
  105.         // short array syntax (one argument, no parentheses)?
  106.         if ($stream->look(1)->test(Token::ARROW_TYPE)) {
  107.             $line = $stream->getCurrent()->getLine();
  108.             $token = $stream->expect(Token::NAME_TYPE);
  109.             $names = [new AssignNameExpression($token->getValue(), $token->getLine())];
  110.             $stream->expect(Token::ARROW_TYPE);
  112.             return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  113.         }
  115.         // first, determine if we are parsing an arrow function by finding => (long form)
  116.         $i = 0;
  117.         if (!$stream->look($i)->test(Token::PUNCTUATION_TYPE, '(')) {
  118.             return null;
  119.         }
  120.         ++$i;
  121.         while (true) {
  122.             // variable name
  123.             ++$i;
  124.             if (!$stream->look($i)->test(Token::PUNCTUATION_TYPE, ',')) {
  125.                 break;
  126.             }
  127.             ++$i;
  128.         }
  129.         if (!$stream->look($i)->test(Token::PUNCTUATION_TYPE, ')')) {
  130.             return null;
  131.         }
  132.         ++$i;
  133.         if (!$stream->look($i)->test(Token::ARROW_TYPE)) {
  134.             return null;
  135.         }
  137.         // yes, let's parse it properly
  138.         $token = $stream->expect(Token::PUNCTUATION_TYPE, '(');
  139.         $line = $token->getLine();
  141.         $names = [];
  142.         while (true) {
  143.             $token = $stream->expect(Token::NAME_TYPE);
  144.             $names[] = new AssignNameExpression($token->getValue(), $token->getLine());
  146.             if (!$stream->nextIf(Token::PUNCTUATION_TYPE, ',')) {
  147.                 break;
  148.             }
  149.         }
  150.         $stream->expect(Token::PUNCTUATION_TYPE, ')');
  151.         $stream->expect(Token::ARROW_TYPE);
  153.         return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  154.     }
  156.     private function getPrimary(): AbstractExpression
  157.     {
  158.         $token = $this->parser->getCurrentToken();
  160.         if ($this->isUnary($token)) {
  161.             $operator = $this->unaryOperators[$token->getValue()];
  162.             $this->parser->getStream()->next();
  163.             $expr = $this->parseExpression($operator['precedence']);
  164.             $class = $operator['class'];
  166.             return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
  167.         } elseif ($token->test(Token::PUNCTUATION_TYPE, '(')) {
  168.             $this->parser->getStream()->next();
  169.             $expr = $this->parseExpression();
  170.             $this->parser->getStream()->expect(Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
  172.             return $this->parsePostfixExpression($expr);
  173.         }
  175.         return $this->parsePrimaryExpression();
  176.     }
  178.     private function parseConditionalExpression($expr): AbstractExpression
  179.     {
  180.         while ($this->parser->getStream()->nextIf(Token::PUNCTUATION_TYPE, '?')) {
  181.             if (!$this->parser->getStream()->nextIf(Token::PUNCTUATION_TYPE, ':')) {
  182.                 $expr2 = $this->parseExpression();
  183.                 if ($this->parser->getStream()->nextIf(Token::PUNCTUATION_TYPE, ':')) {
  184.                     // Ternary operator (expr ? expr2 : expr3)
  185.                     $expr3 = $this->parseExpression();
  186.                 } else {
  187.                     // Ternary without else (expr ? expr2)
  188.                     $expr3 = new ConstantExpression('', $this->parser->getCurrentToken()->getLine());
  189.                 }
  190.             } else {
  191.                 // Ternary without then (expr ?: expr3)
  192.                 $expr2 = $expr;
  193.                 $expr3 = $this->parseExpression();
  194.             }
  196.             $expr = new ConditionalExpression($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
  197.         }
  199.         return $expr;
  200.     }
  202.     private function isUnary(Token $token): bool
  203.     {
  204.         return $token->test(Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->getValue()]);
  205.     }
  207.     private function isBinary(Token $token): bool
  208.     {
  209.         return $token->test(Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->getValue()]);
  210.     }
  212.     public function parsePrimaryExpression()
  213.     {
  214.         $token = $this->parser->getCurrentToken();
  215.         switch ($token->getType()) {
  216.             case Token::NAME_TYPE:
  217.                 $this->parser->getStream()->next();
  218.                 switch ($token->getValue()) {
  219.                     case 'true':
  220.                     case 'TRUE':
  221.                         $node = new ConstantExpression(true, $token->getLine());
  222.                         break;
  224.                     case 'false':
  225.                     case 'FALSE':
  226.                         $node = new ConstantExpression(false, $token->getLine());
  227.                         break;
  229.                     case 'none':
  230.                     case 'NONE':
  231.                     case 'null':
  232.                     case 'NULL':
  233.                         $node = new ConstantExpression(null, $token->getLine());
  234.                         break;
  236.                     default:
  237.                         if ('(' === $this->parser->getCurrentToken()->getValue()) {
  238.                             $node = $this->getFunctionNode($token->getValue(), $token->getLine());
  239.                         } else {
  240.                             $node = new NameExpression($token->getValue(), $token->getLine());
  241.                         }
  242.                 }
  243.                 break;
  245.             case Token::NUMBER_TYPE:
  246.                 $this->parser->getStream()->next();
  247.                 $node = new ConstantExpression($token->getValue(), $token->getLine());
  248.                 break;
  250.             case Token::STRING_TYPE:
  251.             case Token::INTERPOLATION_START_TYPE:
  252.                 $node = $this->parseStringExpression();
  253.                 break;
  255.             case Token::OPERATOR_TYPE:
  256.                 if (preg_match(Lexer::REGEX_NAME, $token->getValue(), $matches) && $matches[0] == $token->getValue()) {
  257.                     // in this context, string operators are variable names
  258.                     $this->parser->getStream()->next();
  259.                     $node = new NameExpression($token->getValue(), $token->getLine());
  260.                     break;
  261.                 }
  263.                 if (isset($this->unaryOperators[$token->getValue()])) {
  264.                     $class = $this->unaryOperators[$token->getValue()]['class'];
  265.                     if (!\in_array($class, [NegUnary::class, PosUnary::class])) {
  266.                         throw new SyntaxError(\sprintf('Unexpected unary operator "%s".', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  267.                     }
  269.                     $this->parser->getStream()->next();
  270.                     $expr = $this->parsePrimaryExpression();
  272.                     $node = new $class($expr, $token->getLine());
  273.                     break;
  274.                 }
  276.                 // no break
  277.             default:
  278.                 if ($token->test(Token::PUNCTUATION_TYPE, '[')) {
  279.                     $node = $this->parseSequenceExpression();
  280.                 } elseif ($token->test(Token::PUNCTUATION_TYPE, '{')) {
  281.                     $node = $this->parseMappingExpression();
  282.                 } elseif ($token->test(Token::OPERATOR_TYPE, '=') && ('==' === $this->parser->getStream()->look(-1)->getValue() || '!=' === $this->parser->getStream()->look(-1)->getValue())) {
  283.                     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());
  284.                 } else {
  285.                     throw new SyntaxError(\sprintf('Unexpected token "%s" of value "%s".', Token::typeToEnglish($token->getType()), $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  286.                 }
  287.         }
  289.         return $this->parsePostfixExpression($node);
  290.     }
  292.     public function parseStringExpression()
  293.     {
  294.         $stream = $this->parser->getStream();
  296.         $nodes = [];
  297.         // a string cannot be followed by another string in a single expression
  298.         $nextCanBeString = true;
  299.         while (true) {
  300.             if ($nextCanBeString && $token = $stream->nextIf(Token::STRING_TYPE)) {
  301.                 $nodes[] = new ConstantExpression($token->getValue(), $token->getLine());
  302.                 $nextCanBeString = false;
  303.             } elseif ($stream->nextIf(Token::INTERPOLATION_START_TYPE)) {
  304.                 $nodes[] = $this->parseExpression();
  305.                 $stream->expect(Token::INTERPOLATION_END_TYPE);
  306.                 $nextCanBeString = true;
  307.             } else {
  308.                 break;
  309.             }
  310.         }
  312.         $expr = array_shift($nodes);
  313.         foreach ($nodes as $node) {
  314.             $expr = new ConcatBinary($expr, $node, $node->getTemplateLine());
  315.         }
  317.         return $expr;
  318.     }
  320.     /**
  321.      * @deprecated since 3.11, use parseSequenceExpression() instead
  322.      */
  323.     public function parseArrayExpression()
  324.     {
  325.         trigger_deprecation('twig/twig', '3.11', 'Calling "%s()" is deprecated, use "parseSequenceExpression()" instead.', __METHOD__);
  327.         return $this->parseSequenceExpression();
  328.     }
  330.     public function parseSequenceExpression()
  331.     {
  332.         $stream = $this->parser->getStream();
  333.         $stream->expect(Token::PUNCTUATION_TYPE, '[', 'A sequence element was expected');
  335.         $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  336.         $first = true;
  337.         while (!$stream->test(Token::PUNCTUATION_TYPE, ']')) {
  338.             if (!$first) {
  339.                 $stream->expect(Token::PUNCTUATION_TYPE, ',', 'A sequence element must be followed by a comma');
  341.                 // trailing ,?
  342.                 if ($stream->test(Token::PUNCTUATION_TYPE, ']')) {
  343.                     break;
  344.                 }
  345.             }
  346.             $first = false;
  348.             if ($stream->test(Token::SPREAD_TYPE)) {
  349.                 $stream->next();
  350.                 $expr = $this->parseExpression();
  351.                 $expr->setAttribute('spread', true);
  352.                 $node->addElement($expr);
  353.             } else {
  354.                 $node->addElement($this->parseExpression());
  355.             }
  356.         }
  357.         $stream->expect(Token::PUNCTUATION_TYPE, ']', 'An opened sequence is not properly closed');
  359.         return $node;
  360.     }
  362.     /**
  363.      * @deprecated since 3.11, use parseMappingExpression() instead
  364.      */
  365.     public function parseHashExpression()
  366.     {
  367.         trigger_deprecation('twig/twig', '3.11', 'Calling "%s()" is deprecated, use "parseMappingExpression()" instead.', __METHOD__);
  369.         return $this->parseMappingExpression();
  370.     }
  372.     public function parseMappingExpression()
  373.     {
  374.         $stream = $this->parser->getStream();
  375.         $stream->expect(Token::PUNCTUATION_TYPE, '{', 'A mapping element was expected');
  377.         $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  378.         $first = true;
  379.         while (!$stream->test(Token::PUNCTUATION_TYPE, '}')) {
  380.             if (!$first) {
  381.                 $stream->expect(Token::PUNCTUATION_TYPE, ',', 'A mapping value must be followed by a comma');
  383.                 // trailing ,?
  384.                 if ($stream->test(Token::PUNCTUATION_TYPE, '}')) {
  385.                     break;
  386.                 }
  387.             }
  388.             $first = false;
  390.             if ($stream->test(Token::SPREAD_TYPE)) {
  391.                 $stream->next();
  392.                 $value = $this->parseExpression();
  393.                 $value->setAttribute('spread', true);
  394.                 $node->addElement($value);
  395.                 continue;
  396.             }
  398.             // a mapping key can be:
  399.             //
  400.             //  * a number -- 12
  401.             //  * a string -- 'a'
  402.             //  * a name, which is equivalent to a string -- a
  403.             //  * an expression, which must be enclosed in parentheses -- (1 + 2)
  404.             if ($token = $stream->nextIf(Token::NAME_TYPE)) {
  405.                 $key = new ConstantExpression($token->getValue(), $token->getLine());
  407.                 // {a} is a shortcut for {a:a}
  408.                 if ($stream->test(Token::PUNCTUATION_TYPE, [',', '}'])) {
  409.                     $value = new NameExpression($key->getAttribute('value'), $key->getTemplateLine());
  410.                     $node->addElement($value, $key);
  411.                     continue;
  412.                 }
  413.             } elseif (($token = $stream->nextIf(Token::STRING_TYPE)) || $token = $stream->nextIf(Token::NUMBER_TYPE)) {
  414.                 $key = new ConstantExpression($token->getValue(), $token->getLine());
  415.             } elseif ($stream->test(Token::PUNCTUATION_TYPE, '(')) {
  416.                 $key = $this->parseExpression();
  417.             } else {
  418.                 $current = $stream->getCurrent();
  420.                 throw new SyntaxError(\sprintf('A mapping 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());
  421.             }
  423.             $stream->expect(Token::PUNCTUATION_TYPE, ':', 'A mapping key must be followed by a colon (:)');
  424.             $value = $this->parseExpression();
  426.             $node->addElement($value, $key);
  427.         }
  428.         $stream->expect(Token::PUNCTUATION_TYPE, '}', 'An opened mapping is not properly closed');
  430.         return $node;
  431.     }
  433.     public function parsePostfixExpression($node)
  434.     {
  435.         while (true) {
  436.             $token = $this->parser->getCurrentToken();
  437.             if (Token::PUNCTUATION_TYPE == $token->getType()) {
  438.                 if ('.' == $token->getValue() || '[' == $token->getValue()) {
  439.                     $node = $this->parseSubscriptExpression($node);
  440.                 } elseif ('|' == $token->getValue()) {
  441.                     $node = $this->parseFilterExpression($node);
  442.                 } else {
  443.                     break;
  444.                 }
  445.             } else {
  446.                 break;
  447.             }
  448.         }
  450.         return $node;
  451.     }
  453.     public function getFunctionNode($name, $line)
  454.     {
  455.         if (null !== $alias = $this->parser->getImportedSymbol('function', $name)) {
  456.             $arguments = new ArrayExpression([], $line);
  457.             foreach ($this->parseArguments() as $n) {
  458.                 $arguments->addElement($n);
  459.             }
  461.             $node = new MethodCallExpression($alias['node'], $alias['name'], $arguments, $line);
  462.             $node->setAttribute('safe', true);
  464.             return $node;
  465.         }
  467.         $args = $this->parseArguments(true);
  468.         $function = $this->getFunction($name, $line);
  470.         if ($function->getParserCallable()) {
  471.             $fakeNode = new Node(lineno: $line);
  472.             $fakeNode->setSourceContext($this->parser->getStream()->getSourceContext());
  474.             return ($function->getParserCallable())($this->parser, $fakeNode, $args, $line);
  475.         }
  477.         if (!isset($this->readyNodes[$class = $function->getNodeClass()])) {
  478.             $this->readyNodes[$class] = (bool) (new \ReflectionClass($class))->getConstructor()->getAttributes(FirstClassTwigCallableReady::class);
  479.         }
  481.         if (!$ready = $this->readyNodes[$class]) {
  482.             trigger_deprecation('twig/twig', '3.12', 'Twig node "%s" is not marked as ready for passing a "TwigFunction" in the constructor instead of its name; please update your code and then add #[FirstClassTwigCallableReady] attribute to the constructor.', $class);
  483.         }
  485.         return new $class($ready ? $function : $function->getName(), $args, $line);
  486.     }
  488.     public function parseSubscriptExpression($node)
  489.     {
  490.         $stream = $this->parser->getStream();
  491.         $token = $stream->next();
  492.         $lineno = $token->getLine();
  493.         $arguments = new ArrayExpression([], $lineno);
  494.         $type = Template::ANY_CALL;
  495.         if ('.' == $token->getValue()) {
  496.             $token = $stream->next();
  497.             if (
  498.                 Token::NAME_TYPE == $token->getType()
  499.                 ||
  500.                 Token::NUMBER_TYPE == $token->getType()
  501.                 ||
  502.                 (Token::OPERATOR_TYPE == $token->getType() && preg_match(Lexer::REGEX_NAME, $token->getValue()))
  503.             ) {
  504.                 $arg = new ConstantExpression($token->getValue(), $lineno);
  506.                 if ($stream->test(Token::PUNCTUATION_TYPE, '(')) {
  507.                     $type = Template::METHOD_CALL;
  508.                     foreach ($this->parseArguments() as $n) {
  509.                         $arguments->addElement($n);
  510.                     }
  511.                 }
  512.             } else {
  513.                 throw new SyntaxError(\sprintf('Expected name or number, got value "%s" of type %s.', $token->getValue(), Token::typeToEnglish($token->getType())), $lineno, $stream->getSourceContext());
  514.             }
  516.             if ($node instanceof NameExpression && null !== $this->parser->getImportedSymbol('template', $node->getAttribute('name'))) {
  517.                 $name = $arg->getAttribute('value');
  519.                 $node = new MethodCallExpression($node, 'macro_'.$name, $arguments, $lineno);
  520.                 $node->setAttribute('safe', true);
  522.                 return $node;
  523.             }
  524.         } else {
  525.             $type = Template::ARRAY_CALL;
  527.             // slice?
  528.             $slice = false;
  529.             if ($stream->test(Token::PUNCTUATION_TYPE, ':')) {
  530.                 $slice = true;
  531.                 $arg = new ConstantExpression(0, $token->getLine());
  532.             } else {
  533.                 $arg = $this->parseExpression();
  534.             }
  536.             if ($stream->nextIf(Token::PUNCTUATION_TYPE, ':')) {
  537.                 $slice = true;
  538.             }
  540.             if ($slice) {
  541.                 if ($stream->test(Token::PUNCTUATION_TYPE, ']')) {
  542.                     $length = new ConstantExpression(null, $token->getLine());
  543.                 } else {
  544.                     $length = $this->parseExpression();
  545.                 }
  547.                 $filter = $this->getFilter('slice', $token->getLine());
  548.                 $arguments = new Node([$arg, $length]);
  549.                 $filter = new ($filter->getNodeClass())($node, $filter, $arguments, $token->getLine());
  551.                 $stream->expect(Token::PUNCTUATION_TYPE, ']');
  553.                 return $filter;
  554.             }
  556.             $stream->expect(Token::PUNCTUATION_TYPE, ']');
  557.         }
  559.         return new GetAttrExpression($node, $arg, $arguments, $type, $lineno);
  560.     }
  562.     public function parseFilterExpression($node)
  563.     {
  564.         $this->parser->getStream()->next();
  566.         return $this->parseFilterExpressionRaw($node);
  567.     }
  569.     public function parseFilterExpressionRaw($node)
  570.     {
  571.         if (\func_num_args() > 1) {
  572.             trigger_deprecation('twig/twig', '3.12', 'Passing a second argument to "%s()" is deprecated.', __METHOD__);
  573.         }
  575.         while (true) {
  576.             $token = $this->parser->getStream()->expect(Token::NAME_TYPE);
  578.             if (!$this->parser->getStream()->test(Token::PUNCTUATION_TYPE, '(')) {
  579.                 $arguments = new Node();
  580.             } else {
  581.                 $arguments = $this->parseArguments(true, false, true);
  582.             }
  584.             $filter = $this->getFilter($token->getValue(), $token->getLine());
  586.             $ready = true;
  587.             if (!isset($this->readyNodes[$class = $filter->getNodeClass()])) {
  588.                 $this->readyNodes[$class] = (bool) (new \ReflectionClass($class))->getConstructor()->getAttributes(FirstClassTwigCallableReady::class);
  589.             }
  591.             if (!$ready = $this->readyNodes[$class]) {
  592.                 trigger_deprecation('twig/twig', '3.12', 'Twig node "%s" is not marked as ready for passing a "TwigFilter" in the constructor instead of its name; please update your code and then add #[FirstClassTwigCallableReady] attribute to the constructor.', $class);
  593.             }
  595.             $node = new $class($node, $ready ? $filter : new ConstantExpression($filter->getName(), $token->getLine()), $arguments, $token->getLine());
  597.             if (!$this->parser->getStream()->test(Token::PUNCTUATION_TYPE, '|')) {
  598.                 break;
  599.             }
  601.             $this->parser->getStream()->next();
  602.         }
  604.         return $node;
  605.     }
  607.     /**
  608.      * Parses arguments.
  609.      *
  610.      * @param bool $namedArguments Whether to allow named arguments or not
  611.      * @param bool $definition     Whether we are parsing arguments for a function (or macro) definition
  612.      *
  613.      * @return Node
  614.      *
  615.      * @throws SyntaxError
  616.      */
  617.     public function parseArguments($namedArguments = false, $definition = false, $allowArrow = false)
  618.     {
  619.         $args = [];
  620.         $stream = $this->parser->getStream();
  622.         $stream->expect(Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
  623.         while (!$stream->test(Token::PUNCTUATION_TYPE, ')')) {
  624.             if (!empty($args)) {
  625.                 $stream->expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
  627.                 // if the comma above was a trailing comma, early exit the argument parse loop
  628.                 if ($stream->test(Token::PUNCTUATION_TYPE, ')')) {
  629.                     break;
  630.                 }
  631.             }
  633.             if ($definition) {
  634.                 $token = $stream->expect(Token::NAME_TYPE, null, 'An argument must be a name');
  635.                 $value = new NameExpression($token->getValue(), $this->parser->getCurrentToken()->getLine());
  636.             } else {
  637.                 $value = $this->parseExpression(0, $allowArrow);
  638.             }
  640.             $name = null;
  641.             if ($namedArguments && (($token = $stream->nextIf(Token::OPERATOR_TYPE, '=')) || ($token = $stream->nextIf(Token::PUNCTUATION_TYPE, ':')))) {
  642.                 if (!$value instanceof NameExpression) {
  643.                     throw new SyntaxError(\sprintf('A parameter name must be a string, "%s" given.', \get_class($value)), $token->getLine(), $stream->getSourceContext());
  644.                 }
  645.                 $name = $value->getAttribute('name');
  647.                 if ($definition) {
  648.                     $value = $this->parsePrimaryExpression();
  650.                     if (!$this->checkConstantExpression($value)) {
  651.                         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());
  652.                     }
  653.                 } else {
  654.                     $value = $this->parseExpression(0, $allowArrow);
  655.                 }
  656.             }
  658.             if ($definition) {
  659.                 if (null === $name) {
  660.                     $name = $value->getAttribute('name');
  661.                     $value = new ConstantExpression(null, $this->parser->getCurrentToken()->getLine());
  662.                     $value->setAttribute('is_implicit', true);
  663.                 }
  664.                 $args[$name] = $value;
  665.             } else {
  666.                 if (null === $name) {
  667.                     $args[] = $value;
  668.                 } else {
  669.                     $args[$name] = $value;
  670.                 }
  671.             }
  672.         }
  673.         $stream->expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
  675.         return new Node($args);
  676.     }
  678.     public function parseAssignmentExpression()
  679.     {
  680.         $stream = $this->parser->getStream();
  681.         $targets = [];
  682.         while (true) {
  683.             $token = $this->parser->getCurrentToken();
  684.             if ($stream->test(Token::OPERATOR_TYPE) && preg_match(Lexer::REGEX_NAME, $token->getValue())) {
  685.                 // in this context, string operators are variable names
  686.                 $this->parser->getStream()->next();
  687.             } else {
  688.                 $stream->expect(Token::NAME_TYPE, null, 'Only variables can be assigned to');
  689.             }
  690.             $value = $token->getValue();
  691.             if (\in_array(strtr($value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), ['true', 'false', 'none', 'null'])) {
  692.                 throw new SyntaxError(\sprintf('You cannot assign a value to "%s".', $value), $token->getLine(), $stream->getSourceContext());
  693.             }
  694.             $targets[] = new AssignNameExpression($value, $token->getLine());
  696.             if (!$stream->nextIf(Token::PUNCTUATION_TYPE, ',')) {
  697.                 break;
  698.             }
  699.         }
  701.         return new Node($targets);
  702.     }
  704.     public function parseMultitargetExpression()
  705.     {
  706.         $targets = [];
  707.         while (true) {
  708.             $targets[] = $this->parseExpression();
  709.             if (!$this->parser->getStream()->nextIf(Token::PUNCTUATION_TYPE, ',')) {
  710.                 break;
  711.             }
  712.         }
  714.         return new Node($targets);
  715.     }
  717.     private function parseNotTestExpression(Node $node): NotUnary
  718.     {
  719.         return new NotUnary($this->parseTestExpression($node), $this->parser->getCurrentToken()->getLine());
  720.     }
  722.     private function parseTestExpression(Node $node): TestExpression
  723.     {
  724.         $stream = $this->parser->getStream();
  725.         $test = $this->getTest($node->getTemplateLine());
  727.         $arguments = null;
  728.         if ($stream->test(Token::PUNCTUATION_TYPE, '(')) {
  729.             $arguments = $this->parseArguments(true);
  730.         } elseif ($test->hasOneMandatoryArgument()) {
  731.             $arguments = new Node([0 => $this->parsePrimaryExpression()]);
  732.         }
  734.         if ('defined' === $test->getName() && $node instanceof NameExpression && null !== $alias = $this->parser->getImportedSymbol('function', $node->getAttribute('name'))) {
  735.             $node = new MethodCallExpression($alias['node'], $alias['name'], new ArrayExpression([], $node->getTemplateLine()), $node->getTemplateLine());
  736.             $node->setAttribute('safe', true);
  737.         }
  739.         $ready = $test instanceof TwigTest;
  740.         if (!isset($this->readyNodes[$class = $test->getNodeClass()])) {
  741.             $this->readyNodes[$class] = (bool) (new \ReflectionClass($class))->getConstructor()->getAttributes(FirstClassTwigCallableReady::class);
  742.         }
  744.         if (!$ready = $this->readyNodes[$class]) {
  745.             trigger_deprecation('twig/twig', '3.12', 'Twig node "%s" is not marked as ready for passing a "TwigTest" in the constructor instead of its name; please update your code and then add #[FirstClassTwigCallableReady] attribute to the constructor.', $class);
  746.         }
  748.         return new $class($node, $ready ? $test : $test->getName(), $arguments, $this->parser->getCurrentToken()->getLine());
  749.     }
  751.     private function getTest(int $line): TwigTest
  752.     {
  753.         $stream = $this->parser->getStream();
  754.         $name = $stream->expect(Token::NAME_TYPE)->getValue();
  756.         if ($stream->test(Token::NAME_TYPE)) {
  757.             // try 2-words tests
  758.             $name = $name.' '.$this->parser->getCurrentToken()->getValue();
  760.             if ($test = $this->env->getTest($name)) {
  761.                 $stream->next();
  762.             }
  763.         } else {
  764.             $test = $this->env->getTest($name);
  765.         }
  767.         if (!$test) {
  768.             $e = new SyntaxError(\sprintf('Unknown "%s" test.', $name), $line, $stream->getSourceContext());
  769.             $e->addSuggestions($name, array_keys($this->env->getTests()));
  771.             throw $e;
  772.         }
  774.         if ($test->isDeprecated()) {
  775.             $stream = $this->parser->getStream();
  776.             $message = \sprintf('Twig Test "%s" is deprecated', $test->getName());
  778.             if ($test->getAlternative()) {
  779.                 $message .= \sprintf('. Use "%s" instead', $test->getAlternative());
  780.             }
  781.             $src = $stream->getSourceContext();
  782.             $message .= \sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $stream->getCurrent()->getLine());
  784.             trigger_deprecation($test->getDeprecatingPackage(), $test->getDeprecatedVersion(), $message);
  785.         }
  787.         return $test;
  788.     }
  790.     private function getFunction(string $name, int $line): TwigFunction
  791.     {
  792.         if (!$function = $this->env->getFunction($name)) {
  793.             $e = new SyntaxError(\sprintf('Unknown "%s" function.', $name), $line, $this->parser->getStream()->getSourceContext());
  794.             $e->addSuggestions($name, array_keys($this->env->getFunctions()));
  796.             throw $e;
  797.         }
  799.         if ($function->isDeprecated()) {
  800.             $message = \sprintf('Twig Function "%s" is deprecated', $function->getName());
  801.             if ($function->getAlternative()) {
  802.                 $message .= \sprintf('. Use "%s" instead', $function->getAlternative());
  803.             }
  804.             $src = $this->parser->getStream()->getSourceContext();
  805.             $message .= \sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  807.             trigger_deprecation($function->getDeprecatingPackage(), $function->getDeprecatedVersion(), $message);
  808.         }
  810.         return $function;
  811.     }
  813.     private function getFilter(string $name, int $line): TwigFilter
  814.     {
  815.         if (!$filter = $this->env->getFilter($name)) {
  816.             $e = new SyntaxError(\sprintf('Unknown "%s" filter.', $name), $line, $this->parser->getStream()->getSourceContext());
  817.             $e->addSuggestions($name, array_keys($this->env->getFilters()));
  819.             throw $e;
  820.         }
  822.         if ($filter->isDeprecated()) {
  823.             $message = \sprintf('Twig Filter "%s" is deprecated', $filter->getName());
  824.             if ($filter->getAlternative()) {
  825.                 $message .= \sprintf('. Use "%s" instead', $filter->getAlternative());
  826.             }
  827.             $src = $this->parser->getStream()->getSourceContext();
  828.             $message .= \sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  830.             trigger_deprecation($filter->getDeprecatingPackage(), $filter->getDeprecatedVersion(), $message);
  831.         }
  833.         return $filter;
  834.     }
  836.     // checks that the node only contains "constant" elements
  837.     private function checkConstantExpression(Node $node): bool
  838.     {
  839.         if (!($node instanceof ConstantExpression || $node instanceof ArrayExpression
  840.             || $node instanceof NegUnary || $node instanceof PosUnary
  841.         )) {
  842.             return false;
  843.         }
  845.         foreach ($node as $n) {
  846.             if (!$this->checkConstantExpression($n)) {
  847.                 return false;
  848.             }
  849.         }
  851.         return true;
  852.     }
  853. }