Implement Transpilation for Match example

Author: grebaldi

src/Module/ModuleId.php

@@ -0,0 +1,62 @@
+<?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\Module;
+
+use PackageFactory\ComponentEngine\Parser\Source\Source;
+
+final class ModuleId
+{
+    /**
+     * @var array<string,ModuleId>
+     */
+    private static array $instances;
+
+    private function __construct(private readonly string $value)
+    {
+    }
+
+    public static function fromString(string $moduleIdAsString): self
+    {
+        return self::$instances[$moduleIdAsString] ??= new self($moduleIdAsString);
+    }
+
+    public static function fromSource(Source $source): self
+    {
+        if ($source->path->isMemory()) {
+            return self::fromString(
+                sprintf(
+                    '%s#%s',
+                    $source->path,
+                    hash('sha256', $source->contents)
+                )
+            );
+        } else {
+            return self::fromString((string) $source->path);
+        }
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}

src/Parser/Ast/AccessChainSegmentNodes.php

@@ -22,8 +22,6 @@
 
 namespace PackageFactory\ComponentEngine\Parser\Ast;
 
-use PackageFactory\ComponentEngine\Definition\AccessType;
-use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\Scanner;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\Token;
 use PackageFactory\ComponentEngine\Parser\Tokenizer\TokenType;
@@ -52,6 +50,10 @@ public static function fromTokens(\Iterator $tokens): self
         while (true) {
             Scanner::skipSpaceAndComments($tokens);
 
+            if (Scanner::isEnd($tokens)) {
+                break;
+            }
+
             switch (Scanner::type($tokens)) {
                 case TokenType::PERIOD:
                 case TokenType::OPTCHAIN:

src/Parser/Source/Source.php

@@ -27,7 +27,7 @@
  */
 final class Source implements \IteratorAggregate
 {
-    private function __construct(
+    public function __construct(
         public readonly Path $path,
         public readonly string $contents
     ) {

src/Transpiler/Php/Access/AccessTranspiler.php

@@ -0,0 +1,61 @@
+<?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\Transpiler\Php\Access;
+
+use PackageFactory\ComponentEngine\Parser\Ast\AccessNode;
+use PackageFactory\ComponentEngine\Transpiler\Php\Expression\ExpressionTranspiler;
+use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumStaticType;
+
+final class AccessTranspiler
+{
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
+    public function transpile(AccessNode $accessNode): string
+    {
+        $expressionTranspiler = new ExpressionTranspiler(
+            scope: $this->scope
+        );
+        $expressionTypeResolver = new ExpressionTypeResolver(
+            scope: $this->scope
+        );
+        $typeOfRoot = $expressionTypeResolver->resolveTypeOf($accessNode->root);
+        $result = $expressionTranspiler->transpile($accessNode->root);
+        
+        $isFirstElement = true;
+        foreach ($accessNode->chain->items as $accessChainNode) {
+            if ($typeOfRoot instanceof EnumStaticType && $isFirstElement) {
+                $result .= '::';
+            } else {
+                $result .= '->';
+            }
+            $result .= $accessChainNode->accessor->value;
+            $isFirstElement = false;
+        }
+
+        return $result;
+    }
+}

src/Transpiler/Php/Attribute/AttributeTranspiler.php

@@ -27,9 +27,14 @@
 use PackageFactory\ComponentEngine\Parser\Ast\StringLiteralNode;
 use PackageFactory\ComponentEngine\Transpiler\Php\Expression\ExpressionTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\StringLiteral\StringLiteralTranspiler;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 
 final class AttributeTranspiler
 {
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
     public function transpile(AttributeNode $attributeNode): string
     {
         return sprintf(
@@ -38,7 +43,9 @@ public function transpile(AttributeNode $attributeNode): string
             match ($attributeNode->value::class) {
                 ExpressionNode::class => sprintf(
                     '\' . %s . \'',
-                    (new ExpressionTranspiler())->transpile($attributeNode->value)
+                    (new ExpressionTranspiler(
+                        scope: $this->scope
+                    ))->transpile($attributeNode->value)
                 ),
                 StringLiteralNode::class => (new StringLiteralTranspiler())->transpile($attributeNode->value)
             }

src/Transpiler/Php/BinaryOperation/BinaryOperationTranspiler.php

@@ -25,9 +25,14 @@
 use PackageFactory\ComponentEngine\Definition\BinaryOperator;
 use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;
 use PackageFactory\ComponentEngine\Transpiler\Php\Expression\ExpressionTranspiler;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 
 final class BinaryOperationTranspiler
 {
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
     private function transpileBinaryOperator(BinaryOperator $binaryOperator): string
     {
         return match ($binaryOperator) {
@@ -50,6 +55,7 @@ private function transpileBinaryOperator(BinaryOperator $binaryOperator): string
     public function transpile(BinaryOperationNode $binaryOperationNode): string
     {
         $expressionTranspiler = new ExpressionTranspiler(
+            scope: $this->scope,
             shouldAddQuotesIfNecessary: true
         );
 

src/Transpiler/Php/ComponentDeclaration/ComponentDeclarationTranspiler.php

@@ -28,10 +28,15 @@
 use PackageFactory\ComponentEngine\Transpiler\Php\TypeReference\TypeReferenceTranspiler;
 use PackageFactory\ComponentEngine\TypeSystem\Resolver\Expression\ExpressionTypeResolver;
 use PackageFactory\ComponentEngine\TypeSystem\Scope\ComponentScope\ComponentScope;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 use PackageFactory\ComponentEngine\TypeSystem\Type\StringType\StringType;
 
 final class ComponentDeclarationTranspiler
 {
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
     public function transpile(ComponentDeclarationNode $componentDeclarationNode): string
     {
         $lines = [];
@@ -83,10 +88,15 @@ public function writeConstructorPropertyDeclarations(PropertyDeclarationNodes $p
 
     public function writeReturnExpression(ComponentDeclarationNode $componentDeclarationNode): string
     {
+        $componentScope = new ComponentScope(
+            componentDeclarationNode: $componentDeclarationNode,
+            parentScope: $this->scope
+        );
         $expressionTypeResolver = new ExpressionTypeResolver(
-            scope: new ComponentScope($componentDeclarationNode)
+            scope: $componentScope
         );
         $expressionTranspiler = new ExpressionTranspiler(
+            scope: $componentScope,
             shouldAddQuotesIfNecessary: true
         );
 

src/Transpiler/Php/Expression/ExpressionTranspiler.php

@@ -22,41 +22,60 @@
 
 namespace PackageFactory\ComponentEngine\Transpiler\Php\Expression;
 
+use PackageFactory\ComponentEngine\Parser\Ast\AccessNode;
 use PackageFactory\ComponentEngine\Parser\Ast\BinaryOperationNode;
 use PackageFactory\ComponentEngine\Parser\Ast\BooleanLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Ast\ExpressionNode;
 use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
+use PackageFactory\ComponentEngine\Parser\Ast\MatchNode;
 use PackageFactory\ComponentEngine\Parser\Ast\NumberLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Ast\StringLiteralNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TagNode;
 use PackageFactory\ComponentEngine\Parser\Ast\TernaryOperationNode;
+use PackageFactory\ComponentEngine\Transpiler\Php\Access\AccessTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\BinaryOperation\BinaryOperationTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\BooleanLiteral\BooleanLiteralTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\Identifier\IdentifierTranspiler;
+use PackageFactory\ComponentEngine\Transpiler\Php\Match\MatchTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\NumberLiteral\NumberLiteralTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\StringLiteral\StringLiteralTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\Tag\TagTranspiler;
 use PackageFactory\ComponentEngine\Transpiler\Php\TernaryOperation\TernaryOperationTranspiler;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
 
 final class ExpressionTranspiler
 {
     public function __construct(
-        private bool $shouldAddQuotesIfNecessary = false
+        private readonly ScopeInterface $scope, 
+        private readonly bool $shouldAddQuotesIfNecessary = false
     ) {
     }
 
     public function transpile(ExpressionNode $expressionNode): string
     {
         $rootTranspiler = match ($expressionNode->root::class) {
-            IdentifierNode::class => new IdentifierTranspiler(),
-            TernaryOperationNode::class => new TernaryOperationTranspiler(),
-            BinaryOperationNode::class => new BinaryOperationTranspiler(),
+            AccessNode::class => new AccessTranspiler(
+                scope: $this->scope
+            ),
+            IdentifierNode::class => new IdentifierTranspiler(
+                scope: $this->scope
+            ),
+            TernaryOperationNode::class => new TernaryOperationTranspiler(
+                scope: $this->scope
+            ),
+            BinaryOperationNode::class => new BinaryOperationTranspiler(
+                scope: $this->scope
+            ),
             BooleanLiteralNode::class => new BooleanLiteralTranspiler(),
+            MatchNode::class => new MatchTranspiler(
+                scope: $this->scope
+            ),
             NumberLiteralNode::class => new NumberLiteralTranspiler(),
             StringLiteralNode::class => new StringLiteralTranspiler(
                 shouldAddQuotes: $this->shouldAddQuotesIfNecessary
             ),
             TagNode::class => new TagTranspiler(
+                scope: $this->scope,
                 shouldAddQuotes: $this->shouldAddQuotesIfNecessary
             ),
             default => throw new \Exception('@TODO: Transpile ' . $expressionNode->root::class)

src/Transpiler/Php/Identifier/IdentifierTranspiler.php

@@ -23,11 +23,22 @@
 namespace PackageFactory\ComponentEngine\Transpiler\Php\Identifier;
 
 use PackageFactory\ComponentEngine\Parser\Ast\IdentifierNode;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+use PackageFactory\ComponentEngine\TypeSystem\Type\EnumType\EnumStaticType;
 
 final class IdentifierTranspiler
 {
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
     public function transpile(IdentifierNode $identifierNode): string
     {
-        return '$this->' . $identifierNode->value;
+        $typeOfIdentifiedValue = $this->scope->lookupTypeFor($identifierNode->value);
+
+        return match (true) {
+            $typeOfIdentifiedValue instanceof EnumStaticType => $identifierNode->value,
+            default => '$this->' . $identifierNode->value
+        };
     }
 }

src/Transpiler/Php/Match/MatchTranspiler.php

@@ -0,0 +1,67 @@
+<?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\Transpiler\Php\Match;
+
+use PackageFactory\ComponentEngine\Parser\Ast\MatchNode;
+use PackageFactory\ComponentEngine\Transpiler\Php\Expression\ExpressionTranspiler;
+use PackageFactory\ComponentEngine\TypeSystem\ScopeInterface;
+
+final class MatchTranspiler
+{
+    public function __construct(private readonly ScopeInterface $scope)
+    {
+    }
+
+    public function transpile(MatchNode $matchNode): string
+    {
+        $expressionTranspiler = new ExpressionTranspiler(
+            scope: $this->scope,
+            shouldAddQuotesIfNecessary: true
+        );
+
+        $transpiledSubject = $expressionTranspiler->transpile($matchNode->subject);
+        $transpiledArms = [];
+
+        foreach ($matchNode->arms->items as $matchArmNode) {
+            $left = [];
+            if ($matchArmNode->left === null) {
+                $left = ['default'];
+            } else {
+                foreach ($matchArmNode->left->items as $leftNode) {
+                    $left[] = $expressionTranspiler->transpile($leftNode);
+                }
+            }
+            $transpiledArms[] = sprintf(
+                '%s => %s',
+                join(', ', $left),
+                $expressionTranspiler->transpile($matchArmNode->right)
+            );
+        }
+
+        return sprintf(
+            'match (%s) { %s }',
+            $transpiledSubject,
+            join(', ', $transpiledArms)
+        );
+    }
+}