Add new bundling testcases and remove old, failing ones

Author: tetektoza

tests/expectations/compiler/async_blocks/too_many_captures_fail.out

@@ -0,0 +1,71 @@
+program test.aleo {
+    struct Position {
+        x: u32,
+        y: u32,
+    }
+
+    struct Entity {
+        pos: Position,
+        health: u32,
+    }
+
+    // Test capturing complex types (nested structs, arrays) with bundling
+    async transition main() -> Future {
+        let entity1 = Entity {
+            pos: Position { x: 10u32, y: 20u32 },
+            health: 100u32,
+        };
+        
+        let entity2 = Entity {
+            pos: Position { x: 30u32, y: 40u32 },
+            health: 80u32,
+        };
+        
+        let arr1 = [1u32, 2u32, 3u32];
+        let arr2 = [4u32, 5u32, 6u32];
+        let arr3 = [7u32, 8u32, 9u32];
+        
+        // Additional scalars to push over 16 captures
+        let s0 = 0u32;
+        let s1 = 1u32;
+        let s2 = 2u32;
+        let s3 = 3u32;
+        let s4 = 4u32;
+        let s5 = 5u32;
+        let s6 = 6u32;
+        let s7 = 7u32;
+        let s8 = 8u32;
+        let s9 = 9u32;
+        let s10 = 10u32;
+        let s11 = 11u32;
+        let s12 = 12u32;
+        let s13 = 13u32;
+        let s14 = 14u32;
+        let s15 = 15u32;
+        let s16 = 16u32;
+        let s17 = 17u32;
+
+        // Total captures: 2 entities + 3 arrays + 18 scalars = 23 captures
+        // Should create 1 bundle with 7 fields
+        let f = async {
+            // Use nested struct fields
+            assert_eq(entity1.pos.x, 10u32);
+            assert_eq(entity1.pos.y, 20u32);
+            assert_eq(entity1.health, 100u32);
+            assert_eq(entity2.pos.x, 30u32);
+            assert_eq(entity2.health, 80u32);
+            
+            // Use arrays
+            assert_eq(arr1[0u32], 1u32);
+            assert_eq(arr2[1u32], 5u32);
+            assert_eq(arr3[2u32], 9u32);
+            
+            // Use scalars
+            let scalar_sum = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 
+                           + s10 + s11 + s12 + s13 + s14 + s15 + s16 + s17;
+            assert_eq(scalar_sum, 153u32);
+        };
+        return f;
+    }
+}
+

tests/tests/compiler/async_blocks/capture_complex_types_bundled.leo

@@ -0,0 +1,63 @@
+program test.aleo {
+    // Test multiple async transition functions with bundling
+    // Ensures synthetic struct names don't collide across different functions
+    async transition first() -> Future {
+        // First set of variables for first async block
+        let a0 = 0u32;
+        let a1 = 1u32;
+        let a2 = 2u32;
+        let a3 = 3u32;
+        let a4 = 4u32;
+        let a5 = 5u32;
+        let a6 = 6u32;
+        let a7 = 7u32;
+        let a8 = 8u32;
+        let a9 = 9u32;
+        let a10 = 10u32;
+        let a11 = 11u32;
+        let a12 = 12u32;
+        let a13 = 13u32;
+        let a14 = 14u32;
+        let a15 = 15u32;
+        let a16 = 16u32;
+
+        // Async block with 17 captures
+        let f = async {
+            let sum1 = a0 + a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9
+                     + a10 + a11 + a12 + a13 + a14 + a15 + a16;
+            assert_eq(sum1, 136u32);
+        };
+        return f;
+    }
+
+    async transition second() -> Future {
+        // Second set of variables for second async transition
+        let b0 = 20u32;
+        let b1 = 21u32;
+        let b2 = 22u32;
+        let b3 = 23u32;
+        let b4 = 24u32;
+        let b5 = 25u32;
+        let b6 = 26u32;
+        let b7 = 27u32;
+        let b8 = 28u32;
+        let b9 = 29u32;
+        let b10 = 30u32;
+        let b11 = 31u32;
+        let b12 = 32u32;
+        let b13 = 33u32;
+        let b14 = 34u32;
+        let b15 = 35u32;
+        let b16 = 36u32;
+        let b17 = 37u32;
+
+        // Second async block with 18 captures
+        let f = async {
+            let sum2 = b0 + b1 + b2 + b3 + b4 + b5 + b6 + b7 + b8 + b9
+                     + b10 + b11 + b12 + b13 + b14 + b15 + b16 + b17;
+            assert_eq(sum2, 513u32);
+        };
+        return f;
+    }
+}
+

tests/tests/compiler/async_blocks/capture_multiple_async_bundled.leo

@@ -0,0 +1,122 @@
+program test.aleo {
+    struct Point {
+        x: u32,
+        y: u32,
+    }
+
+    struct Color {
+        r: u8,
+        g: u8,
+        b: u8,
+    }
+
+    struct Entity {
+        id: u32,
+        health: u32,
+        active: bool,
+    }
+
+    // Stresss test with a mx of structs, tuples, arrays, and scalars with 50+ captures
+    async transition main() -> Future {
+        // 10 Point structs
+        let p0 = Point { x: 0u32, y: 10u32 };
+        let p1 = Point { x: 1u32, y: 11u32 };
+        let p2 = Point { x: 2u32, y: 12u32 };
+        let p3 = Point { x: 3u32, y: 13u32 };
+        let p4 = Point { x: 4u32, y: 14u32 };
+        let p5 = Point { x: 5u32, y: 15u32 };
+        let p6 = Point { x: 6u32, y: 16u32 };
+        let p7 = Point { x: 7u32, y: 17u32 };
+        let p8 = Point { x: 8u32, y: 18u32 };
+        let p9 = Point { x: 9u32, y: 19u32 };
+
+        // 5 Color structs
+        let c0 = Color { r: 255u8, g: 0u8, b: 0u8 };
+        let c1 = Color { r: 0u8, g: 255u8, b: 0u8 };
+        let c2 = Color { r: 0u8, g: 0u8, b: 255u8 };
+        let c3 = Color { r: 128u8, g: 128u8, b: 0u8 };
+        let c4 = Color { r: 0u8, g: 128u8, b: 128u8 };
+
+        // 5 Entity structs
+        let e0 = Entity { id: 100u32, health: 100u32, active: true };
+        let e1 = Entity { id: 101u32, health: 80u32, active: true };
+        let e2 = Entity { id: 102u32, health: 60u32, active: false };
+        let e3 = Entity { id: 103u32, health: 40u32, active: true };
+        let e4 = Entity { id: 104u32, health: 20u32, active: false };
+
+        // 5 tuples
+        let t0 = (0u32, 1u32);
+        let t1 = (2u32, 3u32);
+        let t2 = (4u32, 5u32);
+        let t3 = (6u32, 7u32);
+        let t4 = (8u32, 9u32);
+
+        // 3 arrays
+        let arr0 = [10u32, 11u32, 12u32];
+        let arr1 = [13u32, 14u32, 15u32];
+        let arr2 = [16u32, 17u32, 18u32];
+
+        // 20 scalar u32 variables
+        let s0 = 0u32;
+        let s1 = 1u32;
+        let s2 = 2u32;
+        let s3 = 3u32;
+        let s4 = 4u32;
+        let s5 = 5u32;
+        let s6 = 6u32;
+        let s7 = 7u32;
+        let s8 = 8u32;
+        let s9 = 9u32;
+        let s10 = 10u32;
+        let s11 = 11u32;
+        let s12 = 12u32;
+        let s13 = 13u32;
+        let s14 = 14u32;
+        let s15 = 15u32;
+        let s16 = 16u32;
+        let s17 = 17u32;
+        let s18 = 18u32;
+        let s19 = 19u32;
+
+        // Total: 10 Points + 5 Colors + 5 Entities + 5 Tuples + 3 Arrays + 20 Scalars = 48 captures
+        // This will require multiple bundle structs
+        let f = async {
+            // Use Point structs
+            let sum_x = p0.x + p1.x + p2.x + p3.x + p4.x + p5.x + p6.x + p7.x + p8.x + p9.x;
+            let sum_y = p0.y + p1.y + p2.y + p3.y + p4.y + p5.y + p6.y + p7.y + p8.y + p9.y;
+            
+            // Use Color structs
+            let sum_r = (c0.r as u32) + (c1.r as u32) + (c2.r as u32) + (c3.r as u32) + (c4.r as u32);
+            let sum_g = (c0.g as u32) + (c1.g as u32) + (c2.g as u32) + (c3.g as u32) + (c4.g as u32);
+            
+            // Use Entity structs
+            let sum_health = e0.health + e1.health + e2.health + e3.health + e4.health;
+            let active_count = (e0.active ? 1u32 : 0u32) + (e1.active ? 1u32 : 0u32) 
+                             + (e2.active ? 1u32 : 0u32) + (e3.active ? 1u32 : 0u32) 
+                             + (e4.active ? 1u32 : 0u32);
+            
+            // Use tuples
+            let sum_tuples = t0.0 + t0.1 + t1.0 + t1.1 + t2.0 + t2.1 + t3.0 + t3.1 + t4.0 + t4.1;
+            
+            // Use arrays
+            let sum_arrays = arr0[0u32] + arr0[1u32] + arr1[0u32] + arr1[1u32] + arr2[0u32] + arr2[1u32];
+            
+            // Use scalars
+            let sum_scalars = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9
+                            + s10 + s11 + s12 + s13 + s14 + s15 + s16 + s17 + s18 + s19;
+            
+            // Verify all values
+            assert_eq(sum_x, 45u32);
+            assert_eq(sum_y, 145u32);
+            assert_eq(sum_r, 511u32);
+            assert_eq(sum_g, 511u32);
+            assert_eq(sum_health, 300u32);
+            assert_eq(active_count, 3u32);
+            assert_eq(sum_tuples, 45u32);
+            assert_eq(sum_arrays, 81u32);
+            assert_eq(sum_scalars, 190u32);
+        };
+        return f;
+    }
+}
+

tests/tests/compiler/async_blocks/capture_stress_test_bundled.leo

@@ -0,0 +1,49 @@
+program test.aleo {
+    struct Data {
+        amount: u32,
+        count: u32,
+        flag: bool,
+    }
+
+    // Test capturing individual struct fields (similar to tuple fields)
+    // Each field access counts as a separate capture
+    async transition main() -> Future {
+        let d1 = Data { amount: 1u32, count: 10u32, flag: true };
+        let d2 = Data { amount: 2u32, count: 20u32, flag: false };
+        let d3 = Data { amount: 3u32, count: 30u32, flag: true };
+        let d4 = Data { amount: 4u32, count: 40u32, flag: false };
+        let d5 = Data { amount: 5u32, count: 50u32, flag: true };
+        let d6 = Data { amount: 6u32, count: 60u32, flag: false };
+        let d7 = Data { amount: 7u32, count: 70u32, flag: true };
+        let d8 = Data { amount: 8u32, count: 80u32, flag: false };
+        let d9 = Data { amount: 9u32, count: 90u32, flag: true };
+        let d10 = Data { amount: 10u32, count: 100u32, flag: false };
+        let d11 = Data { amount: 11u32, count: 110u32, flag: true };
+        
+        let s0 = 0u32;
+        let s1 = 1u32;
+        let s2 = 2u32;
+        let s3 = 3u32;
+        let s4 = 4u32;
+        let s5 = 5u32;
+
+        // Total: 11 structs + 6 scalars = 17 captures
+        // Should trigger bundling of 1 variable
+        let f = async {
+            let sum_amounts = d1.amount + d2.amount + d3.amount + d4.amount + d5.amount + d6.amount
+                            + d7.amount + d8.amount + d9.amount + d10.amount + d11.amount;
+            let sum_counts = d1.count + d2.count + d3.count + d4.count + d5.count + d6.count
+                           + d7.count + d8.count + d9.count + d10.count + d11.count;
+            let all_flags = d1.flag && !d2.flag && d3.flag && !d4.flag && d5.flag && !d6.flag
+                          && d7.flag && !d8.flag && d9.flag && !d10.flag && d11.flag;
+            let scalar_sum = s0 + s1 + s2 + s3 + s4 + s5;
+            
+            assert_eq(sum_amounts, 66u32);
+            assert_eq(sum_counts, 660u32);
+            assert(all_flags);
+            assert_eq(scalar_sum, 15u32);
+        };
+        return f;
+    }
+}
+

tests/tests/compiler/async_blocks/capture_struct_fields_bundled.leo

@@ -0,0 +1,28 @@
+program test.aleo {
+    // Test capturing tuple fields that require bundling
+    // Tuple fields count as individual captures
+    async transition main() -> Future {
+        let tuple1 = (1u32, 2u32, 3u32, 4u32);
+        let tuple2 = (5u32, 6u32, 7u32, 8u32);
+        let tuple3 = (9u32, 10u32, 11u32, 12u32);
+        let tuple4 = (13u32, 14u32, 15u32, 16u32);
+        let tuple5 = (17u32, 18u32, 19u32, 20u32);
+        let tuple6 = (21u32, 22u32, 23u32);
+        let a = 100u32;
+        let b = 200u32;
+
+        // Captures: 4+4+4+4+4+3 tuple fields + 2 scalars = 25 total
+        // Should create 1 bundle with 9 fields
+        let f = async {
+            let sum = tuple1.0 + tuple1.1 + tuple1.2 + tuple1.3
+                    + tuple2.0 + tuple2.1 + tuple2.2 + tuple2.3
+                    + tuple3.0 + tuple3.1 + tuple3.2 + tuple3.3
+                    + tuple4.0 + tuple4.1 + tuple4.2 + tuple4.3
+                    + tuple5.0 + tuple5.1 + tuple5.2 + tuple5.3
+                    + tuple6.0 + tuple6.1 + tuple6.2;
+            assert_eq(sum + a + b, 576u32);
+        };
+        return f;
+    }
+}
+