feat: Add compiling VariableStatement

NewSource/Socordia.CodeAnalysis/AST/EmptyNode.cs

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

NewSource/Socordia.CodeAnalysis/AST/Statements/VariableStatement.cs

@@ -1,4 +1,6 @@
-namespace Socordia.CodeAnalysis.AST.Statements;
+using Socordia.CodeAnalysis.AST.TypeNames;
+
+namespace Socordia.CodeAnalysis.AST.Statements;
 
 public class VariableStatement : AstNode
 {
@@ -13,6 +15,6 @@ public VariableStatement(string name, AstNode? type, AstNode initializer, bool i
     public string Name => Properties.GetOrThrow<string>(nameof(Name));
     public bool IsMutable => Properties.GetOrDefault<bool>(nameof(IsMutable));
 
-    public AstNode? Type => Children.First;
+    public TypeName? Type => (TypeName)Children.First;
     public AstNode Initializer => Children.Last;
 }

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

@@ -0,0 +1,3 @@
+namespace Socordia.CodeAnalysis.AST.TypeNames;
+
+public class NoTypeName : TypeName;

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/Statements/VariableStatementParser.cs

@@ -11,7 +11,7 @@ public static AstNode Parse(TokenIterator iterator, Parser parser)
         var keywordToken = iterator.Prev;
 
         var isMutable = false;
-        TypeName? type = null;
+        TypeName? type = new NoTypeName();
 
         Token mutableToken = null;
 
@@ -30,16 +30,16 @@ public static AstNode Parse(TokenIterator iterator, Parser parser)
             type = TypeNameParser.Parse(parser);
         }
 
-        AstNode initilizer = null;
+        AstNode initializer = new EmptyNode();
         if (iterator.Current.Type == TokenType.EqualsToken)
         {
             iterator.NextToken();
 
-            initilizer = Expression.Parse(parser);
+            initializer = Expression.Parse(parser);
         }
 
         iterator.Match(TokenType.Semicolon);
 
-        return new VariableStatement(nameToken.Text, type, initilizer, isMutable);
+        return new VariableStatement(nameToken.Text, type, initializer, isMutable);
     }
 }

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

@@ -72,7 +72,7 @@ public static TypeName Parse(Parser parser)
             parser.AddError("Expected Identifier, TupleType or Function-Signature as TypeLiteral, but got " +
                 TokenIterator.GetTokenRepresentation(iterator.Current.Type));
 
-            typeNode = null;
+            typeNode = new NoTypeName();
             iterator.NextToken();
         }
 

NewSource/SocordiaC/Compilation/Body/BodyCompilation.cs

@@ -0,0 +1,14 @@
+using DistIL.AsmIO;
+using DistIL.IR.Utils;
+using MrKWatkins.Ast.Listening;
+using Socordia.CodeAnalysis.AST;
+
+namespace SocordiaC.Compilation.Body;
+
+public record BodyCompilation(Driver Driver, MethodDef Method, IRBuilder Builder)
+{
+    public static CompositeListener<BodyCompilation, AstNode> Listener =
+        CompositeListener<BodyCompilation, AstNode>.Build()
+            .With(new VariableDeclarationListener())
+            .ToListener();
+}

NewSource/SocordiaC/Compilation/Body/VariableDeclarationListener.cs

@@ -0,0 +1,33 @@
+using DistIL.AsmIO;
+using MrKWatkins.Ast.Listening;
+using Socordia.CodeAnalysis.AST;
+using Socordia.CodeAnalysis.AST.Statements;
+using Socordia.CodeAnalysis.AST.TypeNames;
+
+namespace SocordiaC.Compilation.Body;
+
+public class VariableDeclarationListener : Listener<BodyCompilation, AstNode, VariableStatement>
+{
+    protected override void ListenToNode(BodyCompilation context, VariableStatement node)
+    {
+        var value = Utils.CreateValue(node.Initializer);
+
+        TypeDesc type;
+        if (node.Type is not NoTypeName)
+        {
+            type = Utils.GetTypeFromNode(node.Type, context.Driver.Compilation.Module)!;
+            if (type != value.ResultType)
+            {
+                node.Type.AddError("Type mismatch");
+            }
+        }
+        else
+        {
+            type = value.ResultType;
+        }
+
+        var slot = context.Method.Body!.CreateVar(type!, node.Name);
+
+        context.Builder.CreateStore(slot, value);
+    }
+}

NewSource/SocordiaC/Compilation/Utils.cs

@@ -2,6 +2,7 @@
 using DistIL.IR;
 using Socordia.CodeAnalysis.AST;
 using Socordia.CodeAnalysis.AST.Declarations;
+using Socordia.CodeAnalysis.AST.Literals;
 using Socordia.CodeAnalysis.AST.TypeNames;
 
 namespace SocordiaC.Compilation;
@@ -81,6 +82,11 @@ public static string ToPascalCase(string name)
 
     public static TypeDefOrSpec? GetTypeFromNode(TypeName node, ModuleDef module)
     {
+        if (node is NoTypeName)
+        {
+            return null;
+        }
+
         if (node is QualifiedTypeName qname)
         {
             if (qname.Type is SimpleTypeName simple)
@@ -97,4 +103,31 @@ public static string ToPascalCase(string name)
 
         throw new Exception("cannot get type from node");
     }
+
+    public static Value CreateValue(AstNode valueNode)
+    {
+        return valueNode switch
+        {
+            LiteralNode literal => CreateLiteral(literal.Value),
+            _ => throw new NotImplementedException()
+        };
+    }
+
+    private static Value CreateLiteral(object literalValue)
+    {
+        return literalValue switch
+        {
+            bool b => ConstInt.Create(PrimType.Bool, b ? 1 : 0),
+            byte by => ConstInt.CreateI(by),
+            short s => ConstInt.CreateI(s),
+            int i => ConstInt.CreateI(i),
+            long l => ConstInt.CreateL(l),
+            float f => ConstFloat.CreateD(f),
+            double d => ConstFloat.CreateD(d),
+            string str => ConstString.Create(str),
+            char c => ConstInt.CreateI(c),
+            null => ConstNull.Create(),
+            _ => throw new NotImplementedException()
+        };
+    }
 }

NewSource/SocordiaC/Stages/CompileFunctionsStage.cs

@@ -3,6 +3,7 @@
 using DistIL.IR.Utils;
 using Flo;
 using SocordiaC.Compilation;
+using SocordiaC.Compilation.Body;
 
 namespace SocordiaC.Stages;
 
@@ -13,11 +14,17 @@ public async Task<Driver> HandleAsync(Driver context, Func<Driver, Task<Driver>>
         foreach (var (node, def) in Mappings.Functions)
         {
             var builder = new IRBuilder(def.Body!.CreateBlock());
+            var bodyCompilation = new BodyCompilation(context, def, builder);
 
             if (!node.Children[1].HasChildren)
             {
                 builder.Emit(new ReturnInst());
             }
+            else
+            {
+                BodyCompilation.Listener.Listen(bodyCompilation, node);
+                builder.Emit(new ReturnInst());
+            }
 
             def.ILBody = ILGenerator.GenerateCode(def.Body);
         }

NewSource/SocordiaC/compilation.sc

@@ -1,7 +1,7 @@
 module TestSuite;
 
 func main() -> none  {
-
+    let myFlag = true;
 }
 
 private func test(hello: i32, flag: bool) -> i32