compiler/Compiler/.gitignore

@@ -0,0 +1 @@
+out.c

compiler/Compiler/Generator.cs

@@ -65,6 +65,9 @@ public sealed class Generator(List<NodeDefinition> nodes)
             case NodeStatementReturn statement:
                 EmitStatementReturn(statement);
                 break;
+            case NodeStatementVariableDeclaration statement:
+                EmitStatementVariableDeclaration(statement);
+                break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(node), node, null);
         }
@@ -95,6 +98,12 @@ public sealed class Generator(List<NodeDefinition> nodes)
         writer.WriteLine($"return {value};");
     }
 
+    private void EmitStatementVariableDeclaration(NodeStatementVariableDeclaration statement)
+    {
+        var value = EmitExpression(statement.Value);
+        writer.WriteLine($"{CType(statement.Type)} {statement.Name.Ident} = {value};");
+    }
+
     private string EmitExpression(NodeExpression node)
     {
         return node switch

compiler/Compiler/Parser.cs

@@ -70,6 +70,16 @@ public sealed class Parser(List<Token> tokens)
             return new NodeStatementReturn(TokensFrom(startIndex), value);
         }
 
+        if (TryExpectKeyword(Keyword.Let))
+        {
+            var name = ExpectIdent();
+            ExpectSymbol(Symbol.Colon);
+            var type = ParseType();
+            ExpectSymbol(Symbol.Equal);
+            var value = ParseExpression();
+            return new NodeStatementVariableDeclaration(TokensFrom(startIndex), name, type, value);
+        }
+
         var expression = ParseExpression();
         var parameters = new List<NodeExpression>();
 
@@ -324,6 +334,13 @@ internal class NodeStatementReturn(List<Token> tokens, NodeExpression value) : N
     public readonly NodeExpression Value = value;
 }
 
+internal class NodeStatementVariableDeclaration(List<Token> tokens, TokenIdent name, NodeType type, NodeExpression value) : NodeStatement(tokens)
+{
+    public readonly TokenIdent Name = name;
+    public readonly NodeType Type = type;
+    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

@@ -2,6 +2,7 @@
 
 const string contents = """
                         func main(): i32 {
+                            let x: i32 = 23
                             do_something("test")
                             return 69
                         }
@@ -14,4 +15,4 @@ var tokens = Tokenizer.Tokenize(contents);
 var nodes = Parser.Parse(tokens);
 var output = Generator.Emit(nodes);
 
-Console.WriteLine(output);
+File.WriteAllText("C:/Users/oliste/repos/nub-lang/compiler/Compiler/out.c", output);