diff --git a/air-script/tests/aux_trace/aux_trace.air b/air-script/tests/aux_trace/aux_trace.air
index c7bf063b..54afccdb 100644
--- a/air-script/tests/aux_trace/aux_trace.air
+++ b/air-script/tests/aux_trace/aux_trace.air
@@ -1,16 +1,16 @@
 def AuxiliaryAir
 
 trace_columns {
-    main: [a, b, c]
-    aux: [p0, p1]
+    main: [a, b, c];
+    aux: [p0, p1];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 random_values {
-    rand: [2]
+    rand: [2];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/binary/binary.air b/air-script/tests/binary/binary.air
index 5ba1526c..71fe0c4e 100644
--- a/air-script/tests/binary/binary.air
+++ b/air-script/tests/binary/binary.air
@@ -1,11 +1,11 @@
 def BinaryAir
 
 trace_columns {
-    main: [a, b]
+    main: [a, b];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/bitwise/bitwise.air b/air-script/tests/bitwise/bitwise.air
index c35f2a9b..c41864d6 100644
--- a/air-script/tests/bitwise/bitwise.air
+++ b/air-script/tests/bitwise/bitwise.air
@@ -1,16 +1,16 @@
 def BitwiseAir
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 trace_columns {
-    main: [s, a, b, a0, a1, a2, a3, b0, b1, b2, b3, zp, z, dummy]
+    main: [s, a, b, a0, a1, a2, a3, b0, b1, b2, b3, zp, z, dummy];
 }
 
 periodic_columns {
-    k0: [1, 0, 0, 0, 0, 0, 0, 0]
-    k1: [1, 1, 1, 1, 1, 1, 1, 0]
+    k0: [1, 0, 0, 0, 0, 0, 0, 0];
+    k1: [1, 1, 1, 1, 1, 1, 1, 0];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/constants/constants.air b/air-script/tests/constants/constants.air
index 46293a9d..c31fe2ef 100644
--- a/air-script/tests/constants/constants.air
+++ b/air-script/tests/constants/constants.air
@@ -5,15 +5,15 @@ const B = [0, 1];
 const C = [[1, 2], [2, 0]];
 
 trace_columns {
-    main: [a, b, c, d]
-    aux: [e, f, g]
+    main: [a, b, c, d];
+    aux: [e, f, g];
 }
 
 public_inputs {
-    program_hash: [4]
-    stack_inputs: [4]
-    stack_outputs: [20]
-    overflow_addrs: [4]
+    program_hash: [4];
+    stack_inputs: [4];
+    stack_outputs: [20];
+    overflow_addrs: [4];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/constraint_comprehension/cc_with_evaluators.air b/air-script/tests/constraint_comprehension/cc_with_evaluators.air
index 6d08e7a9..ac0a72b8 100644
--- a/air-script/tests/constraint_comprehension/cc_with_evaluators.air
+++ b/air-script/tests/constraint_comprehension/cc_with_evaluators.air
@@ -5,12 +5,12 @@ ev are_equal([], [x, y]) {
 }
 
 trace_columns {
-    main: [clk, fmp[2], ctx]
-    aux: [a, b, c[4], d[4]]
+    main: [clk, fmp[2], ctx];
+    aux: [a, b, c[4], d[4]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/constraint_comprehension/constraint_comprehension.air b/air-script/tests/constraint_comprehension/constraint_comprehension.air
index 5c9eb3c8..dd43e77a 100644
--- a/air-script/tests/constraint_comprehension/constraint_comprehension.air
+++ b/air-script/tests/constraint_comprehension/constraint_comprehension.air
@@ -1,12 +1,12 @@
 def ConstraintComprehensionAir
 
 trace_columns {
-    main: [clk, fmp[2], ctx]
-    aux: [a, b, c[4], d[4]]
+    main: [clk, fmp[2], ctx];
+    aux: [a, b, c[4], d[4]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/evaluators/evaluators.air b/air-script/tests/evaluators/evaluators.air
index 657f6b42..3703a48f 100644
--- a/air-script/tests/evaluators/evaluators.air
+++ b/air-script/tests/evaluators/evaluators.air
@@ -15,11 +15,11 @@ ev are_all_binary([c[3]]) {
 }
 
 trace_columns {
-    main: [b, c[3], d[3]]
+    main: [b, c[3], d[3]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/indexed_trace_access/indexed_trace_access.air b/air-script/tests/indexed_trace_access/indexed_trace_access.air
index 1103d8b6..216a7eb2 100644
--- a/air-script/tests/indexed_trace_access/indexed_trace_access.air
+++ b/air-script/tests/indexed_trace_access/indexed_trace_access.air
@@ -1,12 +1,12 @@
 def TraceAccessAir
 
 trace_columns {
-    main: [a, b]
-    aux: [c, d]
+    main: [a, b];
+    aux: [c, d];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 integrity_constraints {
diff --git a/air-script/tests/list_comprehension/list_comprehension.air b/air-script/tests/list_comprehension/list_comprehension.air
index 38cac435..b1da7890 100644
--- a/air-script/tests/list_comprehension/list_comprehension.air
+++ b/air-script/tests/list_comprehension/list_comprehension.air
@@ -1,12 +1,12 @@
 def ListComprehensionAir
 
 trace_columns {
-    main: [clk, fmp[2], ctx]
-    aux: [a, b[3], c[4], d[4]]
+    main: [clk, fmp[2], ctx];
+    aux: [a, b[3], c[4], d[4]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/list_folding/list_folding.air b/air-script/tests/list_folding/list_folding.air
index 8ab7d796..38ab527a 100644
--- a/air-script/tests/list_folding/list_folding.air
+++ b/air-script/tests/list_folding/list_folding.air
@@ -1,12 +1,12 @@
 def ListFoldingAir
 
 trace_columns {
-    main: [clk, fmp[2], ctx]
-    aux: [a, b[4], c[4], d[4]]
+    main: [clk, fmp[2], ctx];
+    aux: [a, b[4], c[4], d[4]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/periodic_columns/periodic_columns.air b/air-script/tests/periodic_columns/periodic_columns.air
index 06dddc5e..c3b1136e 100644
--- a/air-script/tests/periodic_columns/periodic_columns.air
+++ b/air-script/tests/periodic_columns/periodic_columns.air
@@ -1,16 +1,16 @@
 def PeriodicColumnsAir
 
 trace_columns {
-    main: [a, b, c]
+    main: [a, b, c];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 periodic_columns {
-    k0: [1, 0, 0, 0]
-    k1: [1, 1, 1, 1, 1, 1, 1, 0]
+    k0: [1, 0, 0, 0];
+    k1: [1, 1, 1, 1, 1, 1, 1, 0];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/pub_inputs/pub_inputs.air b/air-script/tests/pub_inputs/pub_inputs.air
index 211fa340..ffd46a92 100644
--- a/air-script/tests/pub_inputs/pub_inputs.air
+++ b/air-script/tests/pub_inputs/pub_inputs.air
@@ -1,14 +1,14 @@
 def PubInputsAir
 
 trace_columns {
-    main: [a, b, c, d]
+    main: [a, b, c, d];
 }
 
 public_inputs {
-    program_hash: [4]
-    stack_inputs: [4]
-    stack_outputs: [20]
-    overflow_addrs: [4]
+    program_hash: [4];
+    stack_inputs: [4];
+    stack_outputs: [20];
+    overflow_addrs: [4];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/random_values/random_values_bindings.air b/air-script/tests/random_values/random_values_bindings.air
index 6c464c83..40e726f0 100644
--- a/air-script/tests/random_values/random_values_bindings.air
+++ b/air-script/tests/random_values/random_values_bindings.air
@@ -1,16 +1,16 @@
 def RandomValuesAir
 
 trace_columns {
-    main: [a, b]
-    aux: [c, d]
+    main: [a, b];
+    aux: [c, d];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 random_values {
-    alphas: [x, y[14], z]
+    alphas: [x, y[14], z];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/random_values/random_values_simple.air b/air-script/tests/random_values/random_values_simple.air
index 35267e31..e58e6614 100644
--- a/air-script/tests/random_values/random_values_simple.air
+++ b/air-script/tests/random_values/random_values_simple.air
@@ -1,16 +1,16 @@
 def RandomValuesAir
 
 trace_columns {
-    main: [a, b]
-    aux: [c, d]
+    main: [a, b];
+    aux: [c, d];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 random_values {
-    rand: [16]
+    rand: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/selectors/selectors.air b/air-script/tests/selectors/selectors.air
index cf86b952..2e85e523 100644
--- a/air-script/tests/selectors/selectors.air
+++ b/air-script/tests/selectors/selectors.air
@@ -1,11 +1,11 @@
 def SelectorsAir
 
 trace_columns {
-    main: [s[3], clk]
+    main: [s[3], clk];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/selectors/selectors_with_evaluators.air b/air-script/tests/selectors/selectors_with_evaluators.air
index b5f10b8b..7f025dc5 100644
--- a/air-script/tests/selectors/selectors_with_evaluators.air
+++ b/air-script/tests/selectors/selectors_with_evaluators.air
@@ -13,11 +13,11 @@ ev next_is_one([clk]) {
 }
 
 trace_columns {
-    main: [s[3], clk]
+    main: [s[3], clk];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/air-script/tests/system/system.air b/air-script/tests/system/system.air
index 56279611..03b8a69e 100644
--- a/air-script/tests/system/system.air
+++ b/air-script/tests/system/system.air
@@ -1,11 +1,11 @@
 def SystemAir
 
 trace_columns {
-    main: [clk, fmp, ctx]
+    main: [clk, fmp, ctx];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 integrity_constraints {
diff --git a/air-script/tests/trace_col_groups/trace_col_groups.air b/air-script/tests/trace_col_groups/trace_col_groups.air
index a01de892..c528613d 100644
--- a/air-script/tests/trace_col_groups/trace_col_groups.air
+++ b/air-script/tests/trace_col_groups/trace_col_groups.air
@@ -1,12 +1,12 @@
 def TraceColGroupAir
 
 trace_columns {
-    main: [clk, fmp[2], ctx]
-    aux: [a, b, c[3]]
+    main: [clk, fmp[2], ctx];
+    aux: [a, b, c[3]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 integrity_constraints {
diff --git a/air-script/tests/variables/variables.air b/air-script/tests/variables/variables.air
index 3dc9bcbc..a6ed055a 100644
--- a/air-script/tests/variables/variables.air
+++ b/air-script/tests/variables/variables.air
@@ -3,21 +3,21 @@
 def VariablesAir
 
 trace_columns {
-    main: [s, a, b, c]
-    aux: [p]
+    main: [s, a, b, c];
+    aux: [p];
 }
 
 public_inputs {
-    stack_inputs: [16]
-    stack_outputs: [16]
+    stack_inputs: [16];
+    stack_outputs: [16];
 }
 
 periodic_columns {
-    k0: [1, 1, 1, 1, 1, 1, 1, 0]
+    k0: [1, 1, 1, 1, 1, 1, 1, 0];
 }
 
 random_values {
-    rand: [1]
+    rand: [1];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_aux.rs b/codegen/masm/tests/test_aux.rs
index 70c34325..c9a19029 100644
--- a/codegen/masm/tests/test_aux.rs
+++ b/codegen/masm/tests/test_aux.rs
@@ -12,12 +12,12 @@ static SIMPLE_AUX_AIR: &str = "
 def SimpleAux
 
 trace_columns {
-    main: [a]
-    aux: [b]
+    main: [a];
+    aux: [b];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_basic_arithmetic.rs b/codegen/masm/tests/test_basic_arithmetic.rs
index da47fd37..0e82ab21 100644
--- a/codegen/masm/tests/test_basic_arithmetic.rs
+++ b/codegen/masm/tests/test_basic_arithmetic.rs
@@ -12,11 +12,11 @@ static ARITH_AIR: &str = "
 def SimpleArithmetic
 
 trace_columns {
-    main: [a, b]
+    main: [a, b];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
@@ -104,11 +104,11 @@ static EXP_AIR: &str = "
 def Exp
 
 trace_columns {
-    main: [a, b]
+    main: [a, b];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
@@ -193,11 +193,11 @@ static LONG_TRACE: &str = "
 def LongTrace
 
 trace_columns {
-    main: [a, b, c, d, e, f, g, h, i]
+    main: [a, b, c, d, e, f, g, h, i];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
@@ -275,11 +275,11 @@ static VECTOR: &str = "
 def Vector
 
 trace_columns {
-    main: [clk, fmp[2]]
+    main: [clk, fmp[2]];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
@@ -355,11 +355,11 @@ static MULTIPLE_ROWS_AIR: &str = "
 def MultipleRows
 
 trace_columns {
-    main: [a, b]
+    main: [a, b];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_boundary.rs b/codegen/masm/tests/test_boundary.rs
index d792c4b3..d74e94f0 100644
--- a/codegen/masm/tests/test_boundary.rs
+++ b/codegen/masm/tests/test_boundary.rs
@@ -12,11 +12,11 @@ static SIMPLE_BOUNDARY_AIR: &str = "
 def SimpleBoundary
 
 trace_columns {
-    main: [a, b, len]
+    main: [a, b, len];
 }
 
 public_inputs {
-    target: [1]
+    target: [1];
 }
 
 boundary_constraints {
@@ -112,17 +112,17 @@ const B = [0, 1];
 const C = [[1, 2], [2, 0]];
 
 trace_columns {
-    main: [a, b, c, d, e[2]]
-    aux: [f]
+    main: [a, b, c, d, e[2]];
+    aux: [f];
 }
 
 public_inputs {
-    stack_inputs: [2]
-    stack_outputs: [2]
+    stack_inputs: [2];
+    stack_outputs: [2];
 }
 
 random_values {
-    rand: [2]
+    rand: [2];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_constants.rs b/codegen/masm/tests/test_constants.rs
index 2847402e..b88a0bc2 100644
--- a/codegen/masm/tests/test_constants.rs
+++ b/codegen/masm/tests/test_constants.rs
@@ -16,11 +16,11 @@ const B = [3, 5];
 const C = [[7, 11], [13, 17]];
 
 trace_columns {
-    main: [a, b, c]
+    main: [a, b, c];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_divisor.rs b/codegen/masm/tests/test_divisor.rs
index c412e035..f177cfda 100644
--- a/codegen/masm/tests/test_divisor.rs
+++ b/codegen/masm/tests/test_divisor.rs
@@ -13,11 +13,11 @@ static SIMPLE_INTEGRITY_AIR: &str = "
 def SimpleIntegrityAux
 
 trace_columns {
-    main: [a]
+    main: [a];
 }
 
 public_inputs {
-    stack_inputs: [1]
+    stack_inputs: [1];
 }
 
 boundary_constraints {
@@ -97,12 +97,12 @@ static SIMPLE_BOUNDARY_AIR: &str = "
 def SimpleBoundaryAux
 
 trace_columns {
-    main: [a]
-    aux: [b]
+    main: [a];
+    aux: [b];
 }
 
 public_inputs {
-    stack_inputs: [1]
+    stack_inputs: [1];
 }
 
 boundary_constraints {
@@ -218,12 +218,12 @@ static MIXED_BOUNDARY_AIR: &str = "
 def MixedBoundaryAux
 
 trace_columns {
-    main: [a]
-    aux: [b]
+    main: [a];
+    aux: [b];
 }
 
 public_inputs {
-    stack_inputs: [1]
+    stack_inputs: [1];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_exemption_points.rs b/codegen/masm/tests/test_exemption_points.rs
index 013bdc62..c2876ea2 100644
--- a/codegen/masm/tests/test_exemption_points.rs
+++ b/codegen/masm/tests/test_exemption_points.rs
@@ -12,11 +12,11 @@ static SIMPLE_AIR: &str = "
 def Simple
 
 trace_columns {
-    main: [a]
+    main: [a];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/codegen/masm/tests/test_periodic.rs b/codegen/masm/tests/test_periodic.rs
index 49abc204..3ea372e8 100644
--- a/codegen/masm/tests/test_periodic.rs
+++ b/codegen/masm/tests/test_periodic.rs
@@ -12,15 +12,15 @@ static SIMPLE_AUX_AIR: &str = "
 def SimpleAux
 
 trace_columns {
-    main: [a]
+    main: [a];
 }
 
 periodic_columns {
-    k: [1, 1]
+    k: [1, 1];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
@@ -99,17 +99,17 @@ static MULTIPLE_AUX_AIR: &str = "
 def MultipleAux
 
 trace_columns {
-    main: [a, b, c]
+    main: [a, b, c];
 }
 
 periodic_columns {
-    m: [1, 0]
-    n: [1, 1, 1, 0]
-    o: [1, 0, 0, 0]
+    m: [1, 0];
+    n: [1, 1, 1, 0];
+    o: [1, 0, 0, 0];
 }
 
 public_inputs {
-    stack_inputs: [16]
+    stack_inputs: [16];
 }
 
 boundary_constraints {
diff --git a/ir/src/tests/access.rs b/ir/src/tests/access.rs
index bf42eac4..4928af52 100644
--- a/ir/src/tests/access.rs
+++ b/ir/src/tests/access.rs
@@ -9,10 +9,10 @@ fn invalid_vector_access_in_boundary_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = A + B[3] - C[1][2];
@@ -36,10 +36,10 @@ fn invalid_matrix_row_access_in_boundary_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = A + B[1] - C[3][2];
@@ -63,10 +63,10 @@ fn invalid_matrix_column_access_in_boundary_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = A + B[1] - C[1][3];
@@ -90,10 +90,10 @@ fn invalid_vector_access_in_integrity_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -117,10 +117,10 @@ fn invalid_matrix_row_access_in_integrity_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -144,10 +144,10 @@ fn invalid_matrix_column_access_in_integrity_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
diff --git a/ir/src/tests/boundary_constraints.rs b/ir/src/tests/boundary_constraints.rs
index f8645997..f9317d7a 100644
--- a/ir/src/tests/boundary_constraints.rs
+++ b/ir/src/tests/boundary_constraints.rs
@@ -5,10 +5,10 @@ fn boundary_constraints() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -26,10 +26,10 @@ fn err_bc_duplicate_first() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -47,10 +47,10 @@ fn err_bc_duplicate_last() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.last = 0;
diff --git a/ir/src/tests/constant.rs b/ir/src/tests/constant.rs
index 950f30dd..cb13460a 100644
--- a/ir/src/tests/constant.rs
+++ b/ir/src/tests/constant.rs
@@ -8,10 +8,10 @@ fn boundary_constraint_with_constants() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = A;
@@ -32,10 +32,10 @@ fn integrity_constraint_with_constants() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -53,10 +53,10 @@ fn invalid_matrix_constant() {
     def test
     const A = [[2, 3], [1, 0, 2]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
diff --git a/ir/src/tests/evaluators.rs b/ir/src/tests/evaluators.rs
index 27e54467..0ce6995d 100644
--- a/ir/src/tests/evaluators.rs
+++ b/ir/src/tests/evaluators.rs
@@ -9,11 +9,11 @@ fn simple_evaluator() {
     }
     
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -37,11 +37,11 @@ fn evaluator_with_variables() {
     }
     
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -66,12 +66,12 @@ fn evaluator_with_main_and_aux_cols() {
     }
     
     trace_columns {
-        main: [clk]
-        aux: [a, b]
+        main: [clk];
+        aux: [a, b];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -94,12 +94,12 @@ fn ev_call_with_aux_only() {
     }
     
     trace_columns {
-        main: [clk]
-        aux: [a, b]
+        main: [clk];
+        aux: [a, b];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -126,11 +126,11 @@ fn ev_call_inside_evaluator_with_main() {
     }
     
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -162,12 +162,12 @@ fn ev_call_inside_evaluator_with_aux() {
     }
     
     trace_columns {
-        main: [clk]
-        aux: [a, b]
+        main: [clk];
+        aux: [a, b];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -190,11 +190,11 @@ fn ev_fn_call_with_column_group() {
     }
     
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -217,12 +217,12 @@ fn err_ev_fn_call_wrong_segment_columns() {
     }
     
     trace_columns {
-        main: [b]
-        aux: [c]
+        main: [b];
+        aux: [c];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
diff --git a/ir/src/tests/integrity_constraints/comprehension/constraint_comprehension.rs b/ir/src/tests/integrity_constraints/comprehension/constraint_comprehension.rs
index f024f3b0..449fd5dc 100644
--- a/ir/src/tests/integrity_constraints/comprehension/constraint_comprehension.rs
+++ b/ir/src/tests/integrity_constraints/comprehension/constraint_comprehension.rs
@@ -5,11 +5,11 @@ fn constraint_comprehension() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -26,11 +26,11 @@ fn ic_comprehension_with_selectors() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
diff --git a/ir/src/tests/integrity_constraints/comprehension/list_comprehension.rs b/ir/src/tests/integrity_constraints/comprehension/list_comprehension.rs
index 27466ae7..dea749c5 100644
--- a/ir/src/tests/integrity_constraints/comprehension/list_comprehension.rs
+++ b/ir/src/tests/integrity_constraints/comprehension/list_comprehension.rs
@@ -5,11 +5,11 @@ fn list_comprehension() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -27,11 +27,11 @@ fn lc_with_const_exp() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -50,11 +50,11 @@ fn lc_with_non_const_exp() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -72,11 +72,11 @@ fn lc_with_two_lists() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -94,11 +94,11 @@ fn lc_with_two_slices() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -116,10 +116,10 @@ fn lc_with_multiple_lists() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[3], c[4], d[4]]
+        main: [a, b[3], c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -137,11 +137,11 @@ fn err_index_out_of_range_lc_ident() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -163,11 +163,11 @@ fn err_index_out_of_range_lc_slice() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     
     boundary_constraints {
@@ -190,11 +190,11 @@ fn err_non_const_exp_ident_iterable() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     
     boundary_constraints {
@@ -214,11 +214,11 @@ fn err_non_const_exp_slice_iterable() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -238,11 +238,11 @@ fn err_duplicate_member() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
diff --git a/ir/src/tests/integrity_constraints/mod.rs b/ir/src/tests/integrity_constraints/mod.rs
index 4514ee57..9fc414fb 100644
--- a/ir/src/tests/integrity_constraints/mod.rs
+++ b/ir/src/tests/integrity_constraints/mod.rs
@@ -7,10 +7,10 @@ fn integrity_constraints() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -27,10 +27,10 @@ fn ic_using_parens() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -47,10 +47,10 @@ fn ic_op_mul() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -67,10 +67,10 @@ fn ic_op_exp() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -88,11 +88,11 @@ fn err_non_const_exp_outside_lc() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
diff --git a/ir/src/tests/list_folding.rs b/ir/src/tests/list_folding.rs
index a36d38af..ad815068 100644
--- a/ir/src/tests/list_folding.rs
+++ b/ir/src/tests/list_folding.rs
@@ -6,11 +6,11 @@ fn list_folding_on_const() {
     def test
     const A = [1, 2, 3];
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -29,11 +29,11 @@ fn list_folding_on_variable() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -53,11 +53,11 @@ fn list_folding_on_vector() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -77,11 +77,11 @@ fn list_folding_on_lc() {
     def test
     const A = [1, 2, 3];
     trace_columns {
-        main: [clk, fmp[2], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[2], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
@@ -100,11 +100,11 @@ fn list_folding_in_lc() {
     let source = "
     def test
     trace_columns {
-        main: [clk, fmp[4], ctx]
-        aux: [a, b, c[4], d[4]]
+        main: [clk, fmp[4], ctx];
+        aux: [a, b, c[4], d[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf c[2].first = 0;
diff --git a/ir/src/tests/pub_inputs.rs b/ir/src/tests/pub_inputs.rs
index 961f0e2e..491a9a89 100644
--- a/ir/src/tests/pub_inputs.rs
+++ b/ir/src/tests/pub_inputs.rs
@@ -5,10 +5,10 @@ fn bc_with_public_inputs() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = stack_inputs[0]^3;
diff --git a/ir/src/tests/random_values.rs b/ir/src/tests/random_values.rs
index 4eedd520..f5b2d38f 100644
--- a/ir/src/tests/random_values.rs
+++ b/ir/src/tests/random_values.rs
@@ -5,14 +5,14 @@ fn random_values_indexed_access() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [16]
+        rand: [16];
     }
     boundary_constraints {
         enf c.first = $rand[10] * 2;
@@ -30,14 +30,14 @@ fn random_values_custom_name() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        alphas: [16]
+        alphas: [16];
     }
     boundary_constraints {
         enf c.first = $alphas[10] * 2;
@@ -55,14 +55,14 @@ fn random_values_named_access() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [m, n[4]]
+        rand: [m, n[4]];
     }
     boundary_constraints {
         enf c.first = (n[1] - $rand[0]) * 2;
@@ -80,14 +80,14 @@ fn err_random_values_out_of_bounds_no_bindings() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [4]
+        rand: [4];
     }
     boundary_constraints {
         enf a.first = $rand[10] * 2;
@@ -108,14 +108,14 @@ fn err_random_values_out_of_bounds_binding_ref() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [m, n[4]]
+        rand: [m, n[4]];
     }
     boundary_constraints {
         enf a.first = n[5] * 2;
@@ -136,14 +136,14 @@ fn err_random_values_out_of_bounds_global_ref() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [m, n[4]]
+        rand: [m, n[4]];
     }
     boundary_constraints {
         enf a.first = $rand[10] * 2;
@@ -164,13 +164,13 @@ fn err_random_values_without_aux_cols() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
+        main: [a, b[12]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [16]
+        rand: [16];
     }
     boundary_constraints {
         enf a.first = 2;
@@ -191,14 +191,14 @@ fn err_random_values_in_bc_against_main_cols() {
     let source = "
     def test
     trace_columns {
-        main: [a, b[12]]
-        aux: [c, d]
+        main: [a, b[12]];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        rand: [16]
+        rand: [16];
     }
     boundary_constraints {
         enf a.first = $rand[10] * 2;
diff --git a/ir/src/tests/selectors.rs b/ir/src/tests/selectors.rs
index 5ed65599..8bee3b73 100644
--- a/ir/src/tests/selectors.rs
+++ b/ir/src/tests/selectors.rs
@@ -5,11 +5,11 @@ fn single_selector() {
     let source = "
     def test
     trace_columns {
-        main: [s[2], clk]
+        main: [s[2], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -26,11 +26,11 @@ fn chained_selectors() {
     let source = "
     def test
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
     
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -47,11 +47,11 @@ fn multiconstraint_selectors() {
     let source = "
     def test
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -78,11 +78,11 @@ fn selectors_in_evaluators() {
     }
     
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -105,11 +105,11 @@ fn multiple_selectors_in_evaluators() {
     }
     
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -132,11 +132,11 @@ fn selector_with_evaluator_call() {
     }
     
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
 
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
@@ -167,11 +167,11 @@ fn selectors_inside_match() {
     }
 
     trace_columns {
-        main: [s[3], clk]
+        main: [s[3], clk];
     }
  
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
 
     boundary_constraints {
diff --git a/ir/src/tests/source_sections.rs b/ir/src/tests/source_sections.rs
index b17f8b1c..ac86528e 100644
--- a/ir/src/tests/source_sections.rs
+++ b/ir/src/tests/source_sections.rs
@@ -22,7 +22,7 @@ fn err_trace_cols_omitted() {
     let source = "
     def test
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -40,14 +40,14 @@ fn err_pub_inputs_empty() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {}
     boundary_constraints {
-        enf clk.first = 0
+        enf clk.first = 0;
     }
     integrity_constraints {
-        enf clk' = clk + 1
+        enf clk' = clk + 1;
     }";
 
     expect_diagnostic(source, "expected one of: 'identifier'");
@@ -59,7 +59,7 @@ fn err_pub_inputs_omitted() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -77,14 +77,14 @@ fn err_bc_empty() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {}
     integrity_constraints {
-        enf clk' = clk + 1
+        enf clk' = clk + 1;
     }";
 
     expect_diagnostic(source, "expected one of: '\"enf\"', '\"let\"'");
@@ -96,10 +96,10 @@ fn err_bc_omitted() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     integrity_constraints {
         enf clk' = clk + 1;
@@ -117,10 +117,10 @@ fn err_ic_empty() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -136,10 +136,10 @@ fn err_ic_omitted() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
diff --git a/ir/src/tests/trace.rs b/ir/src/tests/trace.rs
index cec83354..59610ff7 100644
--- a/ir/src/tests/trace.rs
+++ b/ir/src/tests/trace.rs
@@ -5,11 +5,11 @@ fn trace_columns_index_access() {
     let source = "
     def test
     trace_columns {
-        main: [a, b]
-        aux: [c, d]
+        main: [a, b];
+        aux: [c, d];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf a.first = 1;
@@ -30,10 +30,10 @@ fn trace_cols_groups() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk, a[4]]
+        main: [clk, a[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf a[1].first = A;
@@ -51,10 +51,10 @@ fn err_bc_column_undeclared() {
     let source = "
     def test
     trace_columns {
-        main: [ctx]
+        main: [ctx];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -72,10 +72,10 @@ fn err_ic_column_undeclared() {
     let source = "
     def test
     trace_columns {
-        main: [ctx]
+        main: [ctx];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf ctx.first = 0;
@@ -96,10 +96,10 @@ fn err_bc_trace_cols_access_out_of_bounds() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk, a[4]]
+        main: [clk, a[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf a[4].first = A;
@@ -123,10 +123,10 @@ fn err_ic_trace_cols_access_out_of_bounds() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk, a[4]]
+        main: [clk, a[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf a[1].first = A;
@@ -147,10 +147,10 @@ fn err_ic_trace_cols_group_used_as_scalar() {
     let source = "
     def test
     trace_columns {
-        main: [clk, a[4]]
+        main: [clk, a[4]];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf a[1].first = 0;
diff --git a/ir/src/tests/variables.rs b/ir/src/tests/variables.rs
index e30e167b..89372198 100644
--- a/ir/src/tests/variables.rs
+++ b/ir/src/tests/variables.rs
@@ -5,10 +5,10 @@ fn let_scalar_constant_in_boundary_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = 1 + 8;
@@ -26,10 +26,10 @@ fn let_vector_constant_in_boundary_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let b = [1, 5];
@@ -47,10 +47,10 @@ fn multi_constraint_nested_let_with_expressions_in_boundary_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = 1 + 8;
@@ -72,10 +72,10 @@ fn let_scalar_constant_in_boundary_constraint_both_domains() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = 1 + 8;
@@ -94,10 +94,10 @@ fn invalid_column_offset_in_boundary_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = clk';
@@ -116,10 +116,10 @@ fn nested_let_with_expressions_in_integrity_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -140,10 +140,10 @@ fn nested_let_with_vector_access_in_integrity_constraint() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 7;
@@ -168,10 +168,10 @@ fn invalid_matrix_literal_with_leading_vector_binding() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 7;
@@ -193,10 +193,10 @@ fn invalid_matrix_literal_with_trailing_vector_binding() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 7;
@@ -217,10 +217,10 @@ fn invalid_variable_access_before_declaration() {
     def test
     const A = [[2, 3], [1, 0]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = a;
@@ -240,10 +240,10 @@ fn invalid_trailing_let() {
     def test
     const A = [[2, 3], [1, 0]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         enf clk.first = 0;
@@ -263,10 +263,10 @@ fn invalid_reference_to_variable_defined_in_other_section() {
     def test
     const A = [[2, 3], [1, 0]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = 1;
@@ -286,10 +286,10 @@ fn invalid_vector_variable_access_out_of_bounds() {
     def test
     const A = [[2, 3], [1, 0]];
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = [1, 2];
@@ -311,10 +311,10 @@ fn invalid_matrix_column_variable_access_out_of_bounds() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = [[1, 2, 3], [4, 5, 6]];
@@ -336,10 +336,10 @@ fn invalid_matrix_row_variable_access_out_of_bounds() {
     let source = "
     def test
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     boundary_constraints {
         let a = [[1, 2, 3], [4, 5, 6]];
@@ -364,14 +364,14 @@ fn invalid_index_into_scalar_variable() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk]
-        aux: [p]
+        main: [clk];
+        aux: [p];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        alphas: [1]
+        alphas: [1];
     }
     boundary_constraints {
         enf clk.first = 1;
@@ -392,14 +392,14 @@ fn trace_binding_access_in_integrity_constraint() {
     const B = [1, 2, 3];
     const C = [[1, 2, 3], [4, 5, 6]];
     trace_columns {
-        main: [clk, x[4]]
-        aux: [p]
+        main: [clk, x[4]];
+        aux: [p];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     random_values {
-        alphas: [1]
+        alphas: [1];
     }
     boundary_constraints {
         enf clk.first = 1;
diff --git a/parser/src/parser/grammar.lalrpop b/parser/src/parser/grammar.lalrpop
index 4485e974..9c602213 100644
--- a/parser/src/parser/grammar.lalrpop
+++ b/parser/src/parser/grammar.lalrpop
@@ -124,12 +124,12 @@ AuxSegmentId: Identifier = {
 }
 
 MainTraceBindings: TraceSegment = {
-    <l:@L> <name:MainSegmentId> ":" <bindings: Vector<TraceBinding>> <r:@R> =>
+    <l:@L> <name:MainSegmentId> ":" <bindings: Vector<TraceBinding>> ";" <r:@R> =>
         TraceSegment::new(span!(l, r), 0, name, bindings),
 }
 
 AuxTraceBindings: TraceSegment = {
-    <l:@L> <name:AuxSegmentId> ":" <bindings: Vector<TraceBinding>> <r:@R> =>
+    <l:@L> <name:AuxSegmentId> ":" <bindings: Vector<TraceBinding>> ";" <r:@R> =>
         TraceSegment::new(span!(l, r), 1, name, bindings),
 }
 
@@ -161,7 +161,7 @@ PublicInputs: Span<Vec<PublicInput>> = {
 }
 
 PublicInput: PublicInput = {
-    <l:@L> <name: Identifier> ":" <size: Size> <r:@R>
+    <l:@L> <name: Identifier> ":" <size: Size> ";" <r:@R>
         => PublicInput::new(span!(l, r), name, size),
 }
 
@@ -175,7 +175,7 @@ PeriodicColumns: Span<Vec<PeriodicColumn>> = {
 }
 
 PeriodicColumn: PeriodicColumn = {
-    <l:@L> <name: Identifier> ":" <values: Vector<Num_u64>> <r:@R>
+    <l:@L> <name: Identifier> ":" <values: Vector<Num_u64>> ";" <r:@R>
         => PeriodicColumn::new(span!(l, r), name, values),
 }
 
@@ -195,18 +195,18 @@ RandomValues: RandomValues = {
 }
 
 RandValuesDef: RandomValues = {
-    <l:@L> <name: Identifier> ":" <size: Size> <r:@R> => {
+    <l:@L> <name: Identifier> ":" <size: Size> ";" <r:@R> => {
         let name = Identifier::new(name.span(), Symbol::intern(format!("${}", &name)));
         RandomValues::with_size(span!(l, r), name, size as usize)
     },
-    <l:@L> <ignored: Identifier> ":" "[" "]" <r:@R> =>? {
+    <l:@L> <ignored: Identifier> ":" "[" "]" ";" <r:@R> =>? {
         diagnostics.diagnostic(Severity::Error)
             .with_message("random values cannot be empty")
             .with_primary_label(span!(l, r), "invalid declaration occurs here")
             .emit();
         Err(ParseError::Failed.into())
     },
-    <l:@L> <name: Identifier> ":" <bindings: Vector<RandBinding>> <r:@R> => {
+    <l:@L> <name: Identifier> ":" <bindings: Vector<RandBinding>> ";" <r:@R> => {
         let name = Identifier::new(name.span(), Symbol::intern(format!("${}", &name)));
         RandomValues::new(span!(l, r), name, bindings)
     },
diff --git a/parser/src/parser/tests/boundary_constraints.rs b/parser/src/parser/tests/boundary_constraints.rs
index 79476d5e..9b5f6266 100644
--- a/parser/src/parser/tests/boundary_constraints.rs
+++ b/parser/src/parser/tests/boundary_constraints.rs
@@ -11,11 +11,11 @@ const BASE_MODULE: &str = r#"
 def test
 
 trace_columns {
-    main: [clk]
+    main: [clk];
 }
 
 public_inputs {
-    inputs: [2]
+    inputs: [2];
 }
 
 integrity_constraints {
diff --git a/parser/src/parser/tests/constant_propagation.rs b/parser/src/parser/tests/constant_propagation.rs
index 4425a35e..9dc5916b 100644
--- a/parser/src/parser/tests/constant_propagation.rs
+++ b/parser/src/parser/tests/constant_propagation.rs
@@ -15,11 +15,11 @@ fn test_constant_propagation() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     const A = [2, 4, 6, 8];
diff --git a/parser/src/parser/tests/evaluators.rs b/parser/src/parser/tests/evaluators.rs
index b4c02b58..b9e02221 100644
--- a/parser/src/parser/tests/evaluators.rs
+++ b/parser/src/parser/tests/evaluators.rs
@@ -89,11 +89,11 @@ fn ev_fn_call_simple() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -130,11 +130,11 @@ fn ev_fn_call() {
     def test
 
     trace_columns {
-        main: [a[2], b[4], c[6]]
+        main: [a[2], b[4], c[6]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -202,11 +202,11 @@ fn ev_fn_call_with_more_than_two_args() {
     def test
 
     trace_columns {
-        main: [a, b, c]
+        main: [a, b, c];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
diff --git a/parser/src/parser/tests/identifiers.rs b/parser/src/parser/tests/identifiers.rs
index 96fa8edb..daff158f 100644
--- a/parser/src/parser/tests/identifiers.rs
+++ b/parser/src/parser/tests/identifiers.rs
@@ -12,7 +12,7 @@ fn error_invalid_int() {
     def test
 
     trace_columns {{
-        main: [clk]
+        main: [clk];
     }}
 
     integrity_constraints {{
diff --git a/parser/src/parser/tests/inlining.rs b/parser/src/parser/tests/inlining.rs
index c57d5c79..eb9cdb4f 100644
--- a/parser/src/parser/tests/inlining.rs
+++ b/parser/src/parser/tests/inlining.rs
@@ -28,11 +28,11 @@ fn test_inlining_with_evaluator_split_input_binding() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     const A = [2, 4, 6, 8];
@@ -153,11 +153,11 @@ fn test_inlining_with_vector_literal_binding_regrouped() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -243,11 +243,11 @@ fn test_inlining_with_vector_literal_binding_unordered() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -332,11 +332,11 @@ fn test_inlining_with_vector_literal_binding_different_arity_many_to_few() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -421,11 +421,11 @@ fn test_inlining_with_vector_literal_binding_different_arity_few_to_many() {
     use lib::*;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -509,11 +509,11 @@ fn test_inlining_across_modules_with_nested_evaluators_variant1() {
     use lib1::test_constraint;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -621,11 +621,11 @@ fn test_inlining_across_modules_with_nested_evaluators_variant2() {
     use lib1::test_constraint;
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -738,11 +738,11 @@ fn test_inlining_constraint_comprehensions_no_selector() {
     const YS = [2, 4, 6, 8];
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -816,11 +816,11 @@ fn test_inlining_constraint_comprehensions_with_selector() {
     const YS = [2, 4, 6, 8];
 
     trace_columns {
-        main: [clk, a, b[2], c]
+        main: [clk, a, b[2], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -896,11 +896,11 @@ fn test_inlining_constraint_comprehensions_with_constant_selector() {
     const YS = [0, 4, 0, 8];
 
     trace_columns {
-        main: [clk, a, b[4], c]
+        main: [clk, a, b[4], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -973,11 +973,11 @@ fn test_inlining_constraint_comprehensions_in_evaluator() {
     const YS = [0, 4, 0, 8];
 
     trace_columns {
-        main: [clk, a, b[4], c]
+        main: [clk, a, b[4], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -1070,11 +1070,11 @@ fn test_inlining_constraints_with_folded_comprehensions_in_evaluator() {
     def root
 
     trace_columns {
-        main: [clk, a, b[4], c]
+        main: [clk, a, b[4], c];
     }
 
     public_inputs {
-        inputs: [0]
+        inputs: [0];
     }
 
     integrity_constraints {
@@ -1171,16 +1171,16 @@ fn test_repro_issue340() {
     def root
 
     trace_columns {
-        main: [instruction_word, instruction_bits[32], immediate, s]
+        main: [instruction_word, instruction_bits[32], immediate, s];
     }
 
     public_inputs {
-        stack_inputs: [16]
-        stack_outputs: [16]
+        stack_inputs: [16];
+        stack_outputs: [16];
     }
 
     periodic_columns {
-        k0: [1, 1, 1, 1, 1, 1, 1, 0]
+        k0: [1, 1, 1, 1, 1, 1, 1, 0];
     }
 
     boundary_constraints {
diff --git a/parser/src/parser/tests/input/bar.air b/parser/src/parser/tests/input/bar.air
index c42d59d3..2c55bc47 100644
--- a/parser/src/parser/tests/input/bar.air
+++ b/parser/src/parser/tests/input/bar.air
@@ -5,7 +5,7 @@ periodic_columns {
     # This column has the same name as the one in `foo`,
     # but shouldn't conflict in `import_example` because it
     # is only referenced locally in this module
-    k0: [1, 0]
+    k0: [1, 0];
 }
 
 ev bar_constraint([clk]) {
diff --git a/parser/src/parser/tests/input/foo.air b/parser/src/parser/tests/input/foo.air
index 0cea2327..c3da512a 100644
--- a/parser/src/parser/tests/input/foo.air
+++ b/parser/src/parser/tests/input/foo.air
@@ -2,7 +2,7 @@
 mod foo
 
 periodic_columns {
-    k0: [1, 1, 0, 0]
+    k0: [1, 1, 0, 0];
 }
 
 ev foo_constraint([clk]) {
diff --git a/parser/src/parser/tests/input/import_example.air b/parser/src/parser/tests/input/import_example.air
index e64bcbdf..5b2d83d8 100644
--- a/parser/src/parser/tests/input/import_example.air
+++ b/parser/src/parser/tests/input/import_example.air
@@ -7,11 +7,11 @@ use foo::*;
 use bar::bar_constraint;
 
 trace_columns {
-    main: [clk, fmp, ctx]
+    main: [clk, fmp, ctx];
 }
 
 public_inputs {
-    inputs: [2]
+    inputs: [2];
 }
 
 integrity_constraints {
diff --git a/parser/src/parser/tests/input/system.air b/parser/src/parser/tests/input/system.air
index f153384e..9da9170a 100644
--- a/parser/src/parser/tests/input/system.air
+++ b/parser/src/parser/tests/input/system.air
@@ -1,11 +1,11 @@
 def SystemAir
 
 trace_columns {
-    main: [clk, fmp, ctx]
+    main: [clk, fmp, ctx];
 }
 
 public_inputs {
-    inputs: [2]
+    inputs: [2];
 }
   
 integrity_constraints {
diff --git a/parser/src/parser/tests/integrity_constraints.rs b/parser/src/parser/tests/integrity_constraints.rs
index fe460e8f..a048584a 100644
--- a/parser/src/parser/tests/integrity_constraints.rs
+++ b/parser/src/parser/tests/integrity_constraints.rs
@@ -13,11 +13,11 @@ fn integrity_constraints() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -80,11 +80,11 @@ fn multiple_integrity_constraints() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -127,15 +127,15 @@ fn integrity_constraint_with_periodic_col() {
     def test
 
     trace_columns {
-        main: [b]
+        main: [b];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     periodic_columns {
-        k0: [1, 0]
+        k0: [1, 0];
     }
 
     boundary_constraints {
@@ -178,16 +178,16 @@ fn integrity_constraint_with_random_value() {
     def test
 
     trace_columns {
-        main: [a]
-        aux: [aux0[2]]
+        main: [a];
+        aux: [aux0[2]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     random_values {
-        rand: [2]
+        rand: [2];
     }
 
     boundary_constraints {
@@ -233,7 +233,7 @@ fn integrity_constraint_with_constants() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     const A = 0;
@@ -241,7 +241,7 @@ fn integrity_constraint_with_constants() {
     const C = [[0, 1], [1, 0]];
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -288,11 +288,11 @@ fn integrity_constraint_with_variables() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -337,12 +337,12 @@ fn integrity_constraint_with_indexed_trace_access() {
     def test
 
     trace_columns {
-        main: [a, b]
-        aux: [c, d]
+        main: [a, b];
+        aux: [c, d];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -397,11 +397,11 @@ fn ic_comprehension_one_iterable_identifier() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -442,11 +442,11 @@ fn ic_comprehension_one_iterable_range() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -487,11 +487,11 @@ fn ic_comprehension_with_selectors() {
     def test
 
     trace_columns {
-        main: [s[2], a, b, c[4]]
+        main: [s[2], a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -536,11 +536,11 @@ fn ic_comprehension_with_evaluator_call() {
     }
 
     trace_columns {
-        main: [a, b, c[4], d[4]]
+        main: [a, b, c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -594,11 +594,11 @@ fn ic_comprehension_with_evaluator_and_selectors() {
     }
 
     trace_columns {
-        main: [s[2], a, b, c[4], d[4]]
+        main: [s[2], a, b, c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -654,11 +654,11 @@ fn ic_match_constraint() {
     }
 
     trace_columns {
-        main: [s[2], a, b, c[4], d[4]]
+        main: [s[2], a, b, c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -721,7 +721,7 @@ fn err_ic_comprehension_one_member_two_iterables() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     integrity_constraints {
@@ -738,7 +738,7 @@ fn err_ic_comprehension_two_members_one_iterable() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     integrity_constraints {
@@ -758,7 +758,7 @@ fn err_missing_integrity_constraint() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     integrity_constraints {
diff --git a/parser/src/parser/tests/list_comprehension.rs b/parser/src/parser/tests/list_comprehension.rs
index fe5b60ea..0cdffa21 100644
--- a/parser/src/parser/tests/list_comprehension.rs
+++ b/parser/src/parser/tests/list_comprehension.rs
@@ -13,11 +13,11 @@ fn bc_one_iterable_identifier_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     integrity_constraints {
@@ -60,11 +60,11 @@ fn bc_identifier_and_range_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     integrity_constraints {
@@ -105,11 +105,11 @@ fn bc_iterable_slice_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     integrity_constraints {
@@ -150,11 +150,11 @@ fn bc_two_iterable_identifier_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4], d[4]]
+        main: [a, b, c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     integrity_constraints {
@@ -195,11 +195,11 @@ fn bc_multiple_iterables_lc() {
     def test
 
     trace_columns {
-        main: [a, b[3], c[4], d[4]]
+        main: [a, b[3], c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     integrity_constraints {
@@ -241,11 +241,11 @@ fn ic_one_iterable_identifier_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -291,11 +291,11 @@ fn ic_iterable_identifier_range_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -336,11 +336,11 @@ fn ic_iterable_slice_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -381,11 +381,11 @@ fn ic_two_iterable_identifier_lc() {
     def test
 
     trace_columns {
-        main: [a, b, c[4], d[4]]
+        main: [a, b, c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -426,11 +426,11 @@ fn ic_multiple_iterables_lc() {
     def test
 
     trace_columns {
-        main: [a, b[3], c[4], d[4]]
+        main: [a, b[3], c[4], d[4]];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -475,12 +475,12 @@ fn err_bc_lc_one_member_two_iterables() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     boundary_constraints {
         let x = [c for c in (c, d)];
-        enf a.first = x
+        enf a.first = x;
     }";
 
     ParseTest::new()
@@ -493,12 +493,12 @@ fn err_bc_lc_two_members_one_iterables() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     boundary_constraints {
         let x = [c + d for (c, d) in c];
-        enf a.first = x
+        enf a.first = x;
     }";
 
     ParseTest::new()
@@ -511,12 +511,12 @@ fn err_ic_lc_one_member_two_iterables() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     integrity_constraints {
         let x = [c for c in (c, d)];
-        enf a = x
+        enf a = x;
     }";
 
     ParseTest::new()
@@ -529,12 +529,12 @@ fn err_ic_lc_two_members_one_iterable() {
     def test
 
     trace_columns {
-        main: [a, b, c[4]]
+        main: [a, b, c[4]];
     }
 
     integrity_constraints {
         let x = [c + d for (c, d) in c];
-        enf a = x
+        enf a = x;
     }";
 
     ParseTest::new()
diff --git a/parser/src/parser/tests/periodic_columns.rs b/parser/src/parser/tests/periodic_columns.rs
index 7e44e0ba..f4b29237 100644
--- a/parser/src/parser/tests/periodic_columns.rs
+++ b/parser/src/parser/tests/periodic_columns.rs
@@ -10,8 +10,8 @@ fn periodic_columns() {
     mod test
 
     periodic_columns {
-        k0: [1, 0, 0, 0]
-        k1: [0, 0, 0, 0, 0, 0, 0, 1]
+        k0: [1, 0, 0, 0];
+        k1: [0, 0, 0, 0, 0, 0, 0, 1];
     }";
 
     let mut expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
@@ -47,7 +47,7 @@ fn err_periodic_columns_length() {
     mod test
 
     periodic_columns {
-        k0: [1, 0, 0]
+        k0: [1, 0, 0];
     }";
 
     ParseTest::new().expect_module_diagnostic(
diff --git a/parser/src/parser/tests/pub_inputs.rs b/parser/src/parser/tests/pub_inputs.rs
index efa9d0cb..0e87ed92 100644
--- a/parser/src/parser/tests/pub_inputs.rs
+++ b/parser/src/parser/tests/pub_inputs.rs
@@ -13,12 +13,12 @@ fn public_inputs() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     public_inputs {
-        program_hash: [4]
-        stack_inputs: [16]
+        program_hash: [4];
+        stack_inputs: [16];
     }
 
     boundary_constraints {
diff --git a/parser/src/parser/tests/random_values.rs b/parser/src/parser/tests/random_values.rs
index 805dced3..1b849370 100644
--- a/parser/src/parser/tests/random_values.rs
+++ b/parser/src/parser/tests/random_values.rs
@@ -13,16 +13,16 @@ fn random_values_fixed_list() {
     def test
 
     trace_columns {
-        main: [clk]
-        aux: [a]
+        main: [clk];
+        aux: [a];
     }
 
     random_values {
-        rand: [15]
+        rand: [15];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -66,16 +66,16 @@ fn random_values_ident_vector() {
     def test
 
     trace_columns {
-        main: [clk]
-        aux: [aux0]
+        main: [clk];
+        aux: [aux0];
     }
 
     random_values {
-        rand: [a, b[12], c]
+        rand: [a, b[12], c];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -119,16 +119,16 @@ fn random_values_custom_name() {
     def test
 
     trace_columns {
-        main: [clk]
-        aux: [aux0]
+        main: [clk];
+        aux: [aux0];
     }
 
     random_values {
-        alphas: [14]
+        alphas: [14];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -172,15 +172,15 @@ fn err_random_values_empty_list() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     random_values {
-        rand: []
+        rand: [];
     }
 
     integrity_constraints {
-        enf clk = 0
+        enf clk = 0;
     }";
 
     ParseTest::new().expect_module_diagnostic(source, "random values cannot be empty");
@@ -192,16 +192,16 @@ fn err_random_values_multiple_declaration() {
     def test
 
     trace_columns {
-        main: [clk]
+        main: [clk];
     }
 
     random_values {
-        rand: [12]
-        alphas: [a, b[2]]
+        rand: [12];
+        alphas: [a, b[2]];
     }
 
     integrity_constraints {
-        enf clk = 0
+        enf clk = 0;
     }";
 
     ParseTest::new()
@@ -214,16 +214,16 @@ fn random_values_index_access() {
     def test
 
     trace_columns {
-        main: [clk]
-        aux: [aux0]
+        main: [clk];
+        aux: [aux0];
     }
 
     random_values {
-        rand: [12]
+        rand: [12];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
diff --git a/parser/src/parser/tests/selectors.rs b/parser/src/parser/tests/selectors.rs
index 5d2c2792..5465fbdb 100644
--- a/parser/src/parser/tests/selectors.rs
+++ b/parser/src/parser/tests/selectors.rs
@@ -13,11 +13,11 @@ fn single_selector() {
     def test
 
     trace_columns {
-        main: [clk, n1]
+        main: [clk, n1];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -57,11 +57,11 @@ fn chained_selectors() {
     def test
 
     trace_columns {
-        main: [clk, n1, n2, n3]
+        main: [clk, n1, n2, n3];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
diff --git a/parser/src/parser/tests/trace_columns.rs b/parser/src/parser/tests/trace_columns.rs
index 5bab1495..d2ce8394 100644
--- a/parser/src/parser/tests/trace_columns.rs
+++ b/parser/src/parser/tests/trace_columns.rs
@@ -13,11 +13,11 @@ fn trace_columns() {
     def test
 
     trace_columns {
-        main: [clk, fmp, ctx]
+        main: [clk, fmp, ctx];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -55,12 +55,12 @@ fn trace_columns_main_and_aux() {
     def test
 
     trace_columns {
-        main: [clk, fmp, ctx]
-        aux: [rc_bus, ch_bus]
+        main: [clk, fmp, ctx];
+        aux: [rc_bus, ch_bus];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -101,12 +101,12 @@ fn trace_columns_groups() {
     def test
 
     trace_columns {
-        main: [clk, fmp, ctx, a[3]]
-        aux: [rc_bus, b[4], ch_bus]
+        main: [clk, fmp, ctx, a[3]];
+        aux: [rc_bus, b[4], ch_bus];
     }
 
     public_inputs {
-        inputs: [2]
+        inputs: [2];
     }
 
     boundary_constraints {
@@ -168,16 +168,16 @@ fn err_main_trace_cols_missing() {
     def test
 
     trace_columns {
-        aux: [clk]
+        aux: [clk];
     }
     public_inputs {
-        stack_inputs: [16]
+        stack_inputs: [16];
     }
     integrity_constraints {
-        enf clk' = clk + 1
+        enf clk' = clk + 1;
     }
     boundary_constraints {
-        enf clk.first = 0
+        enf clk.first = 0;
     }"#;
 
     ParseTest::new()