compiler/Compiler/Generator.cs

@@ -68,6 +68,9 @@ public sealed class Generator(List<NodeDefinition> nodes)
             case NodeStatementVariableDeclaration statement:
                 EmitStatementVariableDeclaration(statement);
                 break;
+            case NodeStatementAssignment statement:
+                EmitStatementAssignment(statement);
+                break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(node), node, null);
         }
@@ -87,7 +90,7 @@ public sealed class Generator(List<NodeDefinition> nodes)
 
     private void EmitStatementFuncCall(NodeStatementFuncCall node)
     {
-        var name = EmitExpression(node.Func);
+        var name = EmitExpression(node.Target);
         var parameterValues = node.Parameters.Select(EmitExpression).ToList();
         writer.WriteLine($"{name}({string.Join(", ", parameterValues)});");
     }
@@ -104,6 +107,13 @@ public sealed class Generator(List<NodeDefinition> nodes)
         writer.WriteLine($"{CType(statement.Type)} {statement.Name.Ident} = {value};");
     }
 
+    private void EmitStatementAssignment(NodeStatementAssignment statement)
+    {
+        var target = EmitExpression(statement.Target);
+        var value = EmitExpression(statement.Value);
+        writer.WriteLine($"{target} = {value};");
+    }
+
     private string EmitExpression(NodeExpression node)
     {
         return node switch

compiler/Compiler/Parser.cs

@@ -80,14 +80,25 @@ public sealed class Parser(List<Token> tokens)
             return new NodeStatementVariableDeclaration(TokensFrom(startIndex), name, type, value);
         }
 
-        var expression = ParseExpression();
-        var parameters = new List<NodeExpression>();
+        var target = ParseExpression();
 
-        ExpectSymbol(Symbol.OpenParen);
-        while (!TryExpectSymbol(Symbol.CloseParen))
-            parameters.Add(ParseExpression());
+        if (TryExpectSymbol(Symbol.OpenParen))
+        {
+            var parameters = new List<NodeExpression>();
 
-        return new NodeStatementFuncCall(TokensFrom(startIndex), expression, parameters);
+            while (!TryExpectSymbol(Symbol.CloseParen))
+                parameters.Add(ParseExpression());
+
+            return new NodeStatementFuncCall(TokensFrom(startIndex), target, parameters);
+        }
+
+        if (TryExpectSymbol(Symbol.Equal))
+        {
+            var value = ParseExpression();
+            return new NodeStatementAssignment(TokensFrom(startIndex), target, value);
+        }
+
+        throw new Exception("Not a valid followup for expression statement");
     }
 
     private NodeExpression ParseExpression()
@@ -323,9 +334,9 @@ public sealed class NodeStatementBlock(List<Token> tokens, List<NodeStatement> s
     public readonly List<NodeStatement> Statements = statements;
 }
 
-public sealed class NodeStatementFuncCall(List<Token> tokens, NodeExpression func, List<NodeExpression> parameters) : NodeStatement(tokens)
+public sealed class NodeStatementFuncCall(List<Token> tokens, NodeExpression target, List<NodeExpression> parameters) : NodeStatement(tokens)
 {
-    public readonly NodeExpression Func = func;
+    public readonly NodeExpression Target = target;
     public readonly List<NodeExpression> Parameters = parameters;
 }
 
@@ -341,6 +352,12 @@ internal class NodeStatementVariableDeclaration(List<Token> tokens, TokenIdent n
     public readonly NodeExpression Value = value;
 }
 
+internal class NodeStatementAssignment(List<Token> tokens, NodeExpression target, NodeExpression value) : NodeStatement(tokens)
+{
+    public readonly NodeExpression Target = target;
+    public readonly NodeExpression Value = value;
+}
+
 public abstract class NodeExpression(List<Token> tokens) : Node(tokens);
 
 public sealed class NodeExpressionIntLiteral(List<Token> tokens, TokenIntLiteral value) : NodeExpression(tokens)

compiler/Compiler/Program.cs

@@ -3,8 +3,9 @@
 const string contents = """
                         func main(): i32 {
                             let x: i32 = 23
+                            x = 24
                             do_something("test")
-                            return 69
+                            return x
                         }
                         
                         func do_something(text: string): void {