: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
* This file is part of Twig.
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
namespace WPML\Core\Twig;
use WPML\Core\Twig\Error\SyntaxError;
use WPML\Core\Twig\Node\Expression\ArrayExpression;
use WPML\Core\Twig\Node\Expression\ArrowFunctionExpression;
use WPML\Core\Twig\Node\Expression\AssignNameExpression;
use WPML\Core\Twig\Node\Expression\Binary\ConcatBinary;
use WPML\Core\Twig\Node\Expression\BlockReferenceExpression;
use WPML\Core\Twig\Node\Expression\ConditionalExpression;
use WPML\Core\Twig\Node\Expression\ConstantExpression;
use WPML\Core\Twig\Node\Expression\GetAttrExpression;
use WPML\Core\Twig\Node\Expression\MethodCallExpression;
use WPML\Core\Twig\Node\Expression\NameExpression;
use WPML\Core\Twig\Node\Expression\ParentExpression;
use WPML\Core\Twig\Node\Expression\Unary\NegUnary;
use WPML\Core\Twig\Node\Expression\Unary\NotUnary;
use WPML\Core\Twig\Node\Expression\Unary\PosUnary;
use WPML\Core\Twig\Node\Node;
* This parser implements a "Precedence climbing" algorithm.
* @see https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
* @see https://en.wikipedia.org/wiki/Operator-precedence_parser
* @author Fabien Potencier <fabien@symfony.com>
const OPERATOR_RIGHT = 2;
protected $unaryOperators;
protected $binaryOperators;
public function __construct(\WPML\Core\Twig\Parser $parser, $env = null)
if ($env instanceof \WPML\Core\Twig\Environment) {
$this->unaryOperators = $env->getUnaryOperators();
$this->binaryOperators = $env->getBinaryOperators();
@\trigger_error('Passing the operators as constructor arguments to ' . __METHOD__ . ' is deprecated since version 1.27. Pass the environment instead.', \E_USER_DEPRECATED);
$this->env = $parser->getEnvironment();
$this->unaryOperators = \func_get_arg(1);
$this->binaryOperators = \func_get_arg(2);
public function parseExpression($precedence = 0, $allowArrow = \false)
if ($allowArrow && ($arrow = $this->parseArrow())) {
$expr = $this->getPrimary();
$token = $this->parser->getCurrentToken();
while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
$op = $this->binaryOperators[$token->getValue()];
$this->parser->getStream()->next();
if ('is not' === $token->getValue()) {
$expr = $this->parseNotTestExpression($expr);
} elseif ('is' === $token->getValue()) {
$expr = $this->parseTestExpression($expr);
} elseif (isset($op['callable'])) {
$expr = \call_user_func($op['callable'], $this->parser, $expr);
$expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
$expr = new $class($expr, $expr1, $token->getLine());
$token = $this->parser->getCurrentToken();
return $this->parseConditionalExpression($expr);
* @return ArrowFunctionExpression|null
private function parseArrow()
$stream = $this->parser->getStream();
// short array syntax (one argument, no parentheses)?
if ($stream->look(1)->test(\WPML\Core\Twig\Token::ARROW_TYPE)) {
$line = $stream->getCurrent()->getLine();
$token = $stream->expect(\WPML\Core\Twig\Token::NAME_TYPE);
$names = [new \WPML\Core\Twig\Node\Expression\AssignNameExpression($token->getValue(), $token->getLine())];
$stream->expect(\WPML\Core\Twig\Token::ARROW_TYPE);
return new \WPML\Core\Twig\Node\Expression\ArrowFunctionExpression($this->parseExpression(0), new \WPML\Core\Twig\Node\Node($names), $line);
// first, determine if we are parsing an arrow function by finding => (long form)
if (!$stream->look($i)->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(')) {
if (!$stream->look($i)->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ',')) {
if (!$stream->look($i)->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ')')) {
if (!$stream->look($i)->test(\WPML\Core\Twig\Token::ARROW_TYPE)) {
// yes, let's parse it properly
$token = $stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(');
$line = $token->getLine();
$token = $stream->expect(\WPML\Core\Twig\Token::NAME_TYPE);
$names[] = new \WPML\Core\Twig\Node\Expression\AssignNameExpression($token->getValue(), $token->getLine());
if (!$stream->nextIf(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ',')) {
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ')');
$stream->expect(\WPML\Core\Twig\Token::ARROW_TYPE);
return new \WPML\Core\Twig\Node\Expression\ArrowFunctionExpression($this->parseExpression(0), new \WPML\Core\Twig\Node\Node($names), $line);
protected function getPrimary()
$token = $this->parser->getCurrentToken();
if ($this->isUnary($token)) {
$operator = $this->unaryOperators[$token->getValue()];
$this->parser->getStream()->next();
$expr = $this->parseExpression($operator['precedence']);
$class = $operator['class'];
return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
} elseif ($token->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(')) {
$this->parser->getStream()->next();
$expr = $this->parseExpression();
$this->parser->getStream()->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
return $this->parsePostfixExpression($expr);
return $this->parsePrimaryExpression();
protected function parseConditionalExpression($expr)
while ($this->parser->getStream()->nextIf(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '?')) {
if (!$this->parser->getStream()->nextIf(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ':')) {
$expr2 = $this->parseExpression();
if ($this->parser->getStream()->nextIf(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ':')) {
$expr3 = $this->parseExpression();
$expr3 = new \WPML\Core\Twig\Node\Expression\ConstantExpression('', $this->parser->getCurrentToken()->getLine());
$expr3 = $this->parseExpression();
$expr = new \WPML\Core\Twig\Node\Expression\ConditionalExpression($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
protected function isUnary(\WPML\Core\Twig\Token $token)
return $token->test(\WPML\Core\Twig\Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->getValue()]);
protected function isBinary(\WPML\Core\Twig\Token $token)
return $token->test(\WPML\Core\Twig\Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->getValue()]);
public function parsePrimaryExpression()
$token = $this->parser->getCurrentToken();
switch ($token->getType()) {
case \WPML\Core\Twig\Token::NAME_TYPE:
$this->parser->getStream()->next();
switch ($token->getValue()) {
$node = new \WPML\Core\Twig\Node\Expression\ConstantExpression(\true, $token->getLine());
$node = new \WPML\Core\Twig\Node\Expression\ConstantExpression(\false, $token->getLine());
$node = new \WPML\Core\Twig\Node\Expression\ConstantExpression(null, $token->getLine());
if ('(' === $this->parser->getCurrentToken()->getValue()) {
$node = $this->getFunctionNode($token->getValue(), $token->getLine());
$node = new \WPML\Core\Twig\Node\Expression\NameExpression($token->getValue(), $token->getLine());
case \WPML\Core\Twig\Token::NUMBER_TYPE:
$this->parser->getStream()->next();
$node = new \WPML\Core\Twig\Node\Expression\ConstantExpression($token->getValue(), $token->getLine());
case \WPML\Core\Twig\Token::STRING_TYPE:
case \WPML\Core\Twig\Token::INTERPOLATION_START_TYPE:
$node = $this->parseStringExpression();
case \WPML\Core\Twig\Token::OPERATOR_TYPE:
if (\preg_match(\WPML\Core\Twig\Lexer::REGEX_NAME, $token->getValue(), $matches) && $matches[0] == $token->getValue()) {
// in this context, string operators are variable names
$this->parser->getStream()->next();
$node = new \WPML\Core\Twig\Node\Expression\NameExpression($token->getValue(), $token->getLine());
} elseif (isset($this->unaryOperators[$token->getValue()])) {
$class = $this->unaryOperators[$token->getValue()]['class'];
$ref = new \ReflectionClass($class);
$negClass = 'WPML\\Core\\Twig\\Node\\Expression\\Unary\\NegUnary';
$posClass = 'WPML\\Core\\Twig\\Node\\Expression\\Unary\\PosUnary';
if (!(\in_array($ref->getName(), [$negClass, $posClass, 'Twig_Node_Expression_Unary_Neg', 'Twig_Node_Expression_Unary_Pos']) || $ref->isSubclassOf($negClass) || $ref->isSubclassOf($posClass) || $ref->isSubclassOf('Twig_Node_Expression_Unary_Neg') || $ref->isSubclassOf('Twig_Node_Expression_Unary_Pos'))) {
throw new \WPML\Core\Twig\Error\SyntaxError(\sprintf('Unexpected unary operator "%s".', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
$this->parser->getStream()->next();
$expr = $this->parsePrimaryExpression();
$node = new $class($expr, $token->getLine());
if ($token->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '[')) {
$node = $this->parseArrayExpression();
} elseif ($token->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '{')) {
$node = $this->parseHashExpression();
} elseif ($token->test(\WPML\Core\Twig\Token::OPERATOR_TYPE, '=') && ('==' === $this->parser->getStream()->look(-1)->getValue() || '!=' === $this->parser->getStream()->look(-1)->getValue())) {
throw new \WPML\Core\Twig\Error\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());
throw new \WPML\Core\Twig\Error\SyntaxError(\sprintf('Unexpected token "%s" of value "%s".', \WPML\Core\Twig\Token::typeToEnglish($token->getType()), $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
return $this->parsePostfixExpression($node);
public function parseStringExpression()
$stream = $this->parser->getStream();
// a string cannot be followed by another string in a single expression
$nextCanBeString = \true;
if ($nextCanBeString && ($token = $stream->nextIf(\WPML\Core\Twig\Token::STRING_TYPE))) {
$nodes[] = new \WPML\Core\Twig\Node\Expression\ConstantExpression($token->getValue(), $token->getLine());
$nextCanBeString = \false;
} elseif ($stream->nextIf(\WPML\Core\Twig\Token::INTERPOLATION_START_TYPE)) {
$nodes[] = $this->parseExpression();
$stream->expect(\WPML\Core\Twig\Token::INTERPOLATION_END_TYPE);
$nextCanBeString = \true;
$expr = \array_shift($nodes);
foreach ($nodes as $node) {
$expr = new \WPML\Core\Twig\Node\Expression\Binary\ConcatBinary($expr, $node, $node->getTemplateLine());
public function parseArrayExpression()
$stream = $this->parser->getStream();
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
$node = new \WPML\Core\Twig\Node\Expression\ArrayExpression([], $stream->getCurrent()->getLine());
while (!$stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']')) {
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
if ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']')) {
$node->addElement($this->parseExpression());
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
public function parseHashExpression()
$stream = $this->parser->getStream();
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '{', 'A hash element was expected');
$node = new \WPML\Core\Twig\Node\Expression\ArrayExpression([], $stream->getCurrent()->getLine());
while (!$stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '}')) {
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ',', 'A hash value must be followed by a comma');
if ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '}')) {
// * a name, which is equivalent to a string -- a
// * an expression, which must be enclosed in parentheses -- (1 + 2)
if (($token = $stream->nextIf(\WPML\Core\Twig\Token::STRING_TYPE)) || ($token = $stream->nextIf(\WPML\Core\Twig\Token::NAME_TYPE)) || ($token = $stream->nextIf(\WPML\Core\Twig\Token::NUMBER_TYPE))) {
$key = new \WPML\Core\Twig\Node\Expression\ConstantExpression($token->getValue(), $token->getLine());
} elseif ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(')) {
$key = $this->parseExpression();
$current = $stream->getCurrent();
throw new \WPML\Core\Twig\Error\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".', \WPML\Core\Twig\Token::typeToEnglish($current->getType()), $current->getValue()), $current->getLine(), $stream->getSourceContext());
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ':', 'A hash key must be followed by a colon (:)');
$value = $this->parseExpression();
$node->addElement($value, $key);
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '}', 'An opened hash is not properly closed');
public function parsePostfixExpression($node)
$token = $this->parser->getCurrentToken();
if (\WPML\Core\Twig\Token::PUNCTUATION_TYPE == $token->getType()) {
if ('.' == $token->getValue() || '[' == $token->getValue()) {
$node = $this->parseSubscriptExpression($node);
} elseif ('|' == $token->getValue()) {
$node = $this->parseFilterExpression($node);
public function getFunctionNode($name, $line)
if (!\count($this->parser->getBlockStack())) {
throw new \WPML\Core\Twig\Error\SyntaxError('Calling "parent" outside a block is forbidden.', $line, $this->parser->getStream()->getSourceContext());
if (!$this->parser->getParent() && !$this->parser->hasTraits()) {
throw new \WPML\Core\Twig\Error\SyntaxError('Calling "parent" on a template that does not extend nor "use" another template is forbidden.', $line, $this->parser->getStream()->getSourceContext());
return new \WPML\Core\Twig\Node\Expression\ParentExpression($this->parser->peekBlockStack(), $line);
$args = $this->parseArguments();
throw new \WPML\Core\Twig\Error\SyntaxError('The "block" function takes one argument (the block name).', $line, $this->parser->getStream()->getSourceContext());
return new \WPML\Core\Twig\Node\Expression\BlockReferenceExpression($args->getNode(0), \count($args) > 1 ? $args->getNode(1) : null, $line);
$args = $this->parseArguments();
throw new \WPML\Core\Twig\Error\SyntaxError('The "attribute" function takes at least two arguments (the variable and the attributes).', $line, $this->parser->getStream()->getSourceContext());
return new \WPML\Core\Twig\Node\Expression\GetAttrExpression($args->getNode(0), $args->getNode(1), \count($args) > 2 ? $args->getNode(2) : null, \WPML\Core\Twig\Template::ANY_CALL, $line);
if (null !== ($alias = $this->parser->getImportedSymbol('function', $name))) {
$arguments = new \WPML\Core\Twig\Node\Expression\ArrayExpression([], $line);
foreach ($this->parseArguments() as $n) {
$arguments->addElement($n);
$node = new \WPML\Core\Twig\Node\Expression\MethodCallExpression($alias['node'], $alias['name'], $arguments, $line);
$node->setAttribute('safe', \true);
$args = $this->parseArguments(\true);
$class = $this->getFunctionNodeClass($name, $line);
return new $class($name, $args, $line);
public function parseSubscriptExpression($node)
$stream = $this->parser->getStream();
$token = $stream->next();
$lineno = $token->getLine();
$arguments = new \WPML\Core\Twig\Node\Expression\ArrayExpression([], $lineno);
$type = \WPML\Core\Twig\Template::ANY_CALL;
if ('.' == $token->getValue()) {
$token = $stream->next();
if (\WPML\Core\Twig\Token::NAME_TYPE == $token->getType() || \WPML\Core\Twig\Token::NUMBER_TYPE == $token->getType() || \WPML\Core\Twig\Token::OPERATOR_TYPE == $token->getType() && \preg_match(\WPML\Core\Twig\Lexer::REGEX_NAME, $token->getValue())) {
$arg = new \WPML\Core\Twig\Node\Expression\ConstantExpression($token->getValue(), $lineno);
if ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(')) {
$type = \WPML\Core\Twig\Template::METHOD_CALL;
foreach ($this->parseArguments() as $n) {
$arguments->addElement($n);
throw new \WPML\Core\Twig\Error\SyntaxError('Expected name or number.', $lineno, $stream->getSourceContext());
if ($node instanceof \WPML\Core\Twig\Node\Expression\NameExpression && null !== $this->parser->getImportedSymbol('template', $node->getAttribute('name'))) {
if (!$arg instanceof \WPML\Core\Twig\Node\Expression\ConstantExpression) {
throw new \WPML\Core\Twig\Error\SyntaxError(\sprintf('Dynamic macro names are not supported (called on "%s").', $node->getAttribute('name')), $token->getLine(), $stream->getSourceContext());
$name = $arg->getAttribute('value');
if ($this->parser->isReservedMacroName($name)) {
throw new \WPML\Core\Twig\Error\SyntaxError(\sprintf('"%s" cannot be called as macro as it is a reserved keyword.', $name), $token->getLine(), $stream->getSourceContext());
$node = new \WPML\Core\Twig\Node\Expression\MethodCallExpression($node, 'get' . $name, $arguments, $lineno);
$node->setAttribute('safe', \true);
$type = \WPML\Core\Twig\Template::ARRAY_CALL;
if ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ':')) {
$arg = new \WPML\Core\Twig\Node\Expression\ConstantExpression(0, $token->getLine());
$arg = $this->parseExpression();
if ($stream->nextIf(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ':')) {
if ($stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']')) {
$length = new \WPML\Core\Twig\Node\Expression\ConstantExpression(null, $token->getLine());
$length = $this->parseExpression();
$class = $this->getFilterNodeClass('slice', $token->getLine());
$arguments = new \WPML\Core\Twig\Node\Node([$arg, $length]);
$filter = new $class($node, new \WPML\Core\Twig\Node\Expression\ConstantExpression('slice', $token->getLine()), $arguments, $token->getLine());
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']');
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ']');
return new \WPML\Core\Twig\Node\Expression\GetAttrExpression($node, $arg, $arguments, $type, $lineno);
public function parseFilterExpression($node)
$this->parser->getStream()->next();
return $this->parseFilterExpressionRaw($node);
public function parseFilterExpressionRaw($node, $tag = null)
$token = $this->parser->getStream()->expect(\WPML\Core\Twig\Token::NAME_TYPE);
$name = new \WPML\Core\Twig\Node\Expression\ConstantExpression($token->getValue(), $token->getLine());
if (!$this->parser->getStream()->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(')) {
$arguments = new \WPML\Core\Twig\Node\Node();
$arguments = $this->parseArguments(\true, \false, \true);
$class = $this->getFilterNodeClass($name->getAttribute('value'), $token->getLine());
$node = new $class($node, $name, $arguments, $token->getLine(), $tag);
if (!$this->parser->getStream()->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '|')) {
$this->parser->getStream()->next();
* @param bool $namedArguments Whether to allow named arguments or not
* @param bool $definition Whether we are parsing arguments for a function definition
public function parseArguments($namedArguments = \false, $definition = \false, $allowArrow = \false)
$stream = $this->parser->getStream();
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
while (!$stream->test(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ')')) {
$stream->expect(\WPML\Core\Twig\Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
$token = $stream->expect(\WPML\Core\Twig\Token::NAME_TYPE, null, 'An argument must be a name');
$value = new \WPML\Core\Twig\Node\Expression\NameExpression($token->getValue(), $this->parser->getCurrentToken()->getLine());
$value = $this->parseExpression(0, $allowArrow);
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
