feat: Add expression body function syntax and emit return statement

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

@@ -7,5 +7,5 @@ public ReturnStatement(AstNode expression)
         Children.Add(expression);
     }
 
-    public AstNode Expression => Children.First;
+    public AstNode Value => Children.First;
 }

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

@@ -1,5 +1,6 @@
 using Socordia.CodeAnalysis.AST;
 using Socordia.CodeAnalysis.AST.Declarations;
+using Socordia.CodeAnalysis.AST.Statements;
 
 namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
 
@@ -10,6 +11,21 @@ public static AstNode Parse(TokenIterator iterator, Parser parser)
         var keywordToken = iterator.Prev;
         var signature = SignatureParser.Parse(parser);
 
-        return new FunctionDefinition(signature, Statements.Statement.ParseBlock(parser));
+        Block body = null;
+        if (iterator.IsMatch(TokenType.OpenCurly))
+        {
+            body = Statements.Statement.ParseBlock(parser);
+        }
+        else if (iterator.ConsumeIfMatch(TokenType.Arrow))
+        {
+            body = new Block([new ReturnStatement(Expression.Parse(parser))]);
+            iterator.Match(TokenType.Semicolon);
+        }
+        else
+        {
+            signature.AddError("Function body is missing");
+        }
+
+        return new FunctionDefinition(signature, body);
     }
 }

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

@@ -37,13 +37,13 @@ public static Signature Parse(Parser parser)
             //generics.Add(LNode.Call(Symbols.Where, LNode.List(genericName, LNode.Call(CodeSymbols.Base, bases))));
         }
 
-        if (iterator.IsMatch(TokenType.Arrow))
+        if (iterator.IsMatch(TokenType.Colon))
         {
             iterator.NextToken();
 
             returnType = TypeNameParser.Parse(parser);
         }
 
-        return SyntaxTree.Signature(name, returnType, parameters, generics);
+        return new Signature(name, returnType, parameters, generics);
     }
 }

NewSource/Socordia.CodeAnalysis/Parsing/SyntaxTree.cs

@@ -145,11 +145,6 @@ public static LNode NullableType(LNode type)
         return Factory.Call(Symbols.NullableType, LNode.List(type));
     }
 
-    public static Signature Signature(AstNode name, AstNode type, List<ParameterDeclaration> parameters, List<AstNode> generics)
-    {
-        return new Signature(name, type, parameters, generics);
-    }
-
     public static AstNode SizeOf(AstNode type)
     {
         return new SizeOf(type);

NewSource/SocordiaC/Compilation/Body/BodyCompilation.cs

@@ -11,5 +11,6 @@ public record BodyCompilation(Driver Driver, MethodDef Method, IRBuilder Builder
         CompositeListener<BodyCompilation, AstNode>.Build()
             .With(new VariableDeclarationListener())
             .With(new CallExpressionListener())
+            .With(new ReturnStatementListener())
             .ToListener();
 }

NewSource/SocordiaC/Compilation/Body/ReturnStatementListener.cs

@@ -0,0 +1,15 @@
+using DistIL.IR;
+using MrKWatkins.Ast.Listening;
+using Socordia.CodeAnalysis.AST;
+using Socordia.CodeAnalysis.AST.Statements;
+
+namespace SocordiaC.Compilation.Body;
+
+public class ReturnStatementListener : Listener<BodyCompilation, AstNode, ReturnStatement>
+{
+    protected override void ListenToNode(BodyCompilation context, ReturnStatement node)
+    {
+        var value = Utils.CreateValue(node.Value);
+        context.Builder.Emit(new ReturnInst(value));
+    }
+}

NewSource/SocordiaC/Compilation/CollectFunctionsListener.cs

@@ -1,22 +1,30 @@
 using System.Reflection;
 using DistIL.AsmIO;
+using DistIL.IR;
 using MrKWatkins.Ast.Listening;
 using Socordia.CodeAnalysis.AST;
 using Socordia.CodeAnalysis.AST.Declarations;
+using Socordia.CodeAnalysis.AST.Statements;
 using MethodBody = DistIL.IR.MethodBody;
 
 namespace SocordiaC.Compilation;
 
 public class CollectFunctionsListener() : Listener<Driver, AstNode, FunctionDefinition>
 {
+    private TypeDesc GetReturnType(FunctionDefinition node, TypeDef type)
+    {
+        return Utils.GetTypeFromNode(node.Signature.ReturnType, type);
+    }
+
     protected override void ListenToNode(Driver context, FunctionDefinition node)
     {
         var attrs = GetModifiers(node);
         var type = context.GetFunctionType(context.GetNamespaceOf(node));
         var parameters = GetParameters(node, type);
 
+        var returnType = GetReturnType(node, type);
         var method = type.CreateMethod(node.Signature.Name.Name,
-            Utils.GetTypeFromNode(node.Signature.ReturnType, type), [..parameters], attrs);
+            returnType, [..parameters], attrs);
 
         if (!node.Modifiers.Contains(Modifier.Extern))
         {

NewSource/SocordiaC/compilation.sc

@@ -1,6 +1,6 @@
 module TestSuite;
 
-func main() -> none  {
+func main(): none  {
     let myFlag = true;
 
     print("hello");
@@ -9,22 +9,19 @@ func main() -> none  {
     test(42, true);
 }
 
-private func test(hello: i32, flag: bool) -> i32
-{
-
-}
+private func test(hello: i32, flag: bool): i32 -> 42;
 
-func complex() -> Functions
+func complex(): Functions
 {
 
 }
 
-func external() -> System.Text.StringBuilder
+func external(): System.Text.StringBuilder
 {
 
 }
 
-func internal_type() -> Hello
+func internal_type(): Hello
 {
 
 }