explicit variable types

example/program.nub

@@ -2,10 +2,7 @@ import c
 
 global func main(argc: i64, argv: i64) {
     printf("args: %d, starts at %p\n", argc, argv)
-    test(12.1)
-    return 23
-}
 
-func test(a: f64) {
-    printf("%f\n", a)
+    x: i8 = 320000
+    printf("%d\n", x)
 }

src/compiler/Nub.Lang/Backend/Generator.cs

@@ -14,6 +14,7 @@ public class Generator
     private readonly Stack<string> _breakLabels = new();
     private readonly Stack<string> _continueLabels = new();
     private bool _codeIsReachable = true;
+    private LocalFuncDefinitionNode? _currentFuncDefininition;
 
     public Generator(List<DefinitionNode> definitions)
     {
@@ -217,6 +218,7 @@ public class Generator
 
     private void GenerateFuncDefinition(LocalFuncDefinitionNode node)
     {
+        _currentFuncDefininition = node;
         _variables.Clear();
 
         if (node.Global)
@@ -288,6 +290,7 @@ public class Generator
         }
 
         _builder.AppendLine("}");
+        _currentFuncDefininition = null;
     }
 
     private void GenerateStructDefinition(StructDefinitionNode structDefinition)
@@ -433,8 +436,14 @@ public class Generator
     {
         if (@return.Value.HasValue)
         {
+            if (!_currentFuncDefininition!.ReturnType.HasValue)
+            {
+                throw new Exception("Cannot return a value when function does not have a return value");
+            }
+            
             var result = GenerateExpression(@return.Value.Value);
-            _builder.AppendLine($"    ret {result}");
+            var converted = GenerateTypeConversion(result, @return.Value.Value.Type, _currentFuncDefininition.ReturnType.Value);
+            _builder.AppendLine($"    ret {converted}");
         }
         else
         {
@@ -445,10 +454,17 @@ public class Generator
     private void GenerateVariableAssignment(VariableAssignmentNode variableAssignment)
     {
         var result = GenerateExpression(variableAssignment.Value);
+        var variableType = variableAssignment.Value.Type;
+        
+        if (variableAssignment.ExplicitType.HasValue)
+        {
+            result = GenerateTypeConversion(result, variableType, variableAssignment.ExplicitType.Value);
+            variableType = variableAssignment.ExplicitType.Value;
+        }
         _variables[variableAssignment.Name] = new Variable
         {
             Identifier = result,
-            Type = variableAssignment.Value.Type
+            Type = variableType
         };
     }
 

src/compiler/Nub.Lang/Frontend/Parsing/Parser.cs

@@ -157,7 +157,14 @@ public class Parser
                     case Symbol.Assign:
                     {
                         var value = ParseExpression();
-                        return new VariableAssignmentNode(identifier.Value, value);
+                        return new VariableAssignmentNode(identifier.Value,  Optional<NubType>.Empty(),  value);
+                    }
+                    case Symbol.Colon:
+                    {
+                        var type = ParseType();
+                        ExpectSymbol(Symbol.Assign);
+                        var value = ParseExpression();
+                        return new VariableAssignmentNode(identifier.Value,type,  value);
                     }
                     default:
                     {

src/compiler/Nub.Lang/Frontend/Parsing/VariableAssignmentNode.cs

@@ -1,7 +1,8 @@
 namespace Nub.Lang.Frontend.Parsing;
 
-public class VariableAssignmentNode(string name, ExpressionNode value) : StatementNode
+public class VariableAssignmentNode(string name, Optional<NubType> explicitType, ExpressionNode value) : StatementNode
 {
     public string Name { get; } = name;
+    public Optional<NubType> ExplicitType { get; } = explicitType;
     public ExpressionNode Value { get; } = value;
 }

src/compiler/Nub.Lang/Frontend/Typing/ExpressionTyper.cs

@@ -143,7 +143,7 @@ public class ExpressionTyper
     private void PopulateVariableAssignment(VariableAssignmentNode variableAssignment)
     {
         PopulateExpression(variableAssignment.Value);
-        _variables.Push(new Variable(variableAssignment.Name, variableAssignment.Value.Type));
+        _variables.Push(new Variable(variableAssignment.Name, variableAssignment.ExplicitType.HasValue ? variableAssignment.ExplicitType.Value : variableAssignment.Value.Type));
     }
 
     private void PopulateVariableReassignment(VariableAssignmentNode variableAssignment)