refactor: Convert to new ast

NewSource/Socordia.CodeAnalysis/AST/AstNode.cs

@@ -1,17 +1,8 @@
 using MrKWatkins.Ast;
-using Socordia.CodeAnalysis.Parsing;
 
 namespace Socordia.CodeAnalysis.AST;
 
 public class AstNode : PropertyNode<AstNode>
 {
-    public AstNode WithRange(Token keywordToken, Token iteratorPrev)
-    {
-        throw new NotImplementedException();
-    }
 
-    public AstNode WithRange(Token token)
-    {
-        throw new NotImplementedException();
-    }
 }

NewSource/Socordia.CodeAnalysis/AST/Declarations/ClassDeclaration.cs

@@ -0,0 +1,14 @@
+namespace Socordia.CodeAnalysis.AST.Declarations;
+
+public class ClassDeclaration : Declaration
+{
+    public ClassDeclaration(string name, List<AstNode> inheritances, List<AstNode> members)
+    {
+        Properties.Set(nameof(Name), name);
+        Properties.Set(nameof(Inheritances), inheritances);
+        Children.Add(members);
+    }
+
+    public string Name => Properties.GetOrThrow<string>(nameof(Name));
+    public List<AstNode> Inheritances => Properties.GetOrThrow<List<AstNode>>(nameof(Inheritances));
+}

NewSource/Socordia.CodeAnalysis/AST/Expressions/Call.cs

@@ -0,0 +1,13 @@
+namespace Socordia.CodeAnalysis.AST.Expressions;
+
+public class Call : AstNode
+{
+    public Call(AstNode callee, List<AstNode> arguments)
+    {
+        Children.Add(callee);
+        Children.Add(arguments);
+    }
+
+    public AstNode Callee => Children[0];
+    public IEnumerable<AstNode> Arguments => Children.Skip(1);
+}

NewSource/Socordia.CodeAnalysis/AST/Expressions/CollectionExpression.cs

@@ -0,0 +1,9 @@
+namespace Socordia.CodeAnalysis.AST.Expressions;
+
+public class CollectionExpression : AstNode
+{
+    public CollectionExpression(List<AstNode> elements)
+    {
+        Children.Add(elements);
+    }
+}

NewSource/Socordia.CodeAnalysis/AST/Expressions/UnaryOperator.cs

@@ -1,15 +1,22 @@
-using Loyc;
+namespace Socordia.CodeAnalysis.AST.Expressions;
 
-namespace Socordia.CodeAnalysis.AST.Expressions;
+public enum UnaryOperatorKind
+{
+    Prefix,
+    Suffix
+}
 
 public class UnaryOperator : AstNode
 {
-    public UnaryOperator(Symbol op, AstNode operand)
+    public UnaryOperator(string op, AstNode operand, UnaryOperatorKind kind)
     {
         Properties.Set(nameof(Op), op);
+        Properties.Set(nameof(Kind), kind);
+
         Children.Add(operand);
     }
 
-    public Symbol Op => Properties.GetOrThrow<Symbol>(nameof(Op));
+    public string Op => Properties.GetOrThrow<string>(nameof(Op));
+    public UnaryOperatorKind Kind => Properties.GetOrThrow<UnaryOperatorKind>(nameof(Kind));
     public AstNode Operand => Children.First;
 }

NewSource/Socordia.CodeAnalysis/AST/Statements/Loops/BreakStatement.cs

@@ -0,0 +1,6 @@
+namespace Socordia.CodeAnalysis.AST.Statements.Loops;
+
+public class BreakStatement : AstNode
+{
+
+}

NewSource/Socordia.CodeAnalysis/AST/Statements/Loops/ContinueStatement.cs

@@ -0,0 +1,6 @@
+namespace Socordia.CodeAnalysis.AST.Statements.Loops;
+
+public class ContinueStatement : AstNode
+{
+
+}

NewSource/Socordia.CodeAnalysis/AST/Statements/DoWhileStatement.cs → NewSource/Socordia.CodeAnalysis/AST/Statements/Loops/DoWhileStatement.cs

@@ -1,4 +1,4 @@
-namespace Socordia.CodeAnalysis.AST.Statements;
+namespace Socordia.CodeAnalysis.AST.Statements.Loops;
 
 public class DoWhileStatement : AstNode
 {

NewSource/Socordia.CodeAnalysis/AST/Statements/Loops/ForStatement.cs

@@ -0,0 +1,17 @@
+namespace Socordia.CodeAnalysis.AST.Statements.Loops;
+
+public class ForStatement : AstNode
+{
+    public ForStatement(AstNode varExpr, AstNode type, AstNode arr, Block body)
+    {
+        Children.Add(varExpr);
+        Children.Add(type);
+        Children.Add(arr);
+        Children.Add(body);
+    }
+
+    public AstNode VarExpr => Children[0];
+    public AstNode Type => Children[1];
+    public AstNode Arr => Children[2];
+    public Block Body => (Block) Children[3];
+}

NewSource/Socordia.CodeAnalysis/AST/Statements/WhileStatement.cs → NewSource/Socordia.CodeAnalysis/AST/Statements/Loops/WhileStatement.cs

@@ -1,4 +1,4 @@
-namespace Socordia.CodeAnalysis.AST.Statements;
+namespace Socordia.CodeAnalysis.AST.Statements.Loops;
 
 public class WhileStatement : AstNode
 {

NewSource/Socordia.CodeAnalysis/AST/TypeAlias.cs

@@ -0,0 +1,11 @@
+namespace Socordia.CodeAnalysis.AST;
+
+public class TypeAlias : AstNode
+{
+    public TypeAlias(AstNode expr)
+    {
+        Children.Add(expr);
+    }
+
+    public AstNode Expression => Children[0];
+}

NewSource/Socordia.CodeAnalysis/AST/TypeNames/GenericTypeName.cs

@@ -0,0 +1,11 @@
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public class GenericTypeName : SimpleTypeName
+{
+    public GenericTypeName(string name, List<TypeName> genericArguments) : base(name)
+    {
+        Properties.Set(nameof(GenericArguments), genericArguments);
+    }
+
+    public List<TypeName> GenericArguments => Properties.GetOrThrow<List<TypeName>>(nameof(GenericArguments));
+}

NewSource/Socordia.CodeAnalysis/AST/TypeNames/PointerKind.cs

@@ -0,0 +1,7 @@
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public enum PointerKind
+{
+    Transient,
+    Reference
+}

NewSource/Socordia.CodeAnalysis/AST/TypeNames/PointerTypeName.cs

@@ -0,0 +1,37 @@
+using System.Text;
+using Socordia.CodeAnalysis.Parsing;
+
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public class PointerTypeName : TypeName
+{
+    public PointerTypeName(TypeName type, PointerKind kind)
+    {
+        Children.Add(type);
+        Properties.Set(nameof(Kind), kind);
+    }
+
+    public TypeName Type => (TypeName)Children[0];
+    public PointerKind Kind => Properties.GetOrThrow<PointerKind>(nameof(Kind));
+
+    public override string ToString()
+    {
+        var builder = new StringBuilder();
+
+        switch (Kind)
+        {
+            case PointerKind.Transient:
+                builder.Append('*');
+                break;
+            case PointerKind.Reference:
+                builder.Append('&');
+                break;
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
+
+        builder.Append(Type);
+
+        return builder.ToString();
+    }
+}

NewSource/Socordia.CodeAnalysis/AST/TypeNames/SimpleTypeName.cs

@@ -0,0 +1,13 @@
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public class SimpleTypeName : TypeName
+{
+    public SimpleTypeName(string name)
+    {
+        Properties.Set(nameof(Name), name);
+    }
+
+    public string Name => Properties.GetOrThrow<string>(nameof(Name));
+
+    public override string ToString() => Name;
+}

NewSource/Socordia.CodeAnalysis/AST/TypeNames/TypeName.cs

@@ -0,0 +1,6 @@
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public abstract class TypeName : AstNode
+{
+
+}

NewSource/Socordia.CodeAnalysis/Parsing/Expression.cs

@@ -2,6 +2,7 @@
 using Loyc;
 using Loyc.Syntax;
 using Socordia.CodeAnalysis.AST;
+using Socordia.CodeAnalysis.AST.Expressions;
 using Socordia.CodeAnalysis.Core;
 using Socordia.CodeAnalysis.Core.Attributes;
 
@@ -47,7 +48,7 @@ public static int GetBinaryOperatorPrecedence(TokenType kind)
         return BinaryOperators.GetValueOrDefault(kind);
     }
 
-    public static AstNode Parse(Parser parser, ParsePoints parsePoints = null, int parentPrecedence = 0)
+    public static AstNode Parse(Parser parser, ParsePointCollection parsePoints = null, int parentPrecedence = 0)
     {
         AstNode left = null;
         var preUnaryOperatorPrecedence = GetPreUnaryOperatorPrecedence(parser.Iterator.Current.Type);
@@ -60,8 +61,7 @@ public static AstNode Parse(Parser parser, ParsePoints parsePoints = null, int p
 
                 var operand = Parse(parser, parsePoints, preUnaryOperatorPrecedence + 1);
 
-                left = SyntaxTree.Unary(GSymbol.Get($"'{operatorToken.Text}"), operand)
-                    .WithRange(operatorToken.Start, operand.Range.EndIndex).WithStyle(NodeStyle.PrefixNotation);
+                left = SyntaxTree.Unary(operatorToken.Text, operand, UnaryOperatorKind.Prefix);
             }
         }
         else
@@ -77,8 +77,7 @@ public static AstNode Parse(Parser parser, ParsePoints parsePoints = null, int p
                 {
                     var unaryOperatorToken = parser.Iterator.NextToken();
 
-                    left = SyntaxTree.Unary(GSymbol.Get($"'suf{unaryOperatorToken.Text}"), left)
-                        .WithRange(left.Range.StartIndex, unaryOperatorToken.End).WithStyle(NodeStyle.Operator);
+                    left = SyntaxTree.Unary(unaryOperatorToken.Text, left, UnaryOperatorKind.Suffix);
                 }
             }
         }
@@ -94,8 +93,7 @@ public static AstNode Parse(Parser parser, ParsePoints parsePoints = null, int p
             var operatorToken = parser.Iterator.NextToken();
             var right = Parse(parser, parsePoints, precedence);
 
-            left = SyntaxTree.Binary(GSymbol.Get($"'{operatorToken.Text}"), left, right)
-                .WithRange(left.Range.StartIndex, right.Range.StartIndex);
+            left = SyntaxTree.Binary(GSymbol.Get($"'{operatorToken.Text}"), left, right);
 
             // parsing postunary for: Hello::new()? = false;
             var postUnaryOperatorPrecedence = GetPostUnaryOperatorPrecedence(parser.Iterator.Current.Type);
@@ -106,8 +104,7 @@ public static AstNode Parse(Parser parser, ParsePoints parsePoints = null, int p
                 {
                     var unaryOperatorToken = parser.Iterator.NextToken();
 
-                    left = SyntaxTree.Unary(GSymbol.Get($"'suf{unaryOperatorToken.Text}"), left)
-                        .WithRange(left.Range.StartIndex, unaryOperatorToken.End).WithStyle(NodeStyle.Operator);
+                    left = SyntaxTree.Unary(unaryOperatorToken.Text, left, UnaryOperatorKind.Suffix);
                 }
             }
         }

NewSource/Socordia.CodeAnalysis/Parsing/LNodeExtensions.cs

@@ -1,4 +1,5 @@
 using Loyc.Syntax;
+using Socordia.CodeAnalysis.Parsing.ParsePoints;
 
 namespace Socordia.CodeAnalysis.Parsing;
 

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/AnnotationParser.cs

@@ -8,10 +8,17 @@ public static Annotation Parse(TokenIterator iterator, Parser parser)
     {
         var atToken = iterator.Match(TokenType.At);
 
-        //ToDo: allow support for annotations without arguments and parens
-        var call = Expression.Parse(parser);
+        var name = iterator.Match(TokenType.Identifier);
+        var args = new List<AstNode>();
 
-        return new Annotation(call).WithRange(atToken, iterator.Prev);
+        if (iterator.IsMatch(TokenType.OpenParen))
+        {
+            iterator.NextToken();
+
+            args = Expression.ParseList(parser, TokenType.CloseParen);
+        }
+
+        return new Annotation(name.Text, args);
     }
 
     public static bool TryParse(Parser parser, out List<Annotation> node)

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/Declarations/BitFieldDeclaration.cs

@@ -1,8 +1,6 @@
-using Loyc.Syntax;
-using Socordia.CodeAnalysis.Core;
-
-namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
+namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
 
+/*
 public sealed class BitFieldDeclaration : IParsePoint
 {
     public static LNode Parse(TokenIterator iterator, Parser parser)
@@ -16,4 +14,5 @@ public static LNode Parse(TokenIterator iterator, Parser parser)
 
         return SyntaxTree.Bitfield(nameToken, members).WithRange(keywordToken, iterator.Prev);
     }
-}
+}
+*/

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/Declarations/BitFieldMemberDeclaration.cs

@@ -1,8 +1,6 @@
-using Loyc.Syntax;
-using Socordia.CodeAnalysis.Core;
-
-namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
+namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
 
+/*
 public sealed class BitFieldMemberDeclaration : IParsePoint
 {
     public static LNode Parse(TokenIterator iterator, Parser parser)
@@ -30,4 +28,5 @@ public static LNode Parse(TokenIterator iterator, Parser parser)
 
         return SyntaxTree.Factory.Tuple(SyntaxTree.Factory.Id(nameToken.Text).WithRange(nameToken), value);
     }
-}
+}
+*/