Add back variable assignment at declaration time

example/src/main.nub

@@ -1,31 +1,29 @@
 namespace main
 
-// struct Name {
+struct Name {
-//     first: cstring
+    first: cstring
-//     last: cstring
+    last: cstring
-// }
+}
 
-// struct Human
+struct Human
-// {
+{
-//     name: Name
+    name: Name
-//     age: i64
+    age: i64
-// }
+}
 
 export func main(args: []cstring): i64
 {
-    // let x: Human
+    let x: Human = alloc Human
+    {
+        name = alloc Name
+        {
+            first = "john"
+            last = "doe"
+        }
+        age = 23
+    }
 
-    // x = alloc Human {
+    c::puts(x.name.last)
-    //     name = alloc Name {
-    //         first = "john"
-    //         last = "doe"
-    //     }
-    //     age = 23
-    // }
-
-    // c::puts(x.name.last)
-
-    c::puts("test")
 
     return 0
 }

src/compiler/Generation/QBE/QBEGenerator.cs

@@ -707,9 +707,15 @@ public static class QBEGenerator
 
     private static void EmitVariableDeclaration(BoundVariableDeclarationNode variableDeclaration)
     {
-        var tmp = VarName();
+        var variable = VarName();
-        _builder.AppendLine($"    {tmp} =l alloc8 {SizeOf(variableDeclaration.Type)}");
+        _builder.AppendLine($"    {variable} =l alloc8 {SizeOf(variableDeclaration.Type)}");
-        _variables.Push(new Variable(variableDeclaration.Name, new Val(tmp, variableDeclaration.Type, ValKind.Pointer)));
+
+        if (variableDeclaration.Assignment.HasValue)
+        {
+            EmitCopyIntoOrInitialize(variableDeclaration.Assignment.Value, variable);
+        }
+
+        _variables.Push(new Variable(variableDeclaration.Name, new Val(variable, variableDeclaration.Type, ValKind.Pointer)));
     }
 
     private static void EmitWhile(BoundWhileNode whileStatement)

src/compiler/Syntax/Parsing/Node/Statement.cs

@@ -9,7 +9,7 @@ public record StatementExpressionNode(IEnumerable<Token> Tokens, ExpressionNode
 public record ReturnNode(IEnumerable<Token> Tokens, Optional<ExpressionNode> Value) : StatementNode(Tokens);
 public record AssignmentNode(IEnumerable<Token> Tokens, ExpressionNode Expression, ExpressionNode Value) : StatementNode(Tokens);
 public record IfNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body, Optional<Variant<IfNode, BlockNode>> Else) : StatementNode(Tokens);
-public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type) : StatementNode(Tokens);
+public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type, Optional<ExpressionNode> Assignment) : StatementNode(Tokens);
 public record ContinueNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
 public record BreakNode(IEnumerable<Token> Tokens) : StatementNode(Tokens);
 public record WhileNode(IEnumerable<Token> Tokens, ExpressionNode Condition, BlockNode Body) : StatementNode(Tokens);

src/compiler/Syntax/Parsing/Parser.cs

@@ -237,8 +237,14 @@ public static class Parser
         var name = ExpectIdentifier().Value;
         ExpectSymbol(Symbol.Colon);
         var type = ParseType();
+
+        Optional<ExpressionNode> assignment = Optional<ExpressionNode>.Empty();
+        if (TryExpectSymbol(Symbol.Assign))
+        {
+            assignment = ParseExpression();
+        }
         
-        return new VariableDeclarationNode(GetTokensForNode(startIndex), name, type);
+        return new VariableDeclarationNode(GetTokensForNode(startIndex), name, type, assignment);
     }
 
     private static StatementNode ParseBreak(int startIndex)

src/compiler/Syntax/Typing/Binder.cs

@@ -189,7 +189,12 @@ public static class Binder
     private static BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationNode statement)
     {
         _variables[statement.Name] = statement.Type;
-        return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, statement.Type);
+        var assignment = Optional<BoundExpressionNode>.Empty();
+        if (statement.Assignment.HasValue)
+        {
+            assignment = BindExpression(statement.Assignment.Value);
+        }
+        return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, statement.Type, assignment);
     }
 
     private static BoundWhileNode BindWhile(WhileNode statement)

src/compiler/Syntax/Typing/BoundNode/Statement.cs

@@ -8,7 +8,7 @@ public record BoundStatementExpressionNode(IEnumerable<Token> Tokens, BoundExpre
 public record BoundReturnNode(IEnumerable<Token> Tokens, Optional<BoundExpressionNode> Value) : BoundStatementNode(Tokens);
 public record BoundAssignmentNode(IEnumerable<Token> Tokens, BoundExpressionNode Expression, BoundExpressionNode Value) : BoundStatementNode(Tokens);
 public record BoundIfNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body, Optional<Variant<BoundIfNode, BoundBlockNode>> Else) : BoundStatementNode(Tokens);
-public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type) : BoundStatementNode(Tokens);
+public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, NubType Type, Optional<BoundExpressionNode> Assignment) : BoundStatementNode(Tokens);
 public record BoundContinueNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
 public record BoundBreakNode(IEnumerable<Token> Tokens) : BoundStatementNode(Tokens);
 public record BoundWhileNode(IEnumerable<Token> Tokens, BoundExpressionNode Condition, BoundBlockNode Body) : BoundStatementNode(Tokens);