Upsilon/Upsilon/Parser/Parser.cs

using System.Collections.Immutable;
using Upsilon.Text;

namespace Upsilon.Parser
{
    public class Parser
    {
        private readonly ImmutableArray<SyntaxToken> _tokens;
        private readonly Diagnostics _diagnostics;
        private int _position;

        private Parser(ImmutableArray<SyntaxToken> tokens, Diagnostics diagnostics)
        {
            _tokens = tokens;
            _diagnostics = diagnostics;
        }

        public static ScriptSyntax Parse(string text, Diagnostics diagnostics)
        {
            var tokens = Lexer.Lex(text, diagnostics);
            return new Parser(tokens, diagnostics).ParseScriptSyntax();
        }

        private SyntaxToken Current => Get(0);
        private SyntaxToken Next => Get(1);

        private SyntaxToken Get(int offset)
        {
            if (_position + offset >= _tokens.Length)
                return new SyntaxToken(SyntaxKind.EndOfFile, _position + offset, "\0", null);
            return _tokens[_position + offset];
        }

        private SyntaxToken NextToken()
        {
            var current = Current;
            _position++;
            return current;
        }

        private SyntaxToken MatchToken(SyntaxKind kind)
        {
            if (Current.Kind == kind)
                return NextToken();

            _diagnostics.LogBadCharacter(Current.Span);
            return new SyntaxToken(kind, Current.Span.Start, "", null);
        }

        public ScriptSyntax ParseScriptSyntax()
        {
            var statement = ParseStatement();
            var eof = MatchToken(SyntaxKind.EndOfFile);
            return new ScriptSyntax(statement, eof);
        }

        public StatementSyntax ParseStatement()
        {
            if (Current.Kind == SyntaxKind.Identifier && Next.Kind == SyntaxKind.Equals)
            {
                return ParseAssignmentExpression();
            }
            if (Current.Kind == SyntaxKind.LocalKeyword && Next.Kind == SyntaxKind.Identifier)
            {
                return ParseAssignmentExpression();
            }

            return ParseExpressionStatement();
        }

        public ExpressionStatementSyntax ParseExpressionStatement()
        {
            var expression = ParseExpression();
            return new ExpressionStatementSyntax(expression);
        }

        public ExpressionSyntax ParseExpression()
        {
            return ParseBinaryExpression();
        }

        private AssignmentExpressionSyntax ParseAssignmentExpression()
        {
            SyntaxToken localKeyword = null;
            if (Current.Kind == SyntaxKind.LocalKeyword)
            {
                localKeyword = MatchToken(SyntaxKind.LocalKeyword);
            }
            var identifier = (IdentifierToken)MatchToken(SyntaxKind.Identifier);
            var assignmentToken = MatchToken(SyntaxKind.Equals);
            var expression = ParseExpression();
            return new AssignmentExpressionSyntax(localKeyword, identifier, assignmentToken, expression);
        }

        private ExpressionSyntax ParseBinaryExpression(SyntaxKindPrecedence.Precedence parentPrecedence = SyntaxKindPrecedence.Precedence.None)
        {
            ExpressionSyntax left;
            var unaryOperatorPrecedence = Current.Kind.UnaryOperatorPrecedence();
            if (unaryOperatorPrecedence != SyntaxKindPrecedence.Precedence.None
                && unaryOperatorPrecedence >= parentPrecedence)
            {
                var operatorToken = NextToken();
                var operand       = ParseBinaryExpression(unaryOperatorPrecedence);
                left = new UnaryExpressionSyntax(operatorToken, operand);
            }
            else
            {
                left = ParsePrimaryExpression();
            }

            while (true)
            {
                var precedence = Current.Kind.BinaryOperatorPrecedence();
                if (precedence == SyntaxKindPrecedence.Precedence.None || precedence <= parentPrecedence)
                    break;

                var op = NextToken();
                var right = ParseBinaryExpression(precedence);
                left = new BinaryExpressionSyntax(left, op, right);
            }
            return left;
        }

        private ExpressionSyntax ParsePrimaryExpression()
        {
            switch (Current.Kind)
            {
                case SyntaxKind.OpenParenthesis:
                    return ParseParenthesizedExpression();
                case SyntaxKind.Number:
                    return ParseNumber();
                case SyntaxKind.TrueKeyword:
                case SyntaxKind.FalseKeyword:
                    return ParseBoolean();
                case SyntaxKind.Identifier:
                    var token = MatchToken(SyntaxKind.Identifier);
                    return new VariableExpressionSyntax((IdentifierToken) token);
                default:
                    _diagnostics.LogBadCharacter(new TextSpan(_position, 1));
                    NextToken();
                    return new BadExpressionSyntax();
            }
        }

        private ExpressionSyntax ParseParenthesizedExpression()
        {
            var l = MatchToken(SyntaxKind.OpenParenthesis);
            var e = ParseExpression();
            var r = MatchToken(SyntaxKind.CloseParenthesis);
            return new ParenthesizedExpressionSyntax(l, e, r);
        }

        private ExpressionSyntax ParseNumber()
        {
            var numberToken = MatchToken(SyntaxKind.Number);
            return new LiteralExpressionSyntax(numberToken, numberToken.Value);
        }

        private ExpressionSyntax ParseBoolean()
        {
            var isTrue = Current.Kind == SyntaxKind.TrueKeyword;
            var token = MatchToken(isTrue ? SyntaxKind.TrueKeyword : SyntaxKind.FalseKeyword);
            return new LiteralExpressionSyntax(token, isTrue);
        }

    }
}