From d068468e0235af15380445859fb763f7644cc021 Mon Sep 17 00:00:00 2001
From: nub31 <oliverlhs@outlook.com>
Date: Tue, 9 Sep 2025 15:33:33 +0200
Subject: [PATCH] ...

---
 example/src/main.nub                          |  4 +--
 .../NubLang/Generation/QBE/QBEGenerator.cs    |  4 +--
 .../TypeChecking/Node/ExpressionNode.cs       |  4 +--
 .../NubLang/TypeChecking/TypeChecker.cs       | 35 ++++++++-----------
 4 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/example/src/main.nub b/example/src/main.nub
index 100b14b..d93ab1e 100644
--- a/example/src/main.nub
+++ b/example/src/main.nub
@@ -3,11 +3,11 @@ extern func puts(text: cstring)
 
 func main(args: []cstring): i64
 {
-    let x: i32 = 23
+    let x: u32 = 23
     test(x)
     return 0
 }
 
-func test(test: u8)
+func test(test: u32)
 {
 }
\ No newline at end of file
diff --git a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs b/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
index 8cfba73..d0187d3 100644
--- a/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
+++ b/src/compiler/NubLang/Generation/QBE/QBEGenerator.cs
@@ -1124,7 +1124,7 @@ public class QBEGenerator
     {
         var value = EmitExpression(convertInt.Value);
 
-        if (convertInt.ValueType == convertInt.TargetType || convertInt.ValueType.Width > convertInt.TargetType.Width)
+        if (convertInt.ValueType.Width >= convertInt.TargetType.Width)
         {
             return value;
         }
@@ -1156,7 +1156,7 @@ public class QBEGenerator
     {
         var value = EmitExpression(convertFloat.Value);
 
-        if (convertFloat.ValueType == convertFloat.TargetType)
+        if (convertFloat.ValueType.Width == convertFloat.TargetType.Width)
         {
             return value;
         }
diff --git a/src/compiler/NubLang/TypeChecking/Node/ExpressionNode.cs b/src/compiler/NubLang/TypeChecking/Node/ExpressionNode.cs
index b8ca51e..f2a6fb7 100644
--- a/src/compiler/NubLang/TypeChecking/Node/ExpressionNode.cs
+++ b/src/compiler/NubLang/TypeChecking/Node/ExpressionNode.cs
@@ -61,6 +61,6 @@ public record DereferenceNode(TypeNode Type, ExpressionNode Expression) : RValue
 
 public record InterfaceInitializerNode(TypeNode Type, InterfaceTypeNode InterfaceType, StructTypeNode StructType, ExpressionNode Implementation) : LValueExpressionNode(Type);
 
-public record ConvertIntNode(TypeNode Type, ExpressionNode Value, IntTypeNode TargetType, IntTypeNode ValueType) : RValueExpressionNode(Type);
+public record ConvertIntNode(TypeNode Type, ExpressionNode Value, IntTypeNode ValueType, IntTypeNode TargetType) : RValueExpressionNode(Type);
 
-public record ConvertFloatNode(TypeNode Type, ExpressionNode Value, FloatTypeNode TargetType, FloatTypeNode ValueType) : RValueExpressionNode(Type);
+public record ConvertFloatNode(TypeNode Type, ExpressionNode Value, FloatTypeNode ValueType, FloatTypeNode TargetType) : RValueExpressionNode(Type);
diff --git a/src/compiler/NubLang/TypeChecking/TypeChecker.cs b/src/compiler/NubLang/TypeChecking/TypeChecker.cs
index 619a21b..9a6872b 100644
--- a/src/compiler/NubLang/TypeChecking/TypeChecker.cs
+++ b/src/compiler/NubLang/TypeChecking/TypeChecker.cs
@@ -286,38 +286,33 @@ public sealed class TypeChecker
             _ => throw new ArgumentOutOfRangeException(nameof(node))
         };
 
-        if (expectedType != null && result.Type != expectedType)
+        if (expectedType == null || result.Type == expectedType)
         {
-            return CheckConversion(expectedType, result);
+            return result;
         }
 
-        return result;
-    }
-
-    private ExpressionNode CheckConversion(TypeNode targetType, ExpressionNode expression)
-    {
-        if (expression.Type is StructTypeNode structType && targetType is InterfaceTypeNode interfaceType)
+        if (result.Type is StructTypeNode structType && expectedType is InterfaceTypeNode interfaceType)
         {
-            return new InterfaceInitializerNode(interfaceType, interfaceType, structType, expression);
+            return new InterfaceInitializerNode(interfaceType, interfaceType, structType, result);
         }
 
-        if (expression.Type is IntTypeNode sourceIntType && targetType is IntTypeNode targetIntType)
+        if (result.Type is IntTypeNode sourceIntType && expectedType is IntTypeNode targetIntType)
         {
-            // if ((sourceIntType.Width < targetIntType.Width) || (sourceIntType.Width == targetIntType.Width && sourceIntType.Signed != targetIntType.Signed))
-            // {
-                return new ConvertIntNode(targetIntType, expression, targetIntType, sourceIntType);
-            // }
+            if (sourceIntType.Signed == targetIntType.Signed && sourceIntType.Width < targetIntType.Width)
+            {
+                return new ConvertIntNode(targetIntType, result, sourceIntType, targetIntType);
+            }
         }
 
-        if (expression.Type is FloatTypeNode sourceFloatType && targetType is FloatTypeNode targetFloatType)
+        if (result.Type is FloatTypeNode sourceFloatType && expectedType is FloatTypeNode targetFloatType)
         {
-            // if (sourceFloatType.Width < targetFloatType.Width)
-            // {
-                return new ConvertFloatNode(targetFloatType, expression, targetFloatType, sourceFloatType);
-            // }
+            if (sourceFloatType.Width < targetFloatType.Width)
+            {
+                return new ConvertFloatNode(targetFloatType, result, sourceFloatType, targetFloatType);
+            }
         }
 
-        throw new TypeCheckerException(Diagnostic.Error($"Cannot convert {expression.Type} to {targetType}").Build());
+        throw new TypeCheckerException(Diagnostic.Error($"Cannot convert {result.Type} to {expectedType}").Build());
     }
 
     private AddressOfNode CheckAddressOf(AddressOfSyntax expression)