TASK: Implement TemplateLiteralParser

Author: grebaldi

src/Language/AST/Node/TemplateLiteral/TemplateLiteralExpressionSegmentNode.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2023 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\Language\AST\Node\TemplateLiteral;
+
+use PackageFactory\ComponentEngine\Language\AST\Node\Expression\ExpressionNode;
+use PackageFactory\ComponentEngine\Language\AST\Node\Node;
+use PackageFactory\ComponentEngine\Parser\Source\Range;
+
+final class TemplateLiteralExpressionSegmentNode extends Node
+{
+
+    public function __construct(
+        public readonly Range $rangeInSource,
+        public readonly ExpressionNode $expression
+    ) {
+    }
+}

src/Language/AST/Node/TemplateLiteral/TemplateLiteralNode.php

@@ -22,22 +22,14 @@
 
 namespace PackageFactory\ComponentEngine\Language\AST\Node\TemplateLiteral;
 
-use PackageFactory\ComponentEngine\Language\AST\Node\Expression\ExpressionNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\Node;
-use PackageFactory\ComponentEngine\Language\AST\Node\StringLiteral\StringLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Source\Range;
 
 final class TemplateLiteralNode extends Node
 {
-    /**
-     * @var (StringLiteralNode|ExpressionNode)[]
-     */
-    public readonly array $segments;
-
     public function __construct(
         public readonly Range $rangeInSource,
-        StringLiteralNode | ExpressionNode ...$segments
+        public readonly TemplateLiteralSegments $segments
     ) {
-        $this->segments = $segments;
     }
 }

src/Language/AST/Node/TemplateLiteral/TemplateLiteralSegments.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2023 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\Language\AST\Node\TemplateLiteral;
+
+final class TemplateLiteralSegments
+{
+    /**
+     * @var (TemplateLiteralStringSegmentNode|TemplateLiteralExpressionSegmentNode)[]
+     */
+    public readonly array $items;
+
+    public function __construct(
+        TemplateLiteralStringSegmentNode | TemplateLiteralExpressionSegmentNode ...$items
+    ) {
+        $this->items = $items;
+    }
+}

src/Language/AST/Node/TemplateLiteral/TemplateLiteralStringSegmentNode.php

@@ -0,0 +1,36 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2023 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\Language\AST\Node\TemplateLiteral;
+
+use PackageFactory\ComponentEngine\Language\AST\Node\Node;
+use PackageFactory\ComponentEngine\Parser\Source\Range;
+
+final class TemplateLiteralStringSegmentNode extends Node
+{
+
+    public function __construct(
+        public readonly Range $rangeInSource,
+        public readonly string $value
+    ) {
+    }
+}

src/Language/Parser/Expression/ExpressionParser.php

@@ -29,7 +29,6 @@
 use PackageFactory\ComponentEngine\Language\AST\Node\BinaryOperation\BinaryOperationNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\BinaryOperation\BinaryOperator;
 use PackageFactory\ComponentEngine\Language\AST\Node\Expression\ExpressionNode;
-use PackageFactory\ComponentEngine\Language\AST\Node\Tag\TagNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TernaryOperation\TernaryOperationNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\UnaryOperation\UnaryOperationNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\UnaryOperation\UnaryOperator;
@@ -38,6 +37,7 @@
 use PackageFactory\ComponentEngine\Language\Parser\NullLiteral\NullLiteralParser;
 use PackageFactory\ComponentEngine\Language\Parser\StringLiteral\StringLiteralParser;
 use PackageFactory\ComponentEngine\Language\Parser\Tag\TagParser;
+use PackageFactory\ComponentEngine\Language\Parser\TemplateLiteral\TemplateLiteralParser;
 use PackageFactory\ComponentEngine\Language\Parser\ValueReference\ValueReferenceParser;
 use PackageFactory\ComponentEngine\Parser\Source\Range;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\Scanner;
@@ -52,16 +52,19 @@ final class ExpressionParser
     private readonly StringLiteralParser $stringLiteralParser;
     private readonly IntegerLiteralParser $integerLiteralParser;
     private readonly ValueReferenceParser $valueReferenceParser;
+    private readonly TemplateLiteralParser $templateLiteralParser;
     private readonly TagParser $tagParser;
 
     public function __construct(
-        private ?TokenType $stopAt = null
+        private ?TokenType $stopAt = null,
+        private Precedence $precedence = Precedence::SEQUENCE
     ) {
         $this->booleanLiteralParser = new BooleanLiteralParser();
         $this->nullLiteralParser = new NullLiteralParser();
         $this->stringLiteralParser = new StringLiteralParser();
         $this->integerLiteralParser = new IntegerLiteralParser();
         $this->valueReferenceParser = new ValueReferenceParser();
+        $this->templateLiteralParser = new TemplateLiteralParser();
         $this->tagParser = new TagParser();
     }
 
@@ -131,6 +134,8 @@ public function parseUnaryStatement(\Iterator &$tokens): ExpressionNode
                 $this->parseValueReference($tokens),
             TokenType::TAG_START_OPENING =>
                 $this->parseTag($tokens),
+            TokenType::TEMPLATE_LITERAL_START =>
+                $this->parseTemplateLiteral($tokens),
             TokenType::BRACKET_ROUND_OPEN =>
                 $this->parseBracketedExpression($tokens),
             default =>
@@ -146,6 +151,7 @@ public function parseUnaryStatement(\Iterator &$tokens): ExpressionNode
                         TokenType::NUMBER_HEXADECIMAL,
                         TokenType::STRING,
                         TokenType::TAG_START_OPENING,
+                        TokenType::TEMPLATE_LITERAL_START,
                         TokenType::BRACKET_ROUND_OPEN
                     ),
                     actualToken: $tokens->current()
@@ -216,6 +222,14 @@ private function withStopAt(TokenType $stopAt): self
         return $newExpressionParser;
     }
 
+    private function withPrecedence(Precedence $precedence): self
+    {
+        $newExpressionParser = clone $this;
+        $newExpressionParser->precedence = $precedence;
+
+        return $newExpressionParser;
+    }
+
     /**
      * @param \Iterator<mixed,Token> $tokens
      * @return boolean
@@ -224,11 +238,21 @@ private function shouldStop(\Iterator &$tokens): bool
     {
         Scanner::skipSpaceAndComments($tokens);
 
-        if (is_null($this->stopAt)) {
-            return Scanner::isEnd($tokens);
+        if (Scanner::isEnd($tokens)) {
+            return true;
+        }
+
+        $type = Scanner::type($tokens);
+
+        if ($this->precedence->mustStopAt($type)) {
+            return true;
+        }
+
+        if ($this->stopAt && $type === $this->stopAt) {
+            return true;
         }
 
-        return Scanner::type($tokens) === $this->stopAt;
+        return false;
     }
 
     /**
@@ -315,6 +339,20 @@ private function parseTag(\Iterator &$tokens): ExpressionNode
         );
     }
 
+    /**
+     * @param \Iterator<mixed,Token> $tokens
+     * @return ExpressionNode
+     */
+    private function parseTemplateLiteral(\Iterator &$tokens): ExpressionNode
+    {
+        $templateLiteralNode = $this->templateLiteralParser->parse($tokens);
+
+        return new ExpressionNode(
+            rangeInSource: $templateLiteralNode->rangeInSource,
+            root: $templateLiteralNode
+        );
+    }
+
     /**
      * @param \Iterator<mixed,Token> $tokens
      * @return ExpressionNode
@@ -412,7 +450,9 @@ private function parseAccessType(\Iterator &$tokens): AccessType
     private function parseBinaryOperation(\Iterator &$tokens, ExpressionNode $leftOperand): ExpressionNode
     {
         $operator = $this->parseBinaryOperator($tokens);
-        $rightOperand = $this->parse($tokens);
+        $rightOperand = $this
+            ->withPrecedence(Precedence::forBinaryOperator($operator))
+            ->parse($tokens);
         $rangeInSource = Range::from(
             $leftOperand->rangeInSource->start,
             $rightOperand->rangeInSource->end

src/Language/Parser/Expression/Precedence.php

@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2022 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\Language\Parser\Expression;
+
+use PackageFactory\ComponentEngine\Language\AST\Node\BinaryOperation\BinaryOperator;
+use PackageFactory\ComponentEngine\Parser\Tokenizer\TokenType;
+
+enum Precedence: int
+{
+    //
+    // Precedence indices as per https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
+    //
+
+    case ACCESS = 18;
+    case UNARY = 15;
+    case COMPARISON = 10;
+    case EQUALITY = 9;
+    case LOGICAL_AND = 5;
+    case LOGICAL_OR = 4;
+    case TERNARY = 3;
+    case SEQUENCE = 1;
+
+    public static function forTokenType(TokenType $tokenType): self
+    {
+        return match ($tokenType) {
+            TokenType::BRACKET_ROUND_OPEN,
+            TokenType::BRACKET_ROUND_CLOSE,
+            TokenType::BRACKET_SQUARE_OPEN,
+            TokenType::BRACKET_SQUARE_CLOSE,
+            TokenType::OPTCHAIN,
+            TokenType::PERIOD => self::ACCESS,
+
+            TokenType::OPERATOR_BOOLEAN_NOT => self::UNARY,
+
+            TokenType::COMPARATOR_GREATER_THAN,
+            TokenType::COMPARATOR_GREATER_THAN_OR_EQUAL,
+            TokenType::COMPARATOR_LESS_THAN,
+            TokenType::COMPARATOR_LESS_THAN_OR_EQUAL => self::COMPARISON,
+
+            TokenType::COMPARATOR_EQUAL,
+            TokenType::COMPARATOR_NOT_EQUAL => self::EQUALITY,
+
+            TokenType::OPERATOR_BOOLEAN_AND => self::LOGICAL_AND,
+
+            TokenType::OPERATOR_BOOLEAN_OR => self::LOGICAL_OR,
+
+            TokenType::QUESTIONMARK,
+            TokenType::COLON => self::TERNARY,
+
+            default => self::SEQUENCE
+        };
+    }
+
+    public static function forBinaryOperator(BinaryOperator $binaryOperator): self
+    {
+        return match ($binaryOperator) {
+            BinaryOperator::AND => self::LOGICAL_AND,
+            BinaryOperator::OR  => self::LOGICAL_OR,
+
+            BinaryOperator::EQUAL,
+            BinaryOperator::NOT_EQUAL => self::EQUALITY,
+
+            BinaryOperator::GREATER_THAN,
+            BinaryOperator::GREATER_THAN_OR_EQUAL,
+            BinaryOperator::LESS_THAN,
+            BinaryOperator::LESS_THAN_OR_EQUAL => self::COMPARISON
+        };
+    }
+
+    public function mustStopAt(TokenType $tokenType): bool
+    {
+        return self::forTokenType($tokenType)->value <= $this->value;
+    }
+}