auto type erasure for protocols & struct literal init bloc

examples/50-smoke.sx

@@ -277,6 +277,17 @@ SumBox :: struct ($T: Type/Summable) {
 }
 
 // ============================================================
+// Init block test struct
+Builder :: struct {
+    total: s32;
+    count: s32;
+
+    add :: (self: *Builder, val: s32) {
+        self.total += val;
+        self.count += 1;
+    }
+}
+
 main :: () {
 
     // ========================================================
@@ -2848,5 +2859,100 @@ END;
         print("P3.3: {}\n", result);
     }
 
+    // --- Auto type erasure (AE) ---
+    print("=== Auto Type Erasure ===\n");
+
+    // AE1: function argument — concrete passed where protocol expected (no xx)
+    {
+        use_counter :: (c: Counter) -> s32 { c.inc(); c.inc(); c.get(); }
+        sc := SimpleCounter.{ val = 10 };
+        result := use_counter(sc);
+        print("AE1: {}\n", result);
+    }
+
+    // AE2: variable assignment — concrete to protocol variable (no xx)
+    {
+        acc := Accumulator.{ total = 0 };
+        a: Adder = acc;
+        a.add(5);
+        a.add(3);
+        print("AE2: {}\n", a.value());
+    }
+
+    // AE3: struct literal passed directly (no xx)
+    {
+        use_counter :: (c: Counter) -> s32 { c.inc(); c.inc(); c.get(); }
+        result := use_counter(SimpleCounter.{ val = 100 });
+        print("AE3: {}\n", result);
+    }
+
+    // AE4: explicit xx still works (not broken)
+    {
+        use_counter :: (c: Counter) -> s32 { c.inc(); c.get(); }
+        result := use_counter(xx SimpleCounter.{ val = 50 });
+        print("AE4: {}\n", result);
+    }
+
+    // AE5: pointer auto-erasure — *ConcreteType to protocol
+    {
+        use_adder :: (a: Adder) { a.add(10); }
+        acc := Accumulator.{ total = 5 };
+        p := @acc;
+        use_adder(p);
+        print("AE5: {}\n", acc.total);
+    }
+
+    // --- Init Blocks (IB) ---
+    print("=== Init Blocks ===\n");
+
+    // IB1: basic init block with struct methods
+    {
+        b := Builder.{ total = 0, count = 0 } {
+            self.add(10);
+            self.add(20);
+            self.add(30);
+        };
+        print("IB1: {} {}\n", b.total, b.count);
+    }
+
+    // IB2: nested init blocks (self shadows correctly)
+    {
+        b1 := Builder.{ total = 0, count = 0 } {
+            self.add(100);
+            b2 := Builder.{ total = 0, count = 0 } {
+                self.add(42);
+            };
+            self.add(b2.total);
+        };
+        print("IB2: {} {}\n", b1.total, b1.count);
+    }
+
+    // IB3: empty init block
+    {
+        b := Builder.{ total = 5, count = 1 } {};
+        print("IB3: {} {}\n", b.total, b.count);
+    }
+
+    // IB4: conditional inside init block
+    {
+        add_extra := true;
+        b := Builder.{ total = 0, count = 0 } {
+            self.add(10);
+            if add_extra {
+                self.add(90);
+            }
+        };
+        print("IB4: {}\n", b.total);
+    }
+
+    // IB5: init block + auto type erasure combined
+    {
+        use_counter :: (c: Counter) -> s32 { c.inc(); c.inc(); c.get(); }
+        result := use_counter(SimpleCounter.{ val = 0 } {
+            self.val = 50;
+        });
+        print("IB5: {}\n", result);
+    }
+
     print("=== DONE ===\n");
 }