BadSourceParser.cs

Go to the documentation of this file.

using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
 
using BadScript2.Common;
using BadScript2.Parser.Expressions;
using BadScript2.Parser.Expressions.Access;
using BadScript2.Parser.Expressions.Binary;
using BadScript2.Parser.Expressions.Block;
using BadScript2.Parser.Expressions.Block.Lock;
using BadScript2.Parser.Expressions.Block.Loop;
using BadScript2.Parser.Expressions.Constant;
using BadScript2.Parser.Expressions.ControlFlow;
using BadScript2.Parser.Expressions.Function;
using BadScript2.Parser.Expressions.Module;
using BadScript2.Parser.Expressions.Types;
using BadScript2.Parser.Expressions.Variables;
using BadScript2.Parser.Operators;
using BadScript2.Reader;
using BadScript2.Reader.Token;
using BadScript2.Reader.Token.Primitive;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Types.Interface;
 
namespace BadScript2.Parser;
 
public class BadSourceParser
{
    private readonly BadOperatorTable m_Operators;
 
    private BadMetaData? m_MetaData;
 
    public BadSourceParser(BadSourceReader sourceReader, BadOperatorTable operators)
    {
        Reader = sourceReader;
        m_Operators = operators;
    }
 
    public BadSourceReader Reader { get; }
 
    public static BadSourceParser Create(string fileName, string source)
    {
        return new BadSourceParser(new BadSourceReader(fileName, source), BadOperatorTable.Instance);
    }
 
    public static BadSourceParser Create(string fileName, string source, int start, int end)
    {
        return new BadSourceParser(new BadSourceReader(fileName, source, start, end), BadOperatorTable.Instance);
    }
 
    public static IEnumerable<BadExpression> Parse(string fileName, string source)
    {
        return Create(fileName, source)
            .Parse();
    }
 
    private BadExpression? ParsePrefix(int precedence)
    {
        // Parse Symbol
        BadSymbolToken? symbol = Reader.TryParseSymbols(m_Operators.UnaryPrefixSymbols);
 
        if (symbol == null)
        {
            return null;
        }
 
        BadUnaryPrefixOperator? op = m_Operators.FindUnaryPrefixOperator(symbol.Text, precedence);
 
        if (op != null)
        {
            return op.Parse(this);
        }
 
        Reader.SetPosition(symbol.SourcePosition.Index);
 
        return null;
    }
 
    private BadExpression ParseSwitch()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.SWITCH_KEY);
        Reader.SkipNonToken();
        Reader.Eat('(');
        Reader.SkipNonToken();
        BadExpression value = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(')');
        Reader.SkipNonToken();
        Reader.Eat('{');
        Reader.SkipNonToken();
        Dictionary<BadExpression, BadExpression[]> cases = new Dictionary<BadExpression, BadExpression[]>();
        List<BadExpression>? defaultCase = null;
 
        while (!Reader.IsEof() && !Reader.Is('}'))
        {
            Reader.SkipNonToken();
 
            if (Reader.Is(BadStaticKeys.DEFAULT_KEY))
            {
                Reader.Eat(BadStaticKeys.DEFAULT_KEY);
                Reader.SkipNonToken();
                Reader.Eat(':');
                Reader.SkipNonToken();
                defaultCase = ParseBlock(out bool _);
                Reader.SkipNonToken();
 
                break;
            }
 
            Reader.Eat(BadStaticKeys.CASE_KEY);
            Reader.SkipNonToken();
            BadExpression caseValue = ParseExpression();
            Reader.SkipNonToken();
            Reader.Eat(':');
            Reader.SkipNonToken();
            List<BadExpression> caseBody = new List<BadExpression>();
 
            if (Reader.Is('{'))
            {
                caseBody = ParseBlock(out bool _);
            }
 
            Reader.SkipNonToken();
            cases[caseValue] = caseBody.ToArray();
        }
 
        Reader.Eat('}');
 
        return new BadSwitchExpression(Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                       value,
                                       cases,
                                       defaultCase
                                      );
    }
 
    private BadExpression ParseIf()
    {
        int start = Reader.CurrentIndex;
 
        Dictionary<BadExpression, BadExpression[]> conditionMap = new Dictionary<BadExpression, BadExpression[]>();
 
        bool readNext;
        bool isElse;
 
        do
        {
            readNext = false;
            isElse = false;
            Reader.Eat(BadStaticKeys.IF_KEY);
            Reader.SkipNonToken();
            Reader.Eat('(');
            Reader.SkipNonToken();
            BadExpression condition = ParseExpression();
            Reader.SkipNonToken();
            Reader.Eat(')');
            Reader.SkipNonToken();
            List<BadExpression> block = ParseBlock(out bool _);
            Reader.SkipNonToken();
            conditionMap[condition] = block.ToArray();
 
            if (!Reader.IsKey(BadStaticKeys.ELSE_KEY))
            {
                continue;
            }
 
            Reader.Eat(BadStaticKeys.ELSE_KEY);
            isElse = true;
            Reader.SkipNonToken();
            readNext = Reader.IsKey(BadStaticKeys.IF_KEY);
        }
        while (readNext);
 
        BadExpression[]? elseBlock = null;
 
        if (isElse)
        {
            elseBlock = ParseBlock(out bool _)
                .ToArray();
        }
 
        return new BadIfExpression(conditionMap,
                                   elseBlock,
                                   Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                  );
    }
 
    private BadExpression ParseForEach()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.FOR_EACH_KEY);
        Reader.SkipNonToken();
        Reader.Eat('(');
        Reader.SkipNonToken();
        BadWordToken variableName = Reader.ParseWord();
        Reader.SkipNonToken();
        Reader.Eat("in");
        Reader.SkipNonToken();
        BadExpression collection = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(')');
        Reader.SkipNonToken();
        List<BadExpression> block = ParseBlock(out bool _);
        Reader.SkipNonToken();
 
        return new BadForEachExpression(collection,
                                        variableName,
                                        block.ToArray(),
                                        Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                       );
    }
 
 
    private BadExpression ParseLock()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.LOCK_KEY);
        Reader.SkipNonToken();
        Reader.Eat('(');
        Reader.SkipNonToken();
        BadExpression collection = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(')');
        Reader.SkipNonToken();
        List<BadExpression> block = ParseBlock(out bool _);
        Reader.SkipNonToken();
 
        return new BadLockExpression(Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                     collection,
                                     block.ToArray()
                                    );
    }
 
    private BadExpression ParseFor()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.FOR_KEY);
        Reader.SkipNonToken();
        Reader.Eat('(');
        Reader.SkipNonToken();
        BadExpression vDef = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        Reader.SkipNonToken();
        BadExpression condition = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        Reader.SkipNonToken();
        BadExpression vInc = ParseExpression();
        Reader.SkipNonToken();
        Reader.Eat(')');
        Reader.SkipNonToken();
        List<BadExpression> block = ParseBlock(out bool _);
        Reader.SkipNonToken();
 
        return new BadForExpression(vDef,
                                    condition,
                                    vInc,
                                    block.ToArray(),
                                    Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                   );
    }
 
    private void ParseMeta()
    {
        if (!Reader.Is("@|"))
        {
            return;
        }
 
        Reader.Eat("@|");
        Reader.SkipNonToken();
        StringBuilder rootMeta = new StringBuilder();
        StringBuilder returnMeta = new StringBuilder();
        string returnType = "any";
        Dictionary<string, (string, StringBuilder)> meta = new Dictionary<string, (string, StringBuilder)>();
 
        StringBuilder GetMeta(string name, string type)
        {
            if (meta.TryGetValue(name, out (string, StringBuilder) val))
            {
                return val.Item2;
            }
 
            val = (type, new StringBuilder());
            meta[name] = val;
 
            return val.Item2;
        }
 
        while (!Reader.Is("|@"))
        {
            if (Reader.Is("|PARAM"))
            {
                Reader.Eat("|PARAM");
                Reader.SkipNonToken();
 
                string name = Reader.ParseWord()
                                    .Text;
                Reader.SkipNonToken();
                string type = "any";
 
                if (!Reader.Is(':'))
                {
                    type = "";
 
                    while (!Reader.IsEof() && (Reader.IsWordStart() || Reader.Is('.')))
                    {
                        type += Reader.ParseWord()
                                      .Text;
 
                        if (!Reader.Is('.'))
                        {
                            continue;
                        }
 
                        type += '.';
                        Reader.MoveNext();
                    }
 
                    Reader.SkipNonToken();
                }
 
                Reader.Eat(':');
                Reader.SkipNonToken();
                StringBuilder m = GetMeta(name, type);
 
                while (!Reader.IsEof() && !Reader.Is("|@") && !Reader.IsNewLine())
                {
                    m.Append(Reader.GetCurrentChar());
                    Reader.MoveNext();
                }
 
                Reader.SkipNonToken();
            }
            else if (Reader.Is("|RET"))
            {
                Reader.Eat("|RET");
                Reader.SkipNonToken();
                string type = "any";
 
                if (!Reader.Is(':'))
                {
                    type = "";
 
                    while (!Reader.IsEof() && (Reader.IsWordStart() || Reader.Is('.')))
                    {
                        type += Reader.ParseWord()
                                      .Text;
 
                        if (!Reader.Is('.'))
                        {
                            continue;
                        }
 
                        type += '.';
                        Reader.MoveNext();
                    }
 
                    Reader.SkipNonToken();
                }
 
                Reader.Eat(':');
                Reader.SkipNonToken();
 
                while (!Reader.IsEof() && !Reader.Is("|@") && !Reader.IsNewLine())
                {
                    returnMeta.Append(Reader.GetCurrentChar());
                    Reader.MoveNext();
                }
 
                Reader.SkipNonToken();
 
                returnType = type;
            }
            else
            {
                if (Reader.IsNewLine(-1))
                {
                    Reader.SkipNonToken();
 
                    if (Reader.Is("|"))
                    {
                        continue;
                    }
                }
 
                while (!Reader.IsEof() && !Reader.IsNewLine() && !Reader.Is("|@"))
                {
                    rootMeta.Append(Reader.GetCurrentChar());
                    Reader.MoveNext();
                }
 
                rootMeta.AppendLine();
                Reader.SkipNonToken();
            }
        }
 
        Reader.Eat("|@");
        Reader.SkipNonToken();
 
        m_MetaData = new BadMetaData(rootMeta.ToString()
                                             .Trim(),
                                     returnMeta.ToString()
                                               .Trim(),
                                     returnType,
                                     meta.ToDictionary(x => x.Key,
                                                       x => new BadParameterMetaData(x.Value.Item1,
                                                            x.Value.Item2.ToString()
                                                             .Trim()
                                                           )
                                                      )
                                    );
    }
 
    private BadExpression ParseValue(int precedence)
    {
        Reader.SkipNonToken();
 
        ParseMeta();
 
        Reader.SkipNonToken();
 
        BadExpression? prefixExpr = ParsePrefix(precedence);
 
        if (prefixExpr != null)
        {
            return prefixExpr;
        }
 
        if (Reader.Is('('))
        {
            int start = Reader.CurrentIndex;
 
            try
            {
                List<BadFunctionParameter> p = ParseParameters(start);
 
                Reader.SkipNonToken();
 
                if (!Reader.Is("=>"))
                {
                    Reader.SetPosition(start);
                }
                else
                {
                    return ParseFunction(start, null, null, false, false, BadFunctionCompileLevel.None, p);
                }
            }
            catch (Exception)
            {
                Reader.SetPosition(start);
            }
        }
 
        if (Reader.Is('('))
        {
            Reader.Eat('(');
            BadExpression expr = ParseExpression();
            Reader.Eat(')');
 
            return expr;
        }
 
        if (Reader.Is('['))
        {
            int start = Reader.CurrentIndex;
            Reader.Eat('[');
            Reader.SkipNonToken();
            List<BadExpression> initExpressions = new List<BadExpression>();
 
            if (!Reader.Is(']'))
            {
                bool parseNext;
 
                do
                {
                    parseNext = false;
 
                    Reader.SkipNonToken();
                    initExpressions.Add(ParseExpression());
 
                    Reader.SkipNonToken();
 
                    if (Reader.Is(','))
                    {
                        Reader.Eat(',');
                        Reader.SkipNonToken();
                        parseNext = true;
                    }
                }
                while (parseNext);
            }
 
            Reader.SkipNonToken();
            Reader.Eat(']');
 
            return new BadArrayExpression(initExpressions.ToArray(),
                                          Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                         );
        }
 
        if (Reader.Is('{'))
        {
            int start = Reader.CurrentIndex;
            Reader.Eat('{');
            Dictionary<BadWordToken, BadExpression> table = new Dictionary<BadWordToken, BadExpression>();
            Reader.SkipNonToken();
 
            if (!Reader.Is('}'))
            {
                bool parseNext;
 
                do
                {
                    parseNext = false;
                    Reader.SkipNonToken();
                    BadWordToken key = Reader.ParseWord();
                    Reader.SkipNonToken();
                    Reader.Eat(':');
                    Reader.SkipNonToken();
                    BadExpression value = ParseExpression();
                    table[key] = value;
                    Reader.SkipNonToken();
 
                    if (Reader.Is(','))
                    {
                        parseNext = true;
                        Reader.Eat(',');
                    }
                }
                while (parseNext);
            }
 
            Reader.Eat('}');
 
            return new BadTableExpression(table,
                                          Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                         );
        }
 
        if (Reader.IsKey(BadStaticKeys.LOCK_KEY))
        {
            return ParseLock();
        }
 
        if (Reader.IsKey(BadStaticKeys.FOR_EACH_KEY))
        {
            return ParseForEach();
        }
 
        if (Reader.IsKey(BadStaticKeys.FOR_KEY))
        {
            return ParseFor();
        }
 
        if (Reader.IsKey(BadStaticKeys.IF_KEY))
        {
            return ParseIf();
        }
 
        if (Reader.IsKey(BadStaticKeys.SWITCH_KEY))
        {
            return ParseSwitch();
        }
 
        if (Reader.IsKey(BadStaticKeys.CONTINUE_KEY))
        {
            BadSourcePosition pos = Reader.Eat(BadStaticKeys.CONTINUE_KEY);
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(pos.Index);
            }
            else
            {
                Reader.SkipNonToken();
 
                return new BadContinueExpression(pos);
            }
        }
 
        if (Reader.IsKey(BadStaticKeys.BREAK_KEY))
        {
            BadSourcePosition pos = Reader.Eat(BadStaticKeys.BREAK_KEY);
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(pos.Index);
            }
            else
            {
                Reader.SkipNonToken();
 
                return new BadBreakExpression(pos);
            }
        }
 
        if (Reader.IsKey(BadStaticKeys.THROW_KEY))
        {
            BadSourcePosition pos = Reader.Eat(BadStaticKeys.THROW_KEY);
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(pos.Index);
            }
            else
            {
                return new BadThrowExpression(ParseExpression(), pos);
            }
        }
 
        if (Reader.IsKey(BadStaticKeys.RETURN_KEY))
        {
            BadSourcePosition pos = Reader.Eat(BadStaticKeys.RETURN_KEY);
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(pos.Index);
            }
            else
            {
                Reader.SkipNonToken();
                bool isRef = false;
 
                if (Reader.Is(';'))
                {
                    return new BadReturnExpression(null, pos, false);
                }
 
                if (Reader.IsKey(BadStaticKeys.REF_KEY))
                {
                    isRef = true;
                    Reader.Eat(BadStaticKeys.REF_KEY);
                    Reader.SkipNonToken();
                }
 
                BadExpression expr = ParseExpression();
 
                return new BadReturnExpression(expr, pos, isRef);
            }
        }
 
        if (Reader.IsKey(BadStaticKeys.TRUE) ||
            Reader.IsKey(BadStaticKeys.FALSE))
        {
            BadBooleanToken token = Reader.ParseBoolean();
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(token.SourcePosition.Index);
            }
            else
            {
                return new BadBooleanExpression(bool.Parse(token.Text), token.SourcePosition);
            }
        }
 
        bool isConstant = false;
        bool isStatic = false;
        BadFunctionCompileLevel compileLevel = BadFunctionCompileLevel.None;
        int constStart = Reader.CurrentIndex;
 
        if (Reader.IsKey(BadStaticKeys.CONSTANT_DEFINITION_KEY))
        {
            isConstant = true;
            Reader.Eat(BadStaticKeys.CONSTANT_DEFINITION_KEY);
            Reader.SkipNonToken();
        }
        else if (Reader.IsKey(BadStaticKeys.STATIC_DEFINITION_KEY))
        {
            isStatic = true;
            Reader.Eat(BadStaticKeys.STATIC_DEFINITION_KEY);
            Reader.SkipNonToken();
        }
 
        int compiledStart = Reader.CurrentIndex;
 
        if (Reader.IsKey(BadStaticKeys.COMPILED_DEFINITION_KEY))
        {
            compileLevel = BadFunctionCompileLevel.Compiled;
            Reader.Eat(BadStaticKeys.COMPILED_DEFINITION_KEY);
            Reader.SkipNonToken();
 
            if (Reader.IsKey(BadStaticKeys.COMPILED_FAST_DEFINITION_KEY))
            {
                compileLevel = BadFunctionCompileLevel.CompiledFast;
                Reader.Eat(BadStaticKeys.COMPILED_FAST_DEFINITION_KEY);
                Reader.SkipNonToken();
            }
        }
 
        if (Reader.IsKey(BadStaticKeys.FUNCTION_KEY))
        {
            return ParseFunction(isConstant, isStatic, compileLevel);
        }
 
        if (compileLevel != BadFunctionCompileLevel.None || isConstant)
        {
            Reader.SetPosition(compiledStart < constStart ? compiledStart : constStart);
        }
 
        if (Reader.IsKey(BadStaticKeys.CLASS_KEY))
        {
            return ParseClass();
        }
 
        if (Reader.IsKey(BadStaticKeys.INTERFACE_KEY))
        {
            return ParseInterface();
        }
 
        if (Reader.IsKey(BadStaticKeys.NEW_KEY))
        {
            return ParseNew();
        }
 
        if (Reader.IsKey(BadStaticKeys.TRY_KEY))
        {
            return ParseTry();
        }
 
        if (Reader.IsKey(BadStaticKeys.USING_KEY))
        {
            return ParseUsing();
        }
 
        if (Reader.IsKey(BadStaticKeys.WHILE))
        {
            return ParseWhile();
        }
 
        if (Reader.IsKey(BadStaticKeys.NULL))
        {
            BadNullToken token = Reader.ParseNull();
 
            if (Reader.IsWordChar())
            {
                Reader.SetPosition(token.SourcePosition.Index);
            }
            else
            {
                return new BadNullExpression(token.SourcePosition);
            }
        }
 
        if (Reader.IsStringQuote() || Reader.IsStringQuote(0, true))
        {
            BadStringToken token = Reader.ParseString();
 
            return new BadStringExpression(token.Value, token.SourcePosition);
        }
 
        if (Reader.Is(BadStaticKeys.FORMAT_STRING_KEY))
        {
            return ParseFormatString();
        }
 
        if (Reader.Is(BadStaticKeys.MULTI_LINE_FORMAT_STRING_KEY))
        {
            return ParseMultiLineFormatString();
        }
 
        if (Reader.Is(BadStaticKeys.MULTI_LINE_STRING_KEY))
        {
            BadStringToken token = Reader.ParseMultiLineString();
 
            return new BadStringExpression(token.Value, token.SourcePosition);
        }
 
        if (Reader.IsNumberStart())
        {
            BadNumberToken token = Reader.ParseNumber();
 
            return new BadNumberExpression(decimal.Parse(token.Text, NumberFormatInfo.InvariantInfo),
                                           token.SourcePosition
                                          );
        }
 
        BadValueParser? valueParser = m_Operators.GetValueParser(this);
 
        if (valueParser != null)
        {
            return valueParser.ParseValue(this);
        }
 
        Reader.SkipNonToken();
 
        int wordStart = Reader.CurrentIndex;
        BadWordToken word = Reader.ParseWord();
 
        if (word.Text == BadStaticKeys.VARIABLE_DEFINITION_KEY ||
            word.Text == BadStaticKeys.CONSTANT_DEFINITION_KEY)
        {
            bool isReadOnly = word.Text == BadStaticKeys.CONSTANT_DEFINITION_KEY;
            Reader.SkipNonToken();
            BadExpression nameExpr = ParseValue(0);
            Reader.SkipNonToken();
 
            while (Reader.Is("."))
            {
                Reader.Eat(".");
                BadWordToken right = Reader.ParseWord();
                List<BadExpression>? genArgs = ParseGenericArguments();
 
                nameExpr = new BadMemberAccessExpression(nameExpr,
                                                         right,
                                                         nameExpr.Position.Combine(right.SourcePosition),
                                                         genArgs
                                                        );
                Reader.SkipNonToken();
            }
 
            BadWordToken name;
            BadExpression? type = null;
            Reader.SkipNonToken();
 
            if (Reader.IsWordStart())
            {
                type = nameExpr;
                name = Reader.ParseWord();
            }
            else
            {
                if (nameExpr is not BadVariableExpression expr)
                {
                    throw new BadRuntimeException("Expected variable name", nameExpr.Position);
                }
 
                name = expr.Name;
            }
 
            Reader.SkipNonToken();
 
            if (Reader.Is('{'))
            {
                //Parse Property Accessors
                // => { get => <expr> [set => <expr>] }
                Reader.Eat('{');
                Reader.SkipNonToken();
                Reader.Eat(BadStaticKeys.GET_ACCESSOR_KEY);
                Reader.SkipNonToken();
                Reader.Eat("=>");
                Reader.SkipNonToken();
                BadExpression getExpr = ParseExpression();
                Reader.SkipNonToken();
                Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
                Reader.SkipNonToken();
                BadExpression? setExpr = null;
 
                if (Reader.Is(BadStaticKeys.SET_ACCESSOR_KEY))
                {
                    if (isReadOnly)
                    {
                        throw new BadParserException("Cannot define a set accessor for a constant",
                                                     Reader.MakeSourcePosition(wordStart,
                                                                               Reader.CurrentIndex - wordStart
                                                                              )
                                                    );
                    }
 
                    Reader.Eat(BadStaticKeys.SET_ACCESSOR_KEY);
                    Reader.SkipNonToken();
                    Reader.Eat("=>");
                    Reader.SkipNonToken();
                    setExpr = ParseExpression();
                    Reader.SkipNonToken();
                    Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
                }
 
                Reader.SkipNonToken();
                Reader.Eat('}');
 
                return new BadPropertyDefinitionExpression(name.Text,
                                                           word.SourcePosition,
                                                           getExpr,
                                                           type,
                                                           setExpr,
                                                           isReadOnly
                                                          );
            }
 
            return new BadVariableDefinitionExpression(name.Text, word.SourcePosition, type, isReadOnly);
        }
 
        Reader.SkipNonToken();
 
        List<BadExpression> typeArgs = ParseGenericArguments();
 
        if (precedence <= 0 || (!Reader.Is("=>") && !Reader.Is('*') && !Reader.Is('?') && !Reader.Is('!')))
        {
            return new BadVariableExpression(word.Text, word.SourcePosition, typeArgs.ToArray());
        }
 
        {
            int start = Reader.CurrentIndex;
 
            while (Reader.Is('*') || Reader.Is('?') || Reader.Is('!'))
            {
                Reader.MoveNext();
            }
 
            Reader.SkipNonToken();
 
            if (!Reader.Is("=>"))
            {
                Reader.SetPosition(start);
            }
            else
            {
                Reader.SetPosition(start);
                BadFunctionParameter p;
 
                if (Reader.Is("=>"))
                {
                    p = new BadFunctionParameter(word.Text, false, false, false);
                }
                else
                {
                    Reader.SetPosition(wordStart);
                    p = ParseParameter();
                }
 
                Reader.SkipNonToken();
 
                if (!Reader.Is("=>"))
                {
                    Reader.SetPosition(start);
                }
                else
                {
                    return ParseFunction(start,
                                         null,
                                         null,
                                         false,
                                         isStatic,
                                         BadFunctionCompileLevel.None,
                                         new List<BadFunctionParameter> { p }
                                        );
                }
            }
        }
 
        return new BadVariableExpression(word.Text, word.SourcePosition, typeArgs.ToArray());
    }
 
    public List<BadExpression> ParseGenericArguments()
    {
        List<BadExpression> typeArgs = new List<BadExpression>();
 
        if (Reader.Is('<'))
        {
            int genStart = Reader.CurrentIndex;
 
            try
            {
                Reader.Eat('<');
                Reader.SkipNonToken();
 
                while (true)
                {
                    BadExpression? expr = ParseExpression(null, 3);
                    typeArgs.Add(expr);
                    Reader.SkipNonToken();
 
                    if (!Reader.Is(','))
                    {
                        break;
                    }
 
                    Reader.Eat(',');
                    Reader.SkipNonToken();
                }
 
                Reader.Eat('>');
 
                Reader.SkipNonToken();
            }
            catch (Exception)
            {
                Reader.SetPosition(genStart);
                typeArgs.Clear();
            }
        }
 
        return typeArgs;
    }
 
    public BadExpression ParseExpression(BadExpression? left = null, int precedence = int.MaxValue)
    {
        left ??= ParseValue(precedence);
 
        while (!Reader.IsEof())
        {
            Reader.SkipNonToken();
 
            if (Reader.Is(BadStaticKeys.STATEMENT_END_KEY))
            {
                return left;
            }
 
            if (Reader.Is('[') || Reader.Is("?["))
            {
                bool isNullChecked = Reader.Is("?[");
 
                if (isNullChecked)
                {
                    Reader.Eat("?[");
                }
                else
                {
                    Reader.Eat('[');
                }
 
                Reader.SkipNonToken();
                bool isReverse = false;
 
                if (Reader.Is('^'))
                {
                    Reader.Eat('^');
                    isReverse = true;
                }
 
                List<BadExpression> indices = new List<BadExpression>();
 
                if (!Reader.Is(']'))
                {
                    bool readNext;
 
                    do
                    {
                        readNext = false;
                        Reader.SkipNonToken();
                        indices.Add(ParseExpression());
 
                        Reader.SkipNonToken();
 
                        if (Reader.Is(','))
                        {
                            readNext = true;
                            Reader.Eat(',');
                        }
 
                        Reader.SkipNonToken();
                    }
                    while (readNext);
                }
 
                BadSourcePosition end = Reader.Eat(']');
                Reader.SkipNonToken();
 
                if (isReverse)
                {
                    left = new BadArrayAccessReverseExpression(left,
                                                               indices.ToArray(),
                                                               left.Position.Combine(end),
                                                               isNullChecked
                                                              );
                }
                else
                {
                    left = new BadArrayAccessExpression(left,
                                                        indices.ToArray(),
                                                        left.Position.Combine(end),
                                                        isNullChecked
                                                       );
                }
 
                continue;
            }
 
            if (Reader.Is('('))
            {
                Reader.Eat('(');
                Reader.SkipNonToken();
                List<BadExpression> args = new List<BadExpression>();
 
                if (!Reader.Is(')'))
                {
                    bool readNext;
 
                    do
                    {
                        readNext = false;
                        Reader.SkipNonToken();
                        args.Add(ParseExpression());
 
                        Reader.SkipNonToken();
 
                        if (Reader.Is(','))
                        {
                            readNext = true;
                            Reader.Eat(',');
                        }
 
                        Reader.SkipNonToken();
                    }
                    while (readNext);
                }
 
                BadSourcePosition rightPos = Reader.MakeSourcePosition(1);
                Reader.Eat(')');
                left = new BadInvocationExpression(left, args.ToArray(), left.Position.Combine(rightPos));
                Reader.SkipNonToken();
 
                continue;
            }
 
            // Parse Symbol
            BadSymbolToken? symbol = Reader.TryParseSymbols(m_Operators.BinarySymbols);
 
            if (symbol == null)
            {
                return left;
            }
 
            BadBinaryOperator? op = m_Operators.FindBinaryOperator(symbol.Text, precedence);
 
            if (op == null)
            {
                Reader.SetPosition(symbol.SourcePosition.Index);
 
                return left;
            }
 
            left = op.Parse(left, this);
        }
 
        return left;
    }
 
 
    private BadStringExpression ParseMultiLineFormatString()
    {
        if (!Reader.Is(BadStaticKeys.MULTI_LINE_FORMAT_STRING_KEY))
        {
            throw new
                BadSourceReaderException($"Expected string start character but got '{(Reader.IsEof() ? "EOF" : Reader.GetCurrentChar())}'",
                                         Reader.MakeSourcePosition(1)
                                        );
        }
 
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.MULTI_LINE_FORMAT_STRING_KEY);
        StringBuilder sb = new StringBuilder();
        List<BadExpression> args = new List<BadExpression>();
 
        while (!Reader.IsStringQuote())
        {
            if (Reader.IsEof())
            {
                throw new BadSourceReaderException("String not terminated",
                                                   Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                                  );
            }
 
            if (Reader.Is('{'))
            {
                Reader.Eat('{');
                Reader.SkipNonToken();
 
                if (!Reader.Is('{'))
                {
                    BadExpression expr = ParseExpression();
                    Reader.SkipNonToken();
                    Reader.Eat('}');
                    sb.Append($"{{{args.Count}}}");
                    args.Add(expr);
 
                    continue;
                }
 
                Reader.Eat('{');
                sb.Append("{{");
 
                continue;
            }
 
            if (Reader.Is('}'))
            {
                int idx = Reader.CurrentIndex;
                Reader.Eat('}');
 
                if (!Reader.Is('}'))
                {
                    throw new BadSourceReaderException("Expected '}'",
                                                       Reader.MakeSourcePosition(idx, 1)
                                                      );
                }
 
                Reader.Eat('}');
                sb.Append("}}");
 
                continue;
            }
 
            sb.Append(Reader.GetCurrentChar());
 
            Reader.MoveNext();
        }
 
        Reader.Eat(BadStaticKeys.QUOTE);
 
        if (args.Count == 0)
        {
            string str = sb.ToString()
                           .Replace("{{", "{")
                           .Replace("}}", "}");
 
            return new BadStringExpression('"' + str + '"',
                                           Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                          );
        }
 
        return new BadFormattedStringExpression(args.ToArray(),
                                                sb.ToString(),
                                                Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                               );
    }
 
    private BadStringExpression ParseFormatString()
    {
        if (!Reader.Is(BadStaticKeys.FORMAT_STRING_KEY))
        {
            throw new
                BadSourceReaderException($"Expected string start character but got '{(Reader.IsEof() ? "EOF" : Reader.GetCurrentChar())}'",
                                         Reader.MakeSourcePosition(1)
                                        );
        }
 
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.FORMAT_STRING_KEY);
        bool isEscaped = false;
        StringBuilder sb = new StringBuilder();
        List<BadExpression> args = new List<BadExpression>();
 
        while (!Reader.IsStringQuote())
        {
            if (Reader.IsNewLine() || Reader.IsEof())
            {
                throw new BadSourceReaderException("String not terminated",
                                                   Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                                  );
            }
 
            if (Reader.Is('{'))
            {
                Reader.Eat('{');
                Reader.SkipNonToken();
 
                if (!Reader.Is('{'))
                {
                    BadExpression expr = ParseExpression();
                    Reader.SkipNonToken();
                    Reader.Eat('}');
                    sb.Append($"{{{args.Count}}}");
                    args.Add(expr);
 
                    continue;
                }
 
                Reader.Eat('{');
                sb.Append("{{");
 
                continue;
            }
 
            if (Reader.Is('}'))
            {
                int idx = Reader.CurrentIndex;
                Reader.Eat('}');
 
                if (!Reader.Is('}'))
                {
                    throw new BadParserException("Expected '}'",
                                                 Reader.MakeSourcePosition(idx, 1)
                                                );
                }
 
                Reader.Eat('}');
                sb.Append("}}");
 
                continue;
            }
 
            if (Reader.Is(BadStaticKeys.ESCAPE_CHARACTER))
            {
                isEscaped = true;
                Reader.MoveNext();
            }
 
            if (isEscaped)
            {
                isEscaped = false;
                sb.Append(Regex.Unescape($"\\{Reader.GetCurrentChar()}"));
            }
            else
            {
                sb.Append(Reader.GetCurrentChar());
            }
 
            Reader.MoveNext();
        }
 
        Reader.Eat(BadStaticKeys.QUOTE);
 
        if (args.Count == 0)
        {
            string str = sb.ToString()
                           .Replace("{{", "{")
                           .Replace("}}", "}");
 
            return new BadStringExpression('"' + str + '"',
                                           Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                          );
        }
 
        return new BadFormattedStringExpression(args.ToArray(),
                                                sb.ToString(),
                                                Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                               );
    }
 
    private BadWhileExpression ParseWhile()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.WHILE);
        Reader.SkipNonToken();
        Reader.Eat('(');
        BadExpression condition = ParseExpression();
        Reader.Eat(')');
 
        List<BadExpression> block = ParseBlock(out bool _);
 
        return new BadWhileExpression(condition,
                                      block,
                                      Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                     );
    }
 
    private List<BadExpression> ParseBlock(out bool isSingleLine)
    {
        Reader.SkipNonToken();
 
        List<BadExpression> block = new List<BadExpression>();
 
        if (Reader.Is('{'))
        {
            isSingleLine = false;
            Reader.Eat('{');
            Reader.SkipNonToken();
 
            while (!Reader.Is(BadStaticKeys.BLOCK_END_KEY))
            {
                Reader.SkipNonToken();
                BadExpression expr = ParseExpression();
                block.Add(expr);
                Reader.SkipNonToken();
 
                if (!RequireSemicolon(expr))
                {
                    continue;
                }
 
                Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
                Reader.SkipNonToken();
            }
 
            Reader.Eat(BadStaticKeys.BLOCK_END_KEY);
        }
        else
        {
            isSingleLine = true;
            BadExpression expr = ParseExpression();
 
            if (RequireSemicolon(expr))
            {
                Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
            }
 
            Reader.SkipNonToken();
            block.Add(expr);
        }
 
        Reader.SkipNonToken();
 
        return block;
    }
 
    private List<BadExpression> ParseFunctionBlock(int start, out bool isSingleLine)
    {
        Reader.SkipNonToken();
 
        List<BadExpression> block = new List<BadExpression>();
 
        if (Reader.Is("=>"))
        {
            Reader.Eat("=>");
            block.Add(ParseExpression());
            isSingleLine = true;
        }
        else if (Reader.Is('{'))
        {
            isSingleLine = false;
            Reader.Eat('{');
            Reader.SkipNonToken();
 
            while (!Reader.Is(BadStaticKeys.BLOCK_END_KEY))
            {
                Reader.SkipNonToken();
                BadExpression expr = ParseExpression();
                block.Add(expr);
                Reader.SkipNonToken();
 
                if (!RequireSemicolon(expr))
                {
                    continue;
                }
 
                Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
                Reader.SkipNonToken();
            }
 
            Reader.Eat(BadStaticKeys.BLOCK_END_KEY);
        }
        else
        {
            throw new BadParserException("Expected Expression Body",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        Reader.SkipNonToken();
 
        return block;
    }
 
    private BadExpression ParseUsingStatement(int start)
    {
        Reader.SkipNonToken();
 
        if (!Reader.Is(BadStaticKeys.CONSTANT_DEFINITION_KEY))
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        //Parse single expression
        BadExpression expr = ParseExpression();
 
        if (expr is not BadAssignExpression assignExpr)
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        if (assignExpr.Left is not BadVariableDefinitionExpression varDef)
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        Reader.SkipNonToken();
 
        //Reader.Eat(BadStaticKeys.STATEMENT_END_KEY); //Not Needed, the parser will automatically eat the statement end key
 
        return new BadUsingStatementExpression(Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                               varDef.Name,
                                               expr
                                              );
    }
 
    private BadExpression ParseUsing()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.USING_KEY);
        Reader.SkipNonToken();
 
        if (!Reader.Is('('))
        {
            return ParseUsingStatement(start);
        }
 
        Reader.Eat('(');
        Reader.SkipNonToken();
 
        if (!Reader.Is(BadStaticKeys.CONSTANT_DEFINITION_KEY))
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        //Parse single expression
        BadExpression expr = ParseExpression();
 
        if (expr is not BadAssignExpression assignExpr)
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        if (assignExpr.Left is not BadVariableDefinitionExpression varDef)
        {
            throw new BadParserException("Expected Constant Variable Definition",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        Reader.SkipNonToken();
 
        Reader.Eat(')');
 
        Reader.SkipNonToken();
        List<BadExpression> block = ParseBlock(out bool isSingleLine);
        Reader.SkipNonToken();
 
        if (isSingleLine)
        {
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        }
 
        Reader.SkipNonToken();
 
        return new BadUsingExpression(varDef.Name,
                                      block.ToArray(),
                                      Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                      expr
                                     );
    }
 
    private BadExpression ParseTry()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.TRY_KEY);
        Reader.SkipNonToken();
        List<BadExpression> block = ParseBlock(out bool isSingleLine);
        Reader.SkipNonToken();
 
        if (isSingleLine)
        {
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        }
 
        Reader.SkipNonToken();
        Reader.Eat(BadStaticKeys.CATCH_KEY);
        Reader.SkipNonToken();
        Reader.Eat('(');
        Reader.SkipNonToken();
        BadWordToken errorName = Reader.ParseWord();
        Reader.SkipNonToken();
        Reader.Eat(')');
        Reader.SkipNonToken();
        List<BadExpression> errorBlock = ParseBlock(out isSingleLine);
        Reader.SkipNonToken();
 
        if (isSingleLine)
        {
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        }
 
        Reader.SkipNonToken();
 
        BadExpression[] finallyBlock = Array.Empty<BadExpression>();
 
        if (Reader.Is(BadStaticKeys.FINALLY_KEY))
        {
            Reader.Eat(BadStaticKeys.FINALLY_KEY);
            Reader.SkipNonToken();
            List<BadExpression> finallyExprs = ParseBlock(out isSingleLine);
            Reader.SkipNonToken();
 
            if (isSingleLine)
            {
                Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
            }
 
            Reader.SkipNonToken();
            finallyBlock = finallyExprs.ToArray();
        }
 
        return new BadTryCatchExpression(Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                         block.ToArray(),
                                         errorBlock.ToArray(),
                                         finallyBlock,
                                         errorName.Text
                                        );
    }
 
 
    private BadNewExpression ParseNew()
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.NEW_KEY);
        Reader.SkipNonToken();
        BadExpression right = ParseExpression();
 
        if (right is not BadInvocationExpression invoc)
        {
            throw new BadParserException("Expected Invocation Expression", right.Position);
        }
 
        return new BadNewExpression(invoc, Reader.MakeSourcePosition(start, Reader.CurrentIndex - start));
    }
 
    private BadInterfaceConstraint ParseInterfaceConstraint()
    {
        int start = Reader.CurrentIndex;
        string? name = null;
        BadExpression? type = null;
 
        if (!Reader.Is('('))
        {
            BadExpression nameExpr = ParseValue(0);
            Reader.SkipNonToken();
 
            while (Reader.Is("."))
            {
                Reader.Eat(".");
                BadWordToken right = Reader.ParseWord();
                List<BadExpression>? genArgs = ParseGenericArguments();
 
                nameExpr = new BadMemberAccessExpression(nameExpr,
                                                         right,
                                                         nameExpr.Position.Combine(right.SourcePosition),
                                                         genArgs
                                                        );
                Reader.SkipNonToken();
            }
 
            Reader.SkipNonToken();
 
            if (!Reader.Is('('))
            {
                type = nameExpr;
 
                name = Reader.ParseWord()
                             .Text;
            }
            else
            {
                if (nameExpr is not BadVariableExpression expr)
                {
                    throw new BadParserException("Expected Variable Expression",
                                                 nameExpr.Position
                                                );
                }
 
                name = expr.Name;
            }
        }
 
        if (name == null)
        {
            throw new BadParserException("Expected Name",
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                        );
        }
 
        Reader.SkipNonToken();
 
        if (Reader.Is('('))
        {
            List<BadFunctionParameter> parameters = ParseParameters(start);
 
            Reader.SkipNonToken();
 
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
 
            return new BadInterfaceFunctionConstraint(name, type, parameters.ToArray());
        }
 
        Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
 
        return new BadInterfacePropertyConstraint(name, type);
    }
 
    private List<BadWordToken> ParseGenericParameters()
    {
        List<BadWordToken> genericParameters = new List<BadWordToken>();
        Reader.SkipNonToken();
 
        if (Reader.Is('<'))
        {
            Reader.Eat('<');
            Reader.SkipNonToken();
 
            while (!Reader.IsEof())
            {
                genericParameters.Add(Reader.ParseWord());
                Reader.SkipNonToken();
 
                if (Reader.Is('>'))
                {
                    break;
                }
 
                Reader.Eat(',');
                Reader.SkipNonToken();
            }
 
            Reader.Eat('>');
            Reader.SkipNonToken();
        }
 
        return genericParameters;
    }
 
    private BadInterfacePrototypeExpression ParseInterface()
    {
        BadMetaData? meta = m_MetaData;
        m_MetaData = null;
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.INTERFACE_KEY);
        Reader.SkipNonToken();
        BadWordToken name = Reader.ParseWord();
        List<BadWordToken> genericParameters = ParseGenericParameters();
        Reader.SkipNonToken();
        List<BadExpression> interfaces = new List<BadExpression>();
 
        if (Reader.Is(':'))
        {
            Reader.Eat(':');
 
            while (!Reader.IsEof())
            {
                Reader.SkipNonToken();
                interfaces.Add(ParseExpression());
                Reader.SkipNonToken();
 
                if (!Reader.Is(','))
                {
                    break;
                }
 
                Reader.Eat(',');
                Reader.SkipNonToken();
            }
        }
 
        Reader.Eat('{');
        Reader.SkipNonToken();
        List<BadInterfaceConstraint> constraints = new List<BadInterfaceConstraint>();
 
        while (!Reader.Is('}'))
        {
            Reader.SkipNonToken();
            BadInterfaceConstraint expr = ParseInterfaceConstraint();
 
            constraints.Add(expr);
 
            Reader.SkipNonToken();
        }
 
        Reader.Eat('}');
        Reader.SkipNonToken();
 
        return new BadInterfacePrototypeExpression(name.Text,
                                                   constraints.ToArray(),
                                                   interfaces.ToArray(),
                                                   meta,
                                                   Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                                   genericParameters.ToArray()
                                                  );
    }
 
    private BadClassPrototypeExpression ParseClass()
    {
        BadMetaData? meta = m_MetaData;
        m_MetaData = null;
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.CLASS_KEY);
        Reader.SkipNonToken();
        BadWordToken name = Reader.ParseWord();
        Reader.SkipNonToken();
        List<BadWordToken> genericParameters = ParseGenericParameters();
 
        List<BadFunctionParameter>? primaryConstructor = null;
        List<BadExpression>? baseInvocationParameters = null;
        BadSourcePosition? primaryConstructorPosition = null;
        BadSourcePosition? baseInvocationParametersPosition = null;
        List<BadExpression> members = new List<BadExpression>();
        List<BadExpression> staticMembers = new List<BadExpression>();
 
        if (Reader.Is('('))
        {
            int ctorStart = Reader.CurrentIndex;
            primaryConstructor = ParseParameters(start);
            primaryConstructorPosition = Reader.MakeSourcePosition(ctorStart, Reader.CurrentIndex - ctorStart);
            Reader.SkipNonToken();
        }
 
        List<BadExpression> baseClasses = new List<BadExpression>();
 
        if (Reader.Is(':'))
        {
            Reader.Eat(':');
 
            while (!Reader.IsEof())
            {
                Reader.SkipNonToken();
                BadExpression baseExpr = ParseExpression();
 
                if (baseClasses.Count == 0)
                {
                    if (baseExpr is BadInvocationExpression baseInvoc)
                    {
                        baseInvocationParameters = baseInvoc.Arguments.ToList();
                        baseInvocationParametersPosition = baseInvoc.Position;
                        baseExpr = baseInvoc.Left;
                    }
                }
                else if (baseExpr is BadInvocationExpression)
                {
                    throw new BadParserException("Base Class Invocation must be the first base class",
                                                 baseExpr.Position
                                                );
                }
 
                baseClasses.Add(baseExpr);
                Reader.SkipNonToken();
 
                if (!Reader.Is(','))
                {
                    break;
                }
 
                Reader.Eat(',');
                Reader.SkipNonToken();
            }
        }
 
        if (!Reader.Is(BadStaticKeys.STATEMENT_END_KEY))
        {
            Reader.Eat('{');
            Reader.SkipNonToken();
 
            List<BadExpression> attributeExpressions = new List<BadExpression>();
 
            while (!Reader.Is('}'))
            {
                Reader.SkipNonToken();
 
                bool isAttribute = false;
 
                if (Reader.Is('@') && !Reader.Is('|', 1))
                {
                    Reader.Eat('@');
                    isAttribute = true;
                }
 
                BadExpression expr = ParseExpression();
 
                if (isAttribute)
                {
                    attributeExpressions.Add(expr);
                    Reader.SkipNonToken();
 
                    continue;
                }
 
                if (expr is BadFunctionExpression { IsStatic: true })
                {
                    staticMembers.Add(expr);
                }
                else if (expr is BadFunctionExpression fExpr && fExpr.Name?.Text == name.Text)
                {
                    if (primaryConstructor != null)
                    {
                        throw new BadParserException("Primary Constructor already defined",
                                                     expr.Position
                                                    );
                    }
 
                    fExpr.SetName(BadStaticKeys.CONSTRUCTOR_NAME);
                    members.Add(expr);
                }
                else
                {
                    members.Add(expr);
                }
 
                if (attributeExpressions.Count > 0)
                {
                    expr.SetAttributes(attributeExpressions.ToArray());
                    attributeExpressions.Clear();
                }
 
                if (expr is IBadNamedExpression nExpr && nExpr.GetName() == name.Text)
                {
                    throw new BadParserException("Class Member cannot have the same name as the class",
                                                 expr.Position
                                                );
                }
 
                Reader.SkipNonToken();
 
                if (RequireSemicolon(expr))
                {
                    Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
                }
 
                Reader.SkipNonToken();
            }
 
            if (attributeExpressions.Count != 0)
            {
                throw new BadParserException("Attributes without target",
                                             Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                            );
            }
 
            Reader.Eat('}');
        }
        else
        {
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
        }
 
        Reader.SkipNonToken();
 
        if (primaryConstructor != null)
        {
            List<BadExpression> block = new List<BadExpression>();
 
            //2. Add the primary constructor as a function to the class
            BadFunctionExpression ctor = new BadFunctionExpression(BadStaticKeys.CONSTRUCTOR_NAME,
                                                                   primaryConstructor,
                                                                   block,
                                                                   primaryConstructorPosition!,
                                                                   false,
                                                                   null,
                                                                   false,
                                                                   false
                                                                  );
            members.Add(ctor);
 
            if (baseInvocationParameters != null)
            {
                //  2.1. (call base class constructor if baseInvocationParameters is not null)
                BadInvocationExpression baseInvocation =
                    new BadInvocationExpression(new BadVariableExpression("base", primaryConstructorPosition!),
                                                baseInvocationParameters,
                                                baseInvocationParametersPosition!
                                               );
                block.Add(baseInvocation);
            }
            else
            {
                BadVariableExpression thisExpr =
                    new BadVariableExpression(BadStaticKeys.THIS_KEY, primaryConstructorPosition!);
 
                foreach (BadFunctionParameter parameter in primaryConstructor)
                {
                    //  2.2. (if baseInvocationParameters is null, assign the parameters to the class members)
                    // this.{parameter.Name} = {parameter.Name};
                    block.Add(new BadAssignExpression(new BadMemberAccessExpression(thisExpr,
                                                           parameter.Name,
                                                           primaryConstructorPosition!,
                                                           new List<BadExpression>()
                                                          ),
                                                      new BadVariableExpression(parameter.Name,
                                                                                primaryConstructorPosition!
                                                                               ),
                                                      primaryConstructorPosition!
                                                     )
                             );
 
                    //3. (if baseInvocationParameters is null, define the properties for the parameters)
                    //let {type} {parameter.Name};
                    members.Add(new BadVariableDefinitionExpression(parameter.Name,
                                                                    primaryConstructorPosition!,
                                                                    parameter.TypeExpr,
                                                                    true
                                                                   )
                               );
                }
            }
        }
 
        return new BadClassPrototypeExpression(name.Text,
                                               members.ToArray(),
                                               staticMembers.ToArray(),
                                               baseClasses.ToArray(),
                                               Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                               meta,
                                               genericParameters.ToArray()
                                              );
    }
 
    private BadFunctionParameter ParseParameter()
    {
        BadExpression nameExpr = ParseValue(0);
        Reader.SkipNonToken();
 
        while (Reader.Is("."))
        {
            Reader.Eat(".");
            BadWordToken right = Reader.ParseWord();
            List<BadExpression>? genArgs = ParseGenericArguments();
 
            nameExpr = new BadMemberAccessExpression(nameExpr,
                                                     right,
                                                     nameExpr.Position.Combine(right.SourcePosition),
                                                     genArgs
                                                    );
            Reader.SkipNonToken();
        }
 
        Reader.SkipNonToken();
        string name;
        BadExpression? typeExpr = null;
        Reader.SkipNonToken();
 
        if (Reader.IsWordStart())
        {
            name = Reader.ParseWord()
                         .Text;
            typeExpr = nameExpr;
        }
        else
        {
            if (nameExpr is not BadVariableExpression expr)
            {
                throw new BadParserException("Expected Variable Expression",
                                             nameExpr.Position
                                            );
            }
 
            name = expr.Name;
        }
 
        bool isOptional = false;
        bool isNullChecked = false;
        bool isRestArgs = false;
 
        if (Reader.Is('*'))
        {
            isRestArgs = true;
            Reader.Eat('*');
            Reader.SkipNonToken();
        }
        else
        {
            if (Reader.Is('?'))
            {
                isOptional = true;
                Reader.Eat('?');
                Reader.SkipNonToken();
 
                if (Reader.Is('!'))
                {
                    isNullChecked = true;
                    Reader.Eat('!');
                    Reader.SkipNonToken();
                }
            }
            else if (Reader.Is('!'))
            {
                isNullChecked = true;
                Reader.Eat('!');
                Reader.SkipNonToken();
 
                if (Reader.Is('?'))
                {
                    isOptional = true;
                    Reader.Eat('?');
                    Reader.SkipNonToken();
                }
            }
        }
 
        Reader.SkipNonToken();
 
        return new BadFunctionParameter(name, isOptional, isNullChecked, isRestArgs, typeExpr);
    }
 
    private List<BadFunctionParameter> ParseParameters(int start)
    {
        List<BadFunctionParameter> parameters = new List<BadFunctionParameter>();
 
        Reader.Eat('(');
        Reader.SkipNonToken();
 
        if (!Reader.Is(')'))
        {
            bool first = true;
            bool hadOptional = false;
            bool hadRest = false;
 
            while (Reader.Is(',') || first)
            {
                if (hadRest)
                {
                    throw new BadParserException("Rest parameter must be last parameter",
                                                 Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                                );
                }
 
                if (!first)
                {
                    Reader.Eat(',');
                    Reader.SkipNonToken();
                }
 
                first = false;
 
                BadFunctionParameter param = ParseParameter();
 
                if (hadOptional && param is { IsOptional: false, IsRestArgs: false })
                {
                    throw new BadParserException("Non-Optional parameters must be in front of optional parameters",
                                                 Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                                );
                }
 
                Reader.SkipNonToken();
 
                if (parameters.Any(p => p.Name == param.Name))
                {
                    throw new BadParserException("Duplicate parameter name",
                                                 Reader.MakeSourcePosition(start, Reader.CurrentIndex - start)
                                                );
                }
 
                hadOptional |= param.IsOptional;
                hadRest |= param.IsRestArgs;
 
                parameters.Add(param);
            }
        }
 
        Reader.SkipNonToken();
        Reader.Eat(')');
 
        return parameters;
    }
 
    private BadFunctionExpression ParseFunction(int start,
                                                string? functionName,
                                                BadExpression? functionReturn,
                                                bool isConstant,
                                                bool isStatic,
                                                BadFunctionCompileLevel compileLevel,
                                                List<BadFunctionParameter> parameters)
    {
        BadMetaData? meta = m_MetaData;
        m_MetaData = null;
        List<BadExpression> block = ParseFunctionBlock(start, out bool isSingleLine);
 
        if (isSingleLine)
        {
            block[0] = new BadReturnExpression(block[0], block[0].Position, false);
        }
 
        if (functionName == null)
        {
            return new BadFunctionExpression(null,
                                             parameters,
                                             block,
                                             Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                             isConstant,
                                             meta,
                                             isSingleLine,
                                             isStatic,
                                             compileLevel,
                                             functionReturn
                                            );
        }
 
        return new BadFunctionExpression(functionName,
                                         parameters,
                                         block,
                                         Reader.MakeSourcePosition(start, Reader.CurrentIndex - start),
                                         isConstant,
                                         meta,
                                         isSingleLine,
                                         isStatic,
                                         compileLevel,
                                         functionReturn
                                        );
    }
 
    private BadFunctionExpression ParseFunction(bool isConstant, bool isStatic, BadFunctionCompileLevel compileLevel)
    {
        int start = Reader.CurrentIndex;
        Reader.Eat(BadStaticKeys.FUNCTION_KEY);
        Reader.SkipNonToken();
 
        string? functionName = null;
        BadExpression? functionReturn = null;
 
        if (!Reader.Is('('))
        {
            BadExpression functionNameExpr = ParseValue(0);
            Reader.SkipNonToken();
 
            while (Reader.Is("."))
            {
                Reader.Eat(".");
                BadWordToken right = Reader.ParseWord();
                List<BadExpression>? genArgs = ParseGenericArguments();
 
                functionNameExpr = new BadMemberAccessExpression(functionNameExpr,
                                                                 right,
                                                                 functionNameExpr.Position
                                                                     .Combine(right.SourcePosition),
                                                                 genArgs
                                                                );
                Reader.SkipNonToken();
            }
 
            Reader.SkipNonToken();
 
            if (!Reader.Is('('))
            {
                functionReturn = functionNameExpr;
 
                functionName = Reader.ParseWord()
                                     .Text;
            }
            else
            {
                if (functionNameExpr is not BadVariableExpression expr)
                {
                    throw new BadParserException("Expected Variable Expression",
                                                 functionNameExpr.Position
                                                );
                }
 
                functionName = expr.Name;
            }
        }
 
        List<BadFunctionParameter> parameters = ParseParameters(start);
 
        return ParseFunction(start, functionName, functionReturn, isConstant, isStatic, compileLevel, parameters);
    }
 
    private static bool RequireSemicolon(BadExpression expr)
    {
        if (expr is BadNamedExportExpression named)
        {
            return RequireSemicolon(named.Expression);
        }
 
        if (expr is BadDefaultExportExpression def)
        {
            return RequireSemicolon(def.Expression);
        }
 
        return expr is not (
                   BadInterfacePrototypeExpression or
                   BadClassPrototypeExpression or
                   BadIfExpression or
                   BadForExpression or
                   BadWhileExpression or
                   BadForEachExpression or
                   BadTryCatchExpression or
                   BadLockExpression or
                   BadUsingExpression or
                   BadSwitchExpression or
                   BadPropertyDefinitionExpression or BadFunctionExpression { IsSingleLine: false });
    }
 
    public IEnumerable<BadExpression> Parse()
    {
        Reader.SkipNonToken();
 
        while (!Reader.IsEof())
        {
            Reader.SkipNonToken();
            BadExpression expr = ParseExpression();
            Reader.SkipNonToken();
 
            if (!RequireSemicolon(expr))
            {
                Reader.SkipNonToken();
 
                yield return expr;
 
                continue;
            }
 
            Reader.Eat(BadStaticKeys.STATEMENT_END_KEY);
            Reader.SkipNonToken();
 
            yield return expr;
        }
    }
}