installation de motranslator

via Composer

vendor/symfony/expression-language/Node/ArgumentsNode.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArgumentsNode extends ArrayNode
+{
+    public function compile(Compiler $compiler): void
+    {
+        $this->compileArguments($compiler, false);
+    }
+
+    public function toArray(): array
+    {
+        $array = [];
+
+        foreach ($this->getKeyValuePairs() as $pair) {
+            $array[] = $pair['value'];
+            $array[] = ', ';
+        }
+        array_pop($array);
+
+        return $array;
+    }
+}

vendor/symfony/expression-language/Node/ArrayNode.php

@@ -0,0 +1,116 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArrayNode extends Node
+{
+    protected int $index;
+
+    public function __construct()
+    {
+        $this->index = -1;
+    }
+
+    public function addElement(Node $value, ?Node $key = null): void
+    {
+        $key ??= new ConstantNode(++$this->index);
+
+        array_push($this->nodes, $key, $value);
+    }
+
+    /**
+     * Compiles the node to PHP.
+     */
+    public function compile(Compiler $compiler): void
+    {
+        $compiler->raw('[');
+        $this->compileArguments($compiler);
+        $compiler->raw(']');
+    }
+
+    public function evaluate(array $functions, array $values): array
+    {
+        $result = [];
+        foreach ($this->getKeyValuePairs() as $pair) {
+            $result[$pair['key']->evaluate($functions, $values)] = $pair['value']->evaluate($functions, $values);
+        }
+
+        return $result;
+    }
+
+    public function toArray(): array
+    {
+        $value = [];
+        foreach ($this->getKeyValuePairs() as $pair) {
+            $value[$pair['key']->attributes['value']] = $pair['value'];
+        }
+
+        $array = [];
+
+        if ($this->isHash($value)) {
+            foreach ($value as $k => $v) {
+                $array[] = ', ';
+                $array[] = new ConstantNode($k);
+                $array[] = ': ';
+                $array[] = $v;
+            }
+            $array[0] = '{';
+            $array[] = '}';
+        } else {
+            foreach ($value as $v) {
+                $array[] = ', ';
+                $array[] = $v;
+            }
+            $array[0] = '[';
+            $array[] = ']';
+        }
+
+        return $array;
+    }
+
+    protected function getKeyValuePairs(): array
+    {
+        $pairs = [];
+        foreach (array_chunk($this->nodes, 2) as $pair) {
+            $pairs[] = ['key' => $pair[0], 'value' => $pair[1]];
+        }
+
+        return $pairs;
+    }
+
+    protected function compileArguments(Compiler $compiler, bool $withKeys = true): void
+    {
+        $first = true;
+        foreach ($this->getKeyValuePairs() as $pair) {
+            if (!$first) {
+                $compiler->raw(', ');
+            }
+            $first = false;
+
+            if ($withKeys) {
+                $compiler
+                    ->compile($pair['key'])
+                    ->raw(' => ')
+                ;
+            }
+
+            $compiler->compile($pair['value']);
+        }
+    }
+}

vendor/symfony/expression-language/Node/BinaryNode.php

@@ -0,0 +1,204 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+use Symfony\Component\ExpressionLanguage\SyntaxError;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class BinaryNode extends Node
+{
+    private const OPERATORS = [
+        '~' => '.',
+        'and' => '&&',
+        'or' => '||',
+    ];
+
+    private const FUNCTIONS = [
+        '**' => 'pow',
+        '..' => 'range',
+        'in' => '\\'.self::class.'::inArray',
+        'not in' => '!\\'.self::class.'::inArray',
+        'contains' => 'str_contains',
+        'starts with' => 'str_starts_with',
+        'ends with' => 'str_ends_with',
+    ];
+
+    public function __construct(string $operator, Node $left, Node $right)
+    {
+        parent::__construct(
+            ['left' => $left, 'right' => $right],
+            ['operator' => $operator]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $operator = $this->attributes['operator'];
+
+        if ('matches' == $operator) {
+            if ($this->nodes['right'] instanceof ConstantNode) {
+                $this->evaluateMatches($this->nodes['right']->evaluate([], []), '');
+            }
+
+            $compiler
+                ->raw('(static function ($regexp, $str) { set_error_handler(static fn ($t, $m) => throw new \Symfony\Component\ExpressionLanguage\SyntaxError(sprintf(\'Regexp "%s" passed to "matches" is not valid\', $regexp).substr($m, 12))); try { return preg_match($regexp, (string) $str); } finally { restore_error_handler(); } })(')
+                ->compile($this->nodes['right'])
+                ->raw(', ')
+                ->compile($this->nodes['left'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::FUNCTIONS[$operator])) {
+            $compiler
+                ->raw(sprintf('%s(', self::FUNCTIONS[$operator]))
+                ->compile($this->nodes['left'])
+                ->raw(', ')
+                ->compile($this->nodes['right'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::OPERATORS[$operator])) {
+            $operator = self::OPERATORS[$operator];
+        }
+
+        $compiler
+            ->raw('(')
+            ->compile($this->nodes['left'])
+            ->raw(' ')
+            ->raw($operator)
+            ->raw(' ')
+            ->compile($this->nodes['right'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        $operator = $this->attributes['operator'];
+        $left = $this->nodes['left']->evaluate($functions, $values);
+
+        if (isset(self::FUNCTIONS[$operator])) {
+            $right = $this->nodes['right']->evaluate($functions, $values);
+
+            if ('not in' === $operator) {
+                return !self::inArray($left, $right);
+            }
+            $f = self::FUNCTIONS[$operator];
+
+            return $f($left, $right);
+        }
+
+        switch ($operator) {
+            case 'or':
+            case '||':
+                return $left || $this->nodes['right']->evaluate($functions, $values);
+            case 'and':
+            case '&&':
+                return $left && $this->nodes['right']->evaluate($functions, $values);
+        }
+
+        $right = $this->nodes['right']->evaluate($functions, $values);
+
+        switch ($operator) {
+            case '|':
+                return $left | $right;
+            case '^':
+                return $left ^ $right;
+            case '&':
+                return $left & $right;
+            case '==':
+                return $left == $right;
+            case '===':
+                return $left === $right;
+            case '!=':
+                return $left != $right;
+            case '!==':
+                return $left !== $right;
+            case '<':
+                return $left < $right;
+            case '>':
+                return $left > $right;
+            case '>=':
+                return $left >= $right;
+            case '<=':
+                return $left <= $right;
+            case 'not in':
+                return !self::inArray($left, $right);
+            case 'in':
+                return self::inArray($left, $right);
+            case '+':
+                return $left + $right;
+            case '-':
+                return $left - $right;
+            case '~':
+                return $left.$right;
+            case '*':
+                return $left * $right;
+            case '/':
+                if (0 == $right) {
+                    throw new \DivisionByZeroError('Division by zero.');
+                }
+
+                return $left / $right;
+            case '%':
+                if (0 == $right) {
+                    throw new \DivisionByZeroError('Modulo by zero.');
+                }
+
+                return $left % $right;
+            case 'matches':
+                return $this->evaluateMatches($right, $left);
+        }
+    }
+
+    public function toArray(): array
+    {
+        return ['(', $this->nodes['left'], ' '.$this->attributes['operator'].' ', $this->nodes['right'], ')'];
+    }
+
+    /**
+     * @internal to be replaced by an inline strict call to in_array() in version 7.0
+     */
+    public static function inArray($value, array $array): bool
+    {
+        if (false === $key = array_search($value, $array)) {
+            return false;
+        }
+
+        if (!\in_array($value, $array, true)) {
+            trigger_deprecation('symfony/expression-language', '6.3', 'The "in" operator will use strict comparisons in Symfony 7.0. Loose match found with key "%s" for value %s. Normalize the array parameter so it only has the expected types or implement loose matching in your own expression function.', $key, json_encode($value));
+        }
+
+        return true;
+    }
+
+    private function evaluateMatches(string $regexp, ?string $str): int
+    {
+        set_error_handler(static fn ($t, $m) => throw new SyntaxError(sprintf('Regexp "%s" passed to "matches" is not valid', $regexp).substr($m, 12)));
+        try {
+            return preg_match($regexp, (string) $str);
+        } finally {
+            restore_error_handler();
+        }
+    }
+}

vendor/symfony/expression-language/Node/ConditionalNode.php

@@ -0,0 +1,56 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConditionalNode extends Node
+{
+    public function __construct(Node $expr1, Node $expr2, Node $expr3)
+    {
+        parent::__construct(
+            ['expr1' => $expr1, 'expr2' => $expr2, 'expr3' => $expr3]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $compiler
+            ->raw('((')
+            ->compile($this->nodes['expr1'])
+            ->raw(') ? (')
+            ->compile($this->nodes['expr2'])
+            ->raw(') : (')
+            ->compile($this->nodes['expr3'])
+            ->raw('))')
+        ;
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        if ($this->nodes['expr1']->evaluate($functions, $values)) {
+            return $this->nodes['expr2']->evaluate($functions, $values);
+        }
+
+        return $this->nodes['expr3']->evaluate($functions, $values);
+    }
+
+    public function toArray(): array
+    {
+        return ['(', $this->nodes['expr1'], ' ? ', $this->nodes['expr2'], ' : ', $this->nodes['expr3'], ')'];
+    }
+}

vendor/symfony/expression-language/Node/ConstantNode.php

@@ -0,0 +1,83 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConstantNode extends Node
+{
+    public readonly bool $isNullSafe;
+    private bool $isIdentifier;
+
+    public function __construct(mixed $value, bool $isIdentifier = false, bool $isNullSafe = false)
+    {
+        $this->isIdentifier = $isIdentifier;
+        $this->isNullSafe = $isNullSafe;
+        parent::__construct(
+            [],
+            ['value' => $value]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $compiler->repr($this->attributes['value']);
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        return $this->attributes['value'];
+    }
+
+    public function toArray(): array
+    {
+        $array = [];
+        $value = $this->attributes['value'];
+
+        if ($this->isIdentifier) {
+            $array[] = $value;
+        } elseif (true === $value) {
+            $array[] = 'true';
+        } elseif (false === $value) {
+            $array[] = 'false';
+        } elseif (null === $value) {
+            $array[] = 'null';
+        } elseif (is_numeric($value)) {
+            $array[] = $value;
+        } elseif (!\is_array($value)) {
+            $array[] = $this->dumpString($value);
+        } elseif ($this->isHash($value)) {
+            foreach ($value as $k => $v) {
+                $array[] = ', ';
+                $array[] = new self($k);
+                $array[] = ': ';
+                $array[] = new self($v);
+            }
+            $array[0] = '{';
+            $array[] = '}';
+        } else {
+            foreach ($value as $v) {
+                $array[] = ', ';
+                $array[] = new self($v);
+            }
+            $array[0] = '[';
+            $array[] = ']';
+        }
+
+        return $array;
+    }
+}

vendor/symfony/expression-language/Node/FunctionNode.php

@@ -0,0 +1,70 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class FunctionNode extends Node
+{
+    public function __construct(string $name, Node $arguments)
+    {
+        parent::__construct(
+            ['arguments' => $arguments],
+            ['name' => $name]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $arguments = [];
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $compiler->subcompile($node);
+        }
+
+        $function = $compiler->getFunction($this->attributes['name']);
+
+        $compiler->raw($function['compiler'](...$arguments));
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        $arguments = [$values];
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $node->evaluate($functions, $values);
+        }
+
+        return $functions[$this->attributes['name']]['evaluator'](...$arguments);
+    }
+
+    /**
+     * @return array
+     */
+    public function toArray()
+    {
+        $array = [];
+        $array[] = $this->attributes['name'];
+
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $array[] = ', ';
+            $array[] = $node;
+        }
+        $array[1] = '(';
+        $array[] = ')';
+
+        return $array;
+    }
+}

vendor/symfony/expression-language/Node/GetAttrNode.php

@@ -0,0 +1,166 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class GetAttrNode extends Node
+{
+    public const PROPERTY_CALL = 1;
+    public const METHOD_CALL = 2;
+    public const ARRAY_CALL = 3;
+
+    /**
+     * @param self::* $type
+     */
+    public function __construct(Node $node, Node $attribute, ArrayNode $arguments, int $type)
+    {
+        parent::__construct(
+            ['node' => $node, 'attribute' => $attribute, 'arguments' => $arguments],
+            ['type' => $type, 'is_null_coalesce' => false, 'is_short_circuited' => false],
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $nullSafe = $this->nodes['attribute'] instanceof ConstantNode && $this->nodes['attribute']->isNullSafe;
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw($nullSafe ? '?->' : '->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                ;
+                break;
+
+            case self::METHOD_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw($nullSafe ? '?->' : '->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                    ->raw('(')
+                    ->compile($this->nodes['arguments'])
+                    ->raw(')')
+                ;
+                break;
+
+            case self::ARRAY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('[')
+                    ->compile($this->nodes['attribute'])->raw(']')
+                ;
+                break;
+        }
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+                if (null === $obj && ($this->nodes['attribute']->isNullSafe || $this->attributes['is_null_coalesce'])) {
+                    $this->attributes['is_short_circuited'] = true;
+
+                    return null;
+                }
+                if (null === $obj && $this->isShortCircuited()) {
+                    return null;
+                }
+
+                if (!\is_object($obj)) {
+                    throw new \RuntimeException(sprintf('Unable to get property "%s" of non-object "%s".', $this->nodes['attribute']->dump(), $this->nodes['node']->dump()));
+                }
+
+                $property = $this->nodes['attribute']->attributes['value'];
+
+                if ($this->attributes['is_null_coalesce']) {
+                    return $obj->$property ?? null;
+                }
+
+                return $obj->$property;
+
+            case self::METHOD_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+
+                if (null === $obj && $this->nodes['attribute']->isNullSafe) {
+                    $this->attributes['is_short_circuited'] = true;
+
+                    return null;
+                }
+                if (null === $obj && $this->isShortCircuited()) {
+                    return null;
+                }
+
+                if (!\is_object($obj)) {
+                    throw new \RuntimeException(sprintf('Unable to call method "%s" of non-object "%s".', $this->nodes['attribute']->dump(), $this->nodes['node']->dump()));
+                }
+                if (!\is_callable($toCall = [$obj, $this->nodes['attribute']->attributes['value']])) {
+                    throw new \RuntimeException(sprintf('Unable to call method "%s" of object "%s".', $this->nodes['attribute']->attributes['value'], get_debug_type($obj)));
+                }
+
+                return $toCall(...array_values($this->nodes['arguments']->evaluate($functions, $values)));
+
+            case self::ARRAY_CALL:
+                $array = $this->nodes['node']->evaluate($functions, $values);
+
+                if (null === $array && $this->isShortCircuited()) {
+                    return null;
+                }
+
+                if (!\is_array($array) && !$array instanceof \ArrayAccess && !(null === $array && $this->attributes['is_null_coalesce'])) {
+                    throw new \RuntimeException(sprintf('Unable to get an item of non-array "%s".', $this->nodes['node']->dump()));
+                }
+
+                if ($this->attributes['is_null_coalesce']) {
+                    return $array[$this->nodes['attribute']->evaluate($functions, $values)] ?? null;
+                }
+
+                return $array[$this->nodes['attribute']->evaluate($functions, $values)];
+        }
+    }
+
+    private function isShortCircuited(): bool
+    {
+        return $this->attributes['is_short_circuited'] || ($this->nodes['node'] instanceof self && $this->nodes['node']->isShortCircuited());
+    }
+
+    public function toArray(): array
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                return [$this->nodes['node'], '.', $this->nodes['attribute']];
+
+            case self::METHOD_CALL:
+                return [$this->nodes['node'], '.', $this->nodes['attribute'], '(', $this->nodes['arguments'], ')'];
+
+            case self::ARRAY_CALL:
+                return [$this->nodes['node'], '[', $this->nodes['attribute'], ']'];
+        }
+    }
+
+    /**
+     * Provides BC with instances serialized before v6.2.
+     */
+    public function __unserialize(array $data): void
+    {
+        $this->nodes = $data['nodes'];
+        $this->attributes = $data['attributes'];
+        $this->attributes['is_null_coalesce'] ??= false;
+        $this->attributes['is_short_circuited'] ??= $data["\x00Symfony\Component\ExpressionLanguage\Node\GetAttrNode\x00isShortCircuited"] ?? false;
+    }
+}

vendor/symfony/expression-language/Node/NameNode.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class NameNode extends Node
+{
+    public function __construct(string $name)
+    {
+        parent::__construct(
+            [],
+            ['name' => $name]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $compiler->raw('$'.$this->attributes['name']);
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        return $values[$this->attributes['name']];
+    }
+
+    public function toArray(): array
+    {
+        return [$this->attributes['name']];
+    }
+}

vendor/symfony/expression-language/Node/Node.php

@@ -0,0 +1,130 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * Represents a node in the AST.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Node
+{
+    public $nodes = [];
+    public $attributes = [];
+
+    /**
+     * @param array $nodes      An array of nodes
+     * @param array $attributes An array of attributes
+     */
+    public function __construct(array $nodes = [], array $attributes = [])
+    {
+        $this->nodes = $nodes;
+        $this->attributes = $attributes;
+    }
+
+    public function __toString(): string
+    {
+        $attributes = [];
+        foreach ($this->attributes as $name => $value) {
+            $attributes[] = sprintf('%s: %s', $name, str_replace("\n", '', var_export($value, true)));
+        }
+
+        $repr = [str_replace('Symfony\Component\ExpressionLanguage\Node\\', '', static::class).'('.implode(', ', $attributes)];
+
+        if (\count($this->nodes)) {
+            foreach ($this->nodes as $node) {
+                foreach (explode("\n", (string) $node) as $line) {
+                    $repr[] = '    '.$line;
+                }
+            }
+
+            $repr[] = ')';
+        } else {
+            $repr[0] .= ')';
+        }
+
+        return implode("\n", $repr);
+    }
+
+    /**
+     * @return void
+     */
+    public function compile(Compiler $compiler)
+    {
+        foreach ($this->nodes as $node) {
+            $node->compile($compiler);
+        }
+    }
+
+    /**
+     * @return mixed
+     */
+    public function evaluate(array $functions, array $values)
+    {
+        $results = [];
+        foreach ($this->nodes as $node) {
+            $results[] = $node->evaluate($functions, $values);
+        }
+
+        return $results;
+    }
+
+    /**
+     * @return array
+     *
+     * @throws \BadMethodCallException when this node cannot be transformed to an array
+     */
+    public function toArray()
+    {
+        throw new \BadMethodCallException(sprintf('Dumping a "%s" instance is not supported yet.', static::class));
+    }
+
+    /**
+     * @return string
+     */
+    public function dump()
+    {
+        $dump = '';
+
+        foreach ($this->toArray() as $v) {
+            $dump .= \is_scalar($v) ? $v : $v->dump();
+        }
+
+        return $dump;
+    }
+
+    /**
+     * @return string
+     */
+    protected function dumpString(string $value)
+    {
+        return sprintf('"%s"', addcslashes($value, "\0\t\"\\"));
+    }
+
+    /**
+     * @return bool
+     */
+    protected function isHash(array $value)
+    {
+        $expectedKey = 0;
+
+        foreach ($value as $key => $val) {
+            if ($key !== $expectedKey++) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

vendor/symfony/expression-language/Node/NullCoalesceNode.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class NullCoalesceNode extends Node
+{
+    public function __construct(Node $expr1, Node $expr2)
+    {
+        parent::__construct(['expr1' => $expr1, 'expr2' => $expr2]);
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $compiler
+            ->raw('((')
+            ->compile($this->nodes['expr1'])
+            ->raw(') ?? (')
+            ->compile($this->nodes['expr2'])
+            ->raw('))')
+        ;
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        if ($this->nodes['expr1'] instanceof GetAttrNode) {
+            $this->addNullCoalesceAttributeToGetAttrNodes($this->nodes['expr1']);
+        }
+
+        return $this->nodes['expr1']->evaluate($functions, $values) ?? $this->nodes['expr2']->evaluate($functions, $values);
+    }
+
+    public function toArray(): array
+    {
+        return ['(', $this->nodes['expr1'], ') ?? (', $this->nodes['expr2'], ')'];
+    }
+
+    private function addNullCoalesceAttributeToGetAttrNodes(Node $node): void
+    {
+        if (!$node instanceof GetAttrNode) {
+            return;
+        }
+
+        $node->attributes['is_null_coalesce'] = true;
+
+        foreach ($node->nodes as $node) {
+            $this->addNullCoalesceAttributeToGetAttrNodes($node);
+        }
+    }
+}

vendor/symfony/expression-language/Node/UnaryNode.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class UnaryNode extends Node
+{
+    private const OPERATORS = [
+        '!' => '!',
+        'not' => '!',
+        '+' => '+',
+        '-' => '-',
+    ];
+
+    public function __construct(string $operator, Node $node)
+    {
+        parent::__construct(
+            ['node' => $node],
+            ['operator' => $operator]
+        );
+    }
+
+    public function compile(Compiler $compiler): void
+    {
+        $compiler
+            ->raw('(')
+            ->raw(self::OPERATORS[$this->attributes['operator']])
+            ->compile($this->nodes['node'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate(array $functions, array $values): mixed
+    {
+        $value = $this->nodes['node']->evaluate($functions, $values);
+
+        return match ($this->attributes['operator']) {
+            'not',
+            '!' => !$value,
+            '-' => -$value,
+            default => $value,
+        };
+    }
+
+    public function toArray(): array
+    {
+        return ['(', $this->attributes['operator'].' ', $this->nodes['node'], ')'];
+    }
+}