path: root/src/Parser/Parser.php

<?php

namespace Mnml\Parser;

use Mnml\Lexer\Token;
use Mnml\Lexer\TokenType;

class Parser
{
    private array $tokens;
    private int $position;
    private array $errors;
    private array $nodes;

    /**
    * @param Token[] $tokens
    */
    public function __construct(array $tokens)
    {
        $this->tokens = $tokens;
        $this->position = 0;
        $this->errors = [];
        $this->nodes = [];
    }

    public function parse(): array
    {
        $lastPosition = -1;
        while ($this->position < count($this->tokens) - 1) {
            $lastPosition = $this->position;
            $currentToken = $this->getCurrentToken();
            $currentStatement = null;

            if ($currentToken->literal == "const") {
                $currentStatement = $this->parseConst();
            }

            else if ($currentToken->literal == "if") {
                $currentStatement = $this->parseIf();
            }

            else if ($currentToken->type == TokenType::Comment) {
                $currentStatement = new CommentNode($currentToken);
                $this->advance(1);
            }
            
            else {
                $currentStatement = $this->parseFunctionCall();
            }

            $nextToken = $this->getCurrentToken();
            
            if ($nextToken->literal == "=>") {
                $this->advance(1);
            
                $currentStatement = new PipeExpression($currentStatement, $this->parseExpression(shouldBeFunction: true));
            }
            
            // unknown token
            if ($this->position == $lastPosition) {
                $error = sprintf("Unknown token %s at position %d,%d" . PHP_EOL, $currentToken,  $currentToken->line, $currentToken->column);
                $this->errors[] = $error;

                $this->advance(1);

                echo $error;
            }

            $this->nodes[] = $currentStatement;
        }

        return $this->nodes;
    }

    public function printTree(): void
    {
        $tree = new Tree($this->nodes);
        $this->printNodeRecursive($tree, 0);
    }

    private function printNodeRecursive(Node $node, int $level = 0): void
    {
        $properties = get_object_vars($node);

        foreach ($properties as $propertyKey => $propertyValue) {
            if ($propertyValue instanceof Node) {
                echo sprintf(str_repeat("> ", $level) . "%s: %s" . PHP_EOL, $propertyKey, (new \ReflectionClass($propertyValue))->getShortName());
                $this->printNodeRecursive($propertyValue, $level + 1);
            }
            
            else if (is_array($propertyValue)) {
                $length = count($propertyValue);

                echo sprintf(str_repeat("> ", $level) . "%s[%d]:" . PHP_EOL, $propertyKey, $length);

                if ($length == 0) {
                    echo str_repeat("> ", $level + 1) . "_empty_" . PHP_EOL;
                } else {
                    foreach ($propertyValue as $idx => $item) {
                        echo sprintf(str_repeat("> ", $level + 1) . "[%d]%s" . PHP_EOL, $idx + 1, (new \ReflectionClass($item))->getShortName());
                        $this->printNodeRecursive($item, $level + 2);
                    }
                }
            }

            else {
                if (! empty($propertyValue)) {
                    if ($propertyValue instanceof Token) {                    
                        echo sprintf(str_repeat("> ", $level) . "%s: %s - %d:%d" . PHP_EOL, $propertyKey, $propertyValue->literal, $propertyValue->line, $propertyValue->column);
                    } else {
                        echo sprintf(str_repeat("> ", $level) . "%s: %s" . PHP_EOL, $propertyKey, $propertyValue);
                    }
                } else {
                    echo sprintf(str_repeat("> ", $level) . "%s: %s" . PHP_EOL, $propertyKey, "_empty_");
                }
            }
        }
    }

    private function getCurrentToken(): Token
    {
        return $this->tokens[$this->position]; 
    }

    private function getNextToken(): ?Token
    {
        return $this->tokens[$this->position + 1] ?? null;
    }

    private function advance(int $steps): void
    {
        $lastToken = $this->getCurrentToken();
        
        if ($this->position + $steps > count($this->tokens)) {
            if (! empty($this->errors)) {
                exit;
            }

            assert(
                false,
                "Parser Implementation Error: Can't advance. Position out of bounds."
            );
        }
        
        $this->position += $steps;
    }

    private function stepBack(int $steps): void
    {
        $this->position -= $steps;
    }

    private function anticipateTokenAndSkip(array|string $tokenValues): void
    {
        if (is_string($tokenValues)) {
            $tokenValues = [$tokenValues];
        }

        foreach ($tokenValues as $value) {
            $currentToken = $this->getCurrentToken();

            if ($currentToken->value != $value) {
                $error = sprintf("Expected %s but got %s instead at %d:%d" . PHP_EOL, $value, $currentToken->value, $currentToken->line, $currentToken->column);
                $this->errors[] = $error;

                echo $error;
            }
            
            $this->advance(1);
        }
    }

    private function parseConst(): Node
    {
        // skip const
        $this->anticipateTokenAndSkip("const");

        $identifier = $this->getCurrentToken();
        $this->advance(1);

        // skip :
        $this->anticipateTokenAndSkip(":");

        $type = $this->parseType();

        // skip =
        $this->anticipateTokenAndSkip("=");
        
        $expression = $this->parseExpression(
            shouldBeMap: $type instanceof MapTypeDeclaration,
            shouldBeFunction: $type instanceof TypeDeclaration and $type->left->literal == "function",
        );

        return new ConstVariableDeclaration(
            $identifier,
            $type,
            $expression,
        );
    }

    private function parseType(): Node
    {   
        $currentToken = $this->getCurrentToken();
        $nextToken = $this->getNextToken();

        if ($currentToken->literal == "[") {
            return $this->parseArrayOrMapType();
        }

        else if (in_array($nextToken->literal, ["and", "or"])) {
            $this->advance(2);
            
            return new TypeDeclaration($currentToken, $nextToken, $this->parseType());
        }

        else {
            $this->advance(1);
            
            return new TypeDeclaration($currentToken);
        }
    }

    private function parseArrayOrMapType(): Node
    {
        // skip first [
        $this->anticipateTokenAndSkip("[");
        
        $key = $this->parseType();

        $currentToken = $this->getCurrentToken();
        $nextToken = $this->getNextToken();

        if ($currentToken->literal == "]" && $nextToken->literal == "[") {
            // skip to first type
            $this->advance(2);
            
            $value = $this->parseType();

            // skip last ]
            $this->anticipateTokenAndSkip("]");

            return new MapTypeDeclaration($key, $value);
        } else {
            // skip last ]
            $this->anticipateTokenAndSkip("]");

            return new ArrayTypeDeclaration($key);
        }
    }

    private function parseExpression($shouldBeMap = false, $shouldBeFunction = false): Node|Token
    {
        $currentToken = $this->getCurrentToken();
        $currentExpression = $currentToken;
        
        if ($currentToken->literal == "[") {
            $currentExpression = $this->parseArrayOrMap($shouldBeMap);
        }

        else if ($currentToken->type == TokenType::Identifier) {
            $currentExpression = new IdentifierNode($currentToken);
            $this->advance(1);
        }

        else if ($currentToken->type == TokenType::Number) {
            $currentExpression = $this->parseNumber();
        }

        else if ($currentToken->type == TokenType::String) {
            $currentExpression = new StringNode($currentToken);
            $this->advance(1);
        }

        else if ($currentToken->literal == "(") {
            #if ($shouldBeFunction) {
                $currentExpression = $this->parseFunctionDefinition();
            #}

            # TODO: parse normal ()
        }

        else {
            # TODO: error. unknown token
            $this->advance(1);
        }

        $nextToken = $this->getCurrentToken();

        if (in_array($nextToken->literal, ["+", "-", "*", "**", "/"])) {
            $this->advance(1);
            
            return new OperatorExpression($currentExpression, $nextToken, $this->parseExpression(shouldBeMap: $shouldBeMap));
        }

        else if (in_array($nextToken->literal, ["<", ">", "<=", ">=", "==", "!="])) {
            $this->advance(1);

            return new CompareExpression($currentExpression, $nextToken, $this->parseExpression(shouldBeMap: $shouldBeMap));
        }
        
        else if (in_array($nextToken->literal, ["and", "or"])) {
            $this->advance(1);

            return new Condition($currentExpression, $nextToken, $this->parseExpression(shouldBeMap: $shouldBeMap));
        }

        else if ($nextToken->literal == "=>") {
            $this->advance(1);
            
            return new PipeExpression($currentExpression, $this->parseExpression(shouldBeFunction: true));
        }

        else if ($currentToken->type == TokenType::Identifier and $nextToken->literal == "(") {
            // step back to parse function call fully
            $this->stepBack(1);

            return $this->parseFunctionCall();
        }
        
        else {
            return $currentExpression;
        }
    }

    private function parseArrayOrMap($shouldBeMap = false): Node
    {
        $values = [];

        // skip first [
        if ($this->getCurrentToken()->literal == "[") {
            $this->advance(1);
        }

        $tokenShouldBeComma = false;
        while ($this->getCurrentToken()->literal != "]") {
            $currentToken = $this->getCurrentToken();
            
            // skip ,
            if ($tokenShouldBeComma) {
                if ($currentToken->literal == ",") {
                    $this->advance(1);
                    $tokenShouldBeComma = false;
                    continue;
                }

                // , missing => error
                else {
                    $error = sprintf(
                        "Expected \",\" at position %d,%d - got %s instead" . PHP_EOL,
                        $currentToken->line,
                        $currentToken->column,
                        $currentToken->literal
                    );
                    $this->errors[] = $error;

                    echo $error;

                    break;
                }
            }
                        
            // nested array or map
            if ($currentToken->literal == "[") {
                $values[] = $this->parseArrayOrMap();
                $tokenShouldBeComma = true;
            }

            // skip comments
            else if ($currentToken->type == TokenType::Comment) {
                $this->advance(1);
                continue;
            }

            else {
                $values[] = $this->parseArrayOrMapItem();
                $tokenShouldBeComma = true;
            }
        }

        // skip last ]
        $this->advance(1);
        
        if ((count($values) > 0 and $values[0] instanceof MapItemNode) or $shouldBeMap) {
            return new MapNode($values);
        } else {
            return new ArrayNode($values);
        }
    }

    private function parseArrayOrMapItem(): Node|Token
    {
        $key = $this->parseExpression();

        // is map item
        if ($this->getCurrentToken()->literal == "=") {
            $this->advance(1);
            
            $value = $this->parseExpression();

            return new MapItemNode($key, $value);
        }

        // is array item
        else {
            return $key;
        }
    }

    private function parseNumber(): Node
    {
        $currentToken = $this->getCurrentToken();
        
        $value = $currentToken->value;
        if (str_contains($value, ".")) {
            $value = floatval($value);
        } else {
            $value = intval($value);
        }

        // step to next token
        $this->advance(1);

        return new NumberNode($currentToken, $value);
    }

    private function parseFunctionDefinition(): Node
    {
        $parameters = $this->parseFunctionDefinitionParameters();

        // skip :
        $this->anticipateTokenAndSkip(":");

        $returnType = $this->parseType();

        $body = $this->parseFunctionBody();

        return new FunctionDefinition(
            $parameters,
            $returnType,
            $body,
        );
    }

    private function parseFunctionDefinitionParameters(): array
    {
        // skip first (
        if ($this->getCurrentToken()->literal == "(") {
            $this->advance(1);
        }

        $parameters = [];
        
        while ($this->getCurrentToken()->literal != ")") {
            // skip ,
            if ($this->getCurrentToken()->literal == ",") {
                $this->advance(1);
                continue;
            }
            
            $identifier = $this->getCurrentToken();
            $this->advance(1);

            // skip :
            $this->anticipateTokenAndSkip(":");

            $type = $this->parseType();
            
            // skip potential , instead default value
            if ($this->getCurrentToken()->literal == ",") {
                $this->advance(1);
            }

            // default value
            $defaultValue = null;
            if ($this->getCurrentToken()->literal == "=") {
                $this->advance(1);
                $defaultValue = $this->parseExpression();
            }

            $parameters[] = new FunctionDefinitionParameter(
                $identifier,
                $type,
                $defaultValue,
            );
        }

        // skip last )
        $this->anticipateTokenAndSkip(")");

        return $parameters;
    }

    private function parseFunctionBody(): array
    {
        // skip first {
        $this->anticipateTokenAndSkip("{");

        $body = [];
        
        while ($this->getCurrentToken()->literal != "}") {
            $currentToken = $this->getCurrentToken();
            
            if ($currentToken->literal == "const") {
                $body[] = $this->parseConst();               
            }

            else if ($currentToken->literal == "return") {
                $body[] = $this->parseFunctionReturn();
            }

            else if ($currentToken->literal == "if") {
                $body[] = $this->parseIf();
            }

            // skip comments
            else if ($currentToken->type == TokenType::Comment) {
                $this->advance(1);
                continue;
            }

            else {
                $body[] = $this->parseFunctionCall();
            }
        }

        // skip last }
        $this->anticipateTokenAndSkip("}");

        return $body;
    }

    private function parseFunctionReturn(): Node
    {
        // skip return
        $this->anticipateTokenAndSkip("return");

        return new FunctionReturn($this->parseExpression());
    }

    private function parseFunctionCall(): Node
    {
        $identifier = $this->getCurrentToken();
        $this->advance(1);

        // skip first (
        $this->anticipateTokenAndSkip("(");

        $parameters = $this->parseFunctionCallParameters();

        return new FunctionCall(
            $identifier,
            $parameters,
        );
    }

    private function parseFunctionCallParameters(): array
    {
        // skip first (
        if ($this->getCurrentToken()->literal == "(") {
            $this->advance(1);
        }

        $parameters = [];

        
        while ($this->getCurrentToken()->literal != ")") {
            // skip ,
            if ($this->getCurrentToken()->literal == ",") {
                $this->advance(1);
                continue;
            }
            
            // if "=" then identifier is name
            if ($this->getNextToken()->literal == "=") {
                $identifier = $this->getCurrentToken();
                $this->advance(2);
                
                $value = $this->parseExpression();

                $parameters[] = new FunctionCallParameter(
                    $identifier,
                    $value,
                );
            }

            // else only value is provided
            else {
                $parameters[] = new FunctionCallParameter(
                    null,
                    $this->parseExpression(),
                );
            }
        }

        // skip last )
        $this->anticipateTokenAndSkip(")");

        return $parameters;
    }

    private function parseIf(): Node
    {
        $arms = [];

        // parse first arm
        $arms[] = $this->parseIfArm();

        // parse remaining arms
        while ($this->getCurrentToken()->literal == "else") {
            $arms[] = $this->parseIfArm();
        }

        return new IfNode($arms);
    }

    private function parseIfArm(): Node
    {
        $isElseBlock = false;
        
        if ($this->getCurrentToken()->literal == "if") {
            $this->advance(1);
        }
        else if ($this->getCurrentToken()->literal == "else") {
            if ($this->getNextToken()->literal == "if") {
                $this->advance(2);
            } else {
                $isElseBlock = true;
                $this->advance(1);
            }
        }

        $condition = null;
        if (! $isElseBlock) {
            // skip first (
            $this->anticipateTokenAndSkip("(");

            $condition = $this->parseExpression();

            // skip last )
            $this->anticipateTokenAndSkip(")");
        }

        $body = $this->parseFunctionBody();
        
        return new IfArm(
            $condition,
            $body,
        );
    }
}

class Node
{}

class Tree extends Node
{
    /**
     * @param Node[] $nodes
     */
    public function __construct(
        public array $nodes,
    ) {}
}

class ConstVariableDeclaration extends Node
{
    public function __construct(
        public Token $identifier,
        public Node|Token $type,
        public Node|Token $expression,
    ) {}
}

class TypeDeclaration extends Node
{
    public function __construct(
        public Token $left,
        public ?Token $operator = null,
        public Token|TypeDeclaration|null $right = null,
    ) {} 
}

class ArrayTypeDeclaration extends Node
{
    public function __construct(
        public TypeDeclaration|ArrayTypeDeclaration $value,
    ) {}}

class MapTypeDeclaration extends Node
{
    public function __construct(
        public TypeDeclaration $key,
        public TypeDeclaration|ArrayTypeDeclaration $value,
    ) {}
}

class ArrayNode extends Node
{
    /**
     * @param Array<Token|Node> $values
     */
    public function __construct(
        public array $values,
    ) {}
}

class MapNode extends Node
{
    /**
     * @param MapItemNode[] $values
     */
    public function __construct(
        public array $values,
    ) {}
}
class MapItemNode extends Node
{
    public function __construct(
        public Token|Node $key,
        public Token|Node $value,
    ) {}
}

class OperatorExpression extends Node
{
    public function __construct(
        public Token|Node $left,
        public Token $operator,
        public Token|Node $right,
    ) {}   
}

class CompareExpression extends Node
{
    public function __construct(
        public Token|Node $left,
        public Token $operator,
        public Token|Node $right,
    ) {}
}

class Condition extends Node
{
    public function __construct(
        public Token|Node $left,
        public Token $operator,
        public Token|Node $right,
    ) {}
}

class IdentifierNode extends Node
{
    public function __construct(
        public Token $token,
    ) {}
}

class NumberNode extends Node
{
    public function __construct(
        public Token $token,
        public int|float $value,
    ) {}
}

class StringNode extends Node
{
    public function __construct(
        public Token $token,
    ) {}
}

class CommentNode extends Node
{
    public function __construct(
        public Token $token,
    ) {}
}

class FunctionDefinition extends Node
{
    public function __construct(
        /**
         * @param FunctionDefinitionParameter[] $parameters
         */
        public array $parameters,
        public TypeDeclaration $returnType,
        /**
         * @param Node[] $body
         */
        public array $body,
    ) {}
}

class FunctionDefinitionParameter extends Node
{
    public function __construct(
        public Token $identifier,
        public TypeDeclaration $type,
        public ?Node $defaultValue = null,
    ) {}
}

class FunctionReturn extends Node
{
    public function __construct(
        public Node|Token $returnValue,
    ) {}
}

class FunctionCall extends Node
{
    public function __construct(
        public Token $identifier,
        /**
         * @param FunctionCallParameter[] $parameters
         */
        public array $parameters,
    ) {}
}

class FunctionCallParameter extends Node
{
    public function __construct(
        public ?Token $identifier,
        public Node|Token $value,
    ) {}
}

class IfNode extends Node
{
    public function __construct(
        /**
         * @param IfArm[] $arms
         */
        public array $arms,
    ) {}
}

class IfArm extends Node
{
    public function __construct(
        public Condition|CompareExpression|null $condition,
        public array $body,
    ) {}
}

class PipeExpression extends Node
{
    public function __construct(
        public Token|Node $left,
        public Token|Node $right,
    ) {}
}