WIP: Preparation for BinaryOperandNode with $left and $right instead of multiple operands

i have the feeling this will make working with the BinaryOperandNode (eg type resolving/inference) easier.
Also the php and js AST use the $left $right and $operator

as a sideeffect it transpiles
- transpile `true === true === true` correctly (with Parenthesis):
`(true === true) === true`
without Parenthesis its invalid php

Author: mhsdesign

src/Parser/Ast/BinaryOperandNodes.php

@@ -25,23 +25,16 @@
 use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\Scanner;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\Token;
-use PackageFactory\ComponentEngine\Parser\Tokenizer\TokenType;
 
 /**
  * @implements \IteratorAggregate<ExpressionNode>
  */
 final class BinaryOperandNodes implements \IteratorAggregate, \JsonSerializable
 {
-    /**
-     * @var ExpressionNode[]
-     */
-    public readonly array $rest;
-
     private function __construct(
         public readonly ExpressionNode $first,
-        ExpressionNode ...$rest
+        public readonly ExpressionNode $second
     ) {
-        $this->rest = $rest;
     }
 
     /**
@@ -55,48 +48,23 @@ public static function fromTokens(ExpressionNode $first, \Iterator $tokens, Bina
         $precedence = $operator->toPrecedence();
         $operands = [$first];
 
-        while (true) {
-            Scanner::skipSpaceAndComments($tokens);
-
-            $operands[] = ExpressionNode::fromTokens($tokens, $precedence);
-
-            Scanner::skipSpaceAndComments($tokens);
+        Scanner::skipSpaceAndComments($tokens);
 
-            if (Scanner::isEnd($tokens)) {
-                break;
-            }
+        $operands[] = ExpressionNode::fromTokens($tokens, $precedence);
 
-            switch (Scanner::type($tokens)) {
-                case TokenType::BRACKET_ROUND_CLOSE:
-                case TokenType::BRACKET_CURLY_CLOSE:
-                case TokenType::BRACKET_SQUARE_CLOSE:
-                case TokenType::ARROW_SINGLE:
-                case TokenType::QUESTIONMARK:
-                    break 2;
-                case $operator->toTokenType():
-                    Scanner::skipOne($tokens);
-                    break;
-                default:
-                    if ($precedence->mustStopAt(Scanner::type($tokens))) {
-                        break 2;
-                    } else {
-                        Scanner::assertType($tokens, $operator->toTokenType());
-                    }
-                    break;
-            }
-        }
+        Scanner::skipSpaceAndComments($tokens);
 
         return new self(...$operands);
     }
 
     public function getIterator(): \Traversable
     {
         yield $this->first;
-        yield from $this->rest;
+        yield $this->second;
     }
 
     public function jsonSerialize(): mixed
     {
-        return [$this->first, ...$this->rest];
+        return [$this->first, $this->second];
     }
 }

src/Target/Php/Transpiler/BinaryOperation/BinaryOperationTranspiler.php

@@ -59,14 +59,10 @@ public function transpile(BinaryOperationNode $binaryOperationNode): string
             shouldAddQuotesIfNecessary: true
         );
 
-        $result = $expressionTranspiler->transpile($binaryOperationNode->operands->first);
-        $operator = sprintf(' %s ', $this->transpileBinaryOperator($binaryOperationNode->operator));
+        $first = $expressionTranspiler->transpile($binaryOperationNode->operands->first);
+        $operator = $this->transpileBinaryOperator($binaryOperationNode->operator);
+        $second = $expressionTranspiler->transpile($binaryOperationNode->operands->second);
 
-        foreach ($binaryOperationNode->operands->rest as $operandNode) {
-            $result .= $operator;
-            $result .= $expressionTranspiler->transpile($operandNode);
-        }
-
-        return sprintf('(%s)', $result);
+        return sprintf('(%s %s %s)', $first, $operator, $second);
     }
 }