Merge branch 'main' into pr-109

8 files changed, 70 insertions, 28 deletions

diff --git a/tests/generics/test_generic_empty_struct.zc b/tests/generics/test_generic_empty_struct.zc
index f3e3c39..40a691a 100644
--- a/tests/generics/test_generic_empty_struct.zc
+++ b/tests/generics/test_generic_empty_struct.zc
@@ -65,7 +65,7 @@ impl Stack<T> {
 
   fn pop(self) -> Optional<T> {
     if (self.len > 0) {
-      var result = Optional<T>{};
+      let result = Optional<T>{};
       result.emplace(self.data[self.len - 1]);
       self.len = self.len - 1;
       return result;
@@ -75,10 +75,10 @@ impl Stack<T> {
 }
 
 test "Generic Empty Struct Init" {
-  var s = Stack<i32>{};
+  let s = Stack<i32>{};
   defer s.free();
   s.push(123);
-  var result = s.pop();
+  let result = s.pop();
   
   assert(result.has_value(), "Result should have value");
   assert(result.get() == 123, "Result value should be 123");
diff --git a/tests/generics/test_generic_operators.zc b/tests/generics/test_generic_operators.zc
index 8578d50..cd73999 100644
--- a/tests/generics/test_generic_operators.zc
+++ b/tests/generics/test_generic_operators.zc
@@ -13,9 +13,9 @@ impl Foo<T> {
 }
 
 test "generic neq" {
-  var f1 = Foo<i32>{value: 10};
-  var f2 = Foo<i32>{value: 20};
-  var f3 = Foo<i32>{value: 10};
+  let f1 = Foo<i32>{value: 10};
+  let f2 = Foo<i32>{value: 20};
+  let f3 = Foo<i32>{value: 10};
   
   assert(f1 != f2, "f1 should not equal f2");
   assert(f1 == f3, "f1 should equal f3");
diff --git a/tests/generics/test_generic_ptr.zc b/tests/generics/test_generic_ptr.zc
index e08caba..fdcb9db 100644
--- a/tests/generics/test_generic_ptr.zc
+++ b/tests/generics/test_generic_ptr.zc
@@ -4,15 +4,15 @@ import "std/result.zc"
 test "generic pointer instantiation" {
     
     // Vector of ints (internally int*) nested in Result
-    var v = Vec<int>::new();
+    let v = Vec<int>::new();
     v.push(10);
     v.push(20);
     v.push(30);
 
-    var res = Result<Vec<int>>::Ok(v);
+    let res = Result<Vec<int>>::Ok(v);
     
     // Test unwrapping (signatures involving int*)
-    var unwrapped = res.unwrap_ref();
+    let unwrapped = res.unwrap_ref();
     assert(unwrapped.get(0) == 10);
     assert(unwrapped.get(1) == 20);
     assert(unwrapped.get(2) == 30);
@@ -23,15 +23,15 @@ test "generic pointer instantiation" {
 test "generic pointer double nesting" {
     // Double nesting - Result<Vec<int*>>
     
-    var v_ptr = Vec<int*>::new();
-    var a: int = 100;
-    var b: int = 200;
+    let v_ptr = Vec<int*>::new();
+    let a: int = 100;
+    let b: int = 200;
     
     v_ptr.push(&a);
     v_ptr.push(&b);
     
-    var res_ptr = Result<Vec<int*>>::Ok(v_ptr);
-    var unwrapped_ptr = res_ptr.unwrap();
+    let res_ptr = Result<Vec<int*>>::Ok(v_ptr);
+    let unwrapped_ptr = res_ptr.unwrap();
     
     assert(*unwrapped_ptr.get(0) == 100);
     assert(*unwrapped_ptr.get(1) == 200);
diff --git a/tests/generics/test_generic_traits.zc b/tests/generics/test_generic_traits.zc
new file mode 100644
index 0000000..5e83f25
--- /dev/null
+++ b/tests/generics/test_generic_traits.zc
@@ -0,0 +1,42 @@
+
+trait MyClone {
+    fn my_clone(self) -> int;
+}
+
+struct GBox<T> {
+    val: T;
+}
+
+impl MyClone for GBox<T> {
+    fn my_clone(self) -> int {
+        return 1;
+    }
+}
+
+test "generic_trait_method_resolution" {
+    let b = GBox<int>{ val: 10 };
+    let res = b.my_clone();
+    assert(res == 1, "Generic trait method call failed");
+}
+
+trait ValueProvider {
+    fn get_value(self) -> int;
+}
+
+struct Wrapper<T> {
+    inner: T;
+}
+
+impl ValueProvider for Wrapper<T> {
+    fn get_value(self) -> int {
+        return 42;
+    }
+}
+
+test "generic_trait_resolution_complex" {
+    let w = Wrapper<bool>{ inner: true };
+    assert(w.get_value() == 42, "Wrapper<bool> trait call failed");
+    
+    let w2 = Wrapper<int>{ inner: 100 };
+    assert(w2.get_value() == 42, "Wrapper<int> trait call failed");
+}
diff --git a/tests/generics/test_generics_fn.zc b/tests/generics/test_generics_fn.zc
index 03f751a..9343004 100644
--- a/tests/generics/test_generics_fn.zc
+++ b/tests/generics/test_generics_fn.zc
@@ -16,11 +16,11 @@ impl Box<T> {
 
 test "Generics" {
     // Generic Function
-    var i = identity<int>(42);
+    let i = identity<int>(42);
     assert(i == 42, "Generic function failed");
 
     // Generic Struct & Impl
-    var b = Box<int> { val: 100 };
+    let b = Box<int> { val: 100 };
     assert(b.get() == 100, "Generic impl failed");
 }
 
@@ -33,7 +33,7 @@ impl Container {
 }
 
 test "Generic Method in Regular Impl" {
-    var c = Container{};
+    let c = Container{};
     assert(c.check_size<int>(10) == sizeof(int), "Generic method int size");
     assert(c.check_size<double>(3.14) == sizeof(double), "Generic method double size");
 }
diff --git a/tests/generics/test_generics_struct.zc b/tests/generics/test_generics_struct.zc
index 58c2cd3..4a7a5c3 100644
--- a/tests/generics/test_generics_struct.zc
+++ b/tests/generics/test_generics_struct.zc
@@ -6,7 +6,7 @@ struct Wrapper<T> {
 
 test "test_generics_struct" {
     // Instantiate with int
-    var w1: Wrapper<int>;
+    let w1: Wrapper<int>;
     w1.id = 1;
     w1.item = 500;
     
diff --git a/tests/generics/test_multi_generics.zc b/tests/generics/test_multi_generics.zc
index 00d735e..d29556c 100644
--- a/tests/generics/test_multi_generics.zc
+++ b/tests/generics/test_multi_generics.zc
@@ -21,7 +21,7 @@ fn make_triple<X, Y, Z>(x: X, y: Y, z: Z) -> Triple<X, Y, Z> {
 }
 
 test "multi-type generics basic" {
-    var p: Pair<int, float>;
+    let p: Pair<int, float>;
     p.first = 42;
     p.second = 3.14;
     assert(p.first == 42, "First field failed");
@@ -29,13 +29,13 @@ test "multi-type generics basic" {
 }
 
 test "generic function with 2 params" {
-    var p = make_pair<int, float>(100, 2.5);
+    let p = make_pair<int, float>(100, 2.5);
     assert(p.first == 100, "Pair first failed");
     println "2-param generic function passed!";
 }
 
 test "generic function with 3 params" {
-    var t = make_triple<int, float, bool>(42, 3.14, true);
+    let t = make_triple<int, float, bool>(42, 3.14, true);
     assert(t.first == 42, "Triple first failed");
     assert(t.third == true, "Triple third failed");
     println "3-param generic function passed!";
diff --git a/tests/generics/test_sizeof_template.zc b/tests/generics/test_sizeof_template.zc
index 8390512..bf4dd51 100644
--- a/tests/generics/test_sizeof_template.zc
+++ b/tests/generics/test_sizeof_template.zc
@@ -3,14 +3,14 @@ struct Struct<T> {
 }
 
 fn hello<T>() {
-    var s = sizeof(Struct<T>);
+    let s = sizeof(Struct<T>);
     println "size: {s}";
 }
 
 test "sizeof template" {
-    var _first: Struct<i32>;
+    let _first: Struct<i32>;
     hello<i32>();
-    var _second: Struct<f64>;
+    let _second: Struct<f64>;
     hello<f64>();
 }
 
@@ -20,9 +20,9 @@ struct Mixed<T> {
 }
 
 test "sizeof mixed" {
-   var s1 = sizeof(Mixed<i32>);
+   let s1 = sizeof(Mixed<i32>);
    println "i32 mixed: {s1}";
-   var s2 = sizeof(Mixed<f64>);
+   let s2 = sizeof(Mixed<f64>);
    println "f64 mixed: {s2}";
 }
 
@@ -33,8 +33,8 @@ struct PackedMixed<T> {
 }
 
 test "sizeof packed mixed" {
-   var s1 = sizeof(PackedMixed<i32>);
+   let s1 = sizeof(PackedMixed<i32>);
    println "i32 packed mixed: {s1}";
-   var s2 = sizeof(PackedMixed<f64>);
+   let s2 = sizeof(PackedMixed<f64>);
    println "f64 packed mixed: {s2}";
 }
\ No newline at end of file