...

example/src/main.nub

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

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, Optional<ExpressionNode> Assignment) : StatementNode(Tokens);
+public record VariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, 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

@@ -235,16 +235,20 @@ public static class Parser
     {
         ExpectSymbol(Symbol.Let);
         var name = ExpectIdentifier().Value;
-        ExpectSymbol(Symbol.Colon);
-        var type = ParseType();
 
-        Optional<ExpressionNode> assignment = Optional<ExpressionNode>.Empty();
+        var explicitType = Optional<NubType>.Empty();
+        if (TryExpectSymbol(Symbol.Colon))
+        {
+            explicitType = ParseType();
+        }
+
+        var assignment = Optional<ExpressionNode>.Empty();
         if (TryExpectSymbol(Symbol.Assign))
         {
             assignment = ParseExpression();
         }
 
-        return new VariableDeclarationNode(GetTokensForNode(startIndex), name, type, assignment);
+        return new VariableDeclarationNode(GetTokensForNode(startIndex), name, explicitType, assignment);
     }
 
     private static StatementNode ParseBreak(int startIndex)
@@ -632,7 +636,7 @@ public static class Parser
                     .Build());
             }
 
-            return new NubStructType(@namespace , name.Value);
+            return new NubStructType(@namespace, name.Value);
         }
 
         if (TryExpectSymbol(Symbol.Caret))
@@ -685,7 +689,7 @@ public static class Parser
             .WithHelp("Expected type name, '^' for pointer, or '[]' for array")
             .At(peekToken)
             .Build());
-}
+    }
 
     private static Token ExpectToken()
     {

src/compiler/Syntax/Typing/Binder.cs

@@ -188,13 +188,29 @@ public static class Binder
 
     private static BoundVariableDeclarationNode BindVariableDeclaration(VariableDeclarationNode statement)
     {
-        _variables[statement.Name] = statement.Type;
+        NubType? type = null;
+
+        if (statement.ExplicitType.HasValue)
+        {
+            type = statement.ExplicitType.Value;
+        }
+
         var assignment = Optional<BoundExpressionNode>.Empty();
         if (statement.Assignment.HasValue)
         {
-            assignment = BindExpression(statement.Assignment.Value);
+            var boundValue = BindExpression(statement.Assignment.Value, type);
+            assignment = boundValue;
+            type = boundValue.Type;
         }
-        return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, statement.Type, assignment);
+
+        if (type == null)
+        {
+            throw new NotImplementedException("Diagnostics not implemented");
+        }
+
+        _variables[statement.Name] = type;
+
+        return new BoundVariableDeclarationNode(statement.Tokens, statement.Name, statement.ExplicitType, assignment, type);
     }
 
     private static BoundWhileNode BindWhile(WhileNode statement)
@@ -254,8 +270,7 @@ public static class Binder
 
     private static BoundArrayInitializerNode BindArrayInitializer(ArrayInitializerNode expression)
     {
-        return new BoundArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, NubPrimitiveType.U64),
+        return new BoundArrayInitializerNode(expression.Tokens, new NubArrayType(expression.ElementType), BindExpression(expression.Capacity, NubPrimitiveType.U64), expression.ElementType);
-            expression.ElementType);
     }
 
     private static BoundBinaryExpressionNode BindBinaryExpression(BinaryExpressionNode expression)

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, Optional<BoundExpressionNode> Assignment) : BoundStatementNode(Tokens);
+public record BoundVariableDeclarationNode(IEnumerable<Token> Tokens, string Name, Optional<NubType> ExplicitType, Optional<BoundExpressionNode> Assignment, NubType Type) : 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);