-

Author: fabpot

src/ExpressionParser.php

@@ -57,23 +57,27 @@ class ExpressionParser
 
     private Operators $operators;
     private $readyNodes = [];
-    private array $precedenceChanges = [];
+    private \WeakMap $precedenceChanges;
     private bool $deprecationCheck = true;
 
     public function __construct(
         private Parser $parser,
         private Environment $env,
     ) {
         $this->operators = $env->getOperators();
-        foreach ($this->operators as $name => $op) {
+        $this->precedenceChanges = new \WeakMap();
+        foreach ($this->operators as $op) {
             if (!$op->getPrecedenceChange()) {
                 continue;
             }
             $min = min($op->getPrecedenceChange()->getNewPrecedence(), $op->getPrecedence());
             $max = max($op->getPrecedenceChange()->getNewPrecedence(), $op->getPrecedence());
-            foreach ($this->operators as $n => $o) {
+            foreach ($this->operators as $o) {
                 if ($o->getPrecedence() > $min && $o->getPrecedence() < $max) {
-                    $this->precedenceChanges[$n][] = $name;
+                    if (!isset($this->precedenceChanges[$o])) {
+                        $this->precedenceChanges[$o] = [];
+                    }
+                    $this->precedenceChanges[$o][] = $op;
                 }
             }
         }
@@ -111,7 +115,7 @@ public function parseExpression($precedence = 0)
                 $expr = new $class($expr, $expr1, $token->getLine());
             }
 
-            $expr->setAttribute('operator', OperatorArity::Binary->value.'_'.$token->getValue());
+            $expr->setAttribute('operator', $op);
 
             $this->triggerPrecedenceDeprecations($expr);
 
@@ -132,30 +136,29 @@ private function triggerPrecedenceDeprecations(AbstractExpression $expr): void
             return;
         }
 
-        if (str_starts_with($unaryOp = $expr->getAttribute('operator'), 'unary')) {
+        if (OperatorArity::Unary === $expr->getAttribute('operator')->getArity()) {
             if ($expr->hasExplicitParentheses()) {
                 return;
             }
-            $target = explode('_', $unaryOp)[1];
+            $operator = $expr->getAttribute('operator');
             /** @var AbstractExpression $node */
             $node = $expr->getNode('node');
-            foreach ($this->precedenceChanges as $operatorName => $changes) {
-                if (!\in_array($unaryOp, $changes)) {
+            foreach ($this->precedenceChanges as $op => $changes) {
+                if (!\in_array($operator, $changes, true)) {
                     continue;
                 }
-                if ($node->hasAttribute('operator') && $operatorName === $node->getAttribute('operator')) {
-                    $change = $this->operators->getUnary($target)->getPrecedenceChange();
-                    trigger_deprecation($change->getPackage(), $change->getVersion(), \sprintf('Add explicit parentheses around the "%s" unary operator to avoid behavior change in the next major version as its precedence will change in "%s" at line %d.', $target, $this->parser->getStream()->getSourceContext()->getName(), $node->getTemplateLine()));
+                if ($node->hasAttribute('operator') && $op === $node->getAttribute('operator')) {
+                    $change = $operator->getPrecedenceChange();
+                    trigger_deprecation($change->getPackage(), $change->getVersion(), \sprintf('Add explicit parentheses around the "%s" unary operator to avoid behavior change in the next major version as its precedence will change in "%s" at line %d.', $operator->getOperator(), $this->parser->getStream()->getSourceContext()->getName(), $node->getTemplateLine()));
                 }
             }
         } else {
-            foreach ($this->precedenceChanges[$expr->getAttribute('operator')] as $operatorName) {
+            foreach ($this->precedenceChanges[$expr->getAttribute('operator')] as $operator) {
                 foreach ($expr as $node) {
                     /** @var AbstractExpression $node */
-                    if ($node->hasAttribute('operator') && $operatorName === $node->getAttribute('operator') && !$node->hasExplicitParentheses()) {
-                        $op = explode('_', $operatorName)[1];
-                        $change = $this->operators->getBinary($op)->getPrecedenceChange();
-                        trigger_deprecation($change->getPackage(), $change->getVersion(), \sprintf('Add explicit parentheses around the "%s" binary operator to avoid behavior change in the next major version as its precedence will change in "%s" at line %d.', $op, $this->parser->getStream()->getSourceContext()->getName(), $node->getTemplateLine()));
+                    if ($node->hasAttribute('operator') && $operator === $node->getAttribute('operator') && !$node->hasExplicitParentheses()) {
+                        $change = $operator->getPrecedenceChange();
+                        trigger_deprecation($change->getPackage(), $change->getVersion(), \sprintf('Add explicit parentheses around the "%s" binary operator to avoid behavior change in the next major version as its precedence will change in "%s" at line %d.', $operator->getOperator(), $this->parser->getStream()->getSourceContext()->getName(), $node->getTemplateLine()));
                     }
                 }
             }
@@ -230,7 +233,7 @@ private function getPrimary(): AbstractExpression
             $class = $operator->getNodeClass();
 
             $expr = new $class($expr, $token->getLine());
-            $expr->setAttribute('operator', OperatorArity::Unary->value.'_'.$token->getValue());
+            $expr->setAttribute('operator', $operator);
 
             if ($this->deprecationCheck) {
                 $this->triggerPrecedenceDeprecations($expr);

src/Operator/AbstractOperator.php

@@ -24,4 +24,9 @@ public function getAliases(): array
     {
         return [];
     }
+
+    public function getId(): string
+    {
+        return 'arity_'.$this->getArity()->value.'_operator_'.$this->getOperator();
+    }
 }

src/Operator/OperatorArity.php

@@ -11,9 +11,9 @@
 
 namespace Twig\Operator;
 
-enum OperatorArity: string
+enum OperatorArity: int
 {
-    case Unary = 'unary';
-    case Binary = 'binary';
-    case Ternary = 'ternary';
+    case Unary = 1;
+    case Binary = 2;
+    case Ternary = 3;
 }

src/Operator/OperatorInterface.php

@@ -26,4 +26,9 @@ public function getPrecedence(): int;
     public function getPrecedenceChange(): ?OperatorPrecedenceChange;
 
     public function getAliases(): array;
+
+    /**
+     * @return string A unique identifier for the operator.
+     */
+    public function getId(): string;
 }

src/Operator/Operators.php

@@ -12,12 +12,13 @@
 namespace Twig\Operator;
 
 use Twig\Operator\Binary\AbstractBinaryOperator;
+use Twig\Operator\Ternary\AbstractTernaryOperator;
 use Twig\Operator\Unary\AbstractUnaryOperator;
 
 class Operators implements \IteratorAggregate
 {
-    /** @var array<AbstractOperator> */
     private array $operators = [];
+    private array $aliases = [];
 
     public function __construct(
         array $operators = [],
@@ -33,9 +34,9 @@ public function __construct(
     public function add(array $operators): self
     {
         foreach ($operators as $operator) {
-            $this->operators[$operator->getArity()->value.'_'.$operator->getOperator()] = $operator;
+            $this->operators[$operator->getArity()->value][$operator->getOperator()] = $operator;
             foreach ($operator->getAliases() as $alias) {
-                $this->operators[$operator->getArity()->value.'_'.$alias] = $operator;
+                $this->aliases[$operator->getArity()->value][$alias] = $operator;
             }
         }
 
@@ -44,16 +45,19 @@ public function add(array $operators): self
 
     public function getUnary(string $name): ?AbstractUnaryOperator
     {
-        return $this->operators[OperatorArity::Unary->value.'_'.$name] ?? null;
+        return $this->operators[OperatorArity::Unary->value][$name] ?? ($this->aliases[OperatorArity::Unary->value][$name] ?? null);
     }
 
     public function getBinary(string $name): ?AbstractBinaryOperator
     {
-        return $this->operators[OperatorArity::Binary->value.'_'.$name] ?? null;
+        return $this->operators[OperatorArity::Binary->value][$name] ?? ($this->aliases[OperatorArity::Binary->value][$name] ?? null);
     }
 
     public function getIterator(): \Traversable
     {
-        return new \ArrayIterator($this->operators);
+        foreach ($this->operators as $operators) {
+            // we don't yield the keys
+            yield from $operators;
+        }
     }
 }