feat(masm): refactor assembler into a more compiler-like architecture

.gitignore

@@ -23,3 +23,6 @@ stdlib/assets/std.masl
 
 # VS Code
 .vscode/
+
+# Zed
+.zed/

Cargo.toml

@@ -1,14 +1,14 @@
 [workspace]
 members = [
-  "air",
-  "assembly",
-  "core",
-  "miden",
-  "processor",
-  "prover",
-  "stdlib",
-  "test-utils",
-  "verifier"
+    "air",
+    "assembly",
+    "core",
+    "miden",
+    "processor",
+    "prover",
+    "stdlib",
+    "test-utils",
+    "verifier",
 ]
 resolver = "2"
 
@@ -22,3 +22,7 @@ inherits = "release"
 debug = true
 debug-assertions = true
 overflow-checks = true
+
+[patch.crates-io]
+thiserror = { git = "https://github.com/bitwalker/thiserror", branch = "no-std" }
+miette = { git = "https://github.com/bitwalker/miette", branch = "no-std" }

air/src/constraints/chiplets/memory/tests.rs

@@ -103,8 +103,8 @@ enum MemoryTestDeltaType {
 /// in the  specified column (context, address, or clock), then returns the evaluation of the memory
 /// constraints on this frame.
 ///
-/// - To test a valid write, the MemoryTestDeltaType must be Context or Address and the `old_values` and
-/// `new_values` must change.
+/// - To test a valid write, the MemoryTestDeltaType must be Context or Address and the `old_values`
+///   and `new_values` must change.
 /// - To test a valid read, the `delta_type` must be Clock and the `old_values` and `new_values`
 /// must be equal.
 fn get_constraint_evaluation(
@@ -132,8 +132,8 @@ fn get_constraint_evaluation(
 /// - `selectors`: specifies the memory operation selectors in the next row which is being tested.
 /// - `delta_type`: specifies the column over which the delta value should be calculated.
 /// - `delta_row`: specifies the values of the context, address, and clock columns in the next row.
-/// - `old_values`: specifies the old values, which are placed in the value columns of the
-///   current row.
+/// - `old_values`: specifies the old values, which are placed in the value columns of the current
+///   row.
 /// - `new_values`: specifies the new values, which are placed in the value columns of the next row.
 fn get_test_frame(
     selectors: Selectors,

air/src/constraints/mod.rs

@@ -21,7 +21,7 @@ where
     /// Returns true when a u32 stack operation that requires range checks is being performed.
     fn u32_rc_op(&self) -> F;
 
-    // --- Range check lookup accessors -----------------------------------------------------------------------
+    // --- Range check lookup accessors -----------------------------------------------------------
 
     /// The value required for the first memory lookup when the memory chiplet requests range
     /// checks. The value returned is the denominator used for including the value into the LogUp

air/src/constraints/stack/field_ops/mod.rs

@@ -100,8 +100,8 @@ pub fn enforce_constraints<E: FieldElement>(
 
 /// Enforces constraints of the ADD operation. The ADD operation adds the first two elements
 /// in the current trace. Therefore, the following constraints are enforced:
-/// - The first element in the trace frame should be the addition of the first two elements in
-///   the current trace. s0` - s0 - s1 = 0.
+/// - The first element in the trace frame should be the addition of the first two elements in the
+///   current trace. s0` - s0 - s1 = 0.
 pub fn enforce_add_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
     result: &mut [E],
@@ -117,10 +117,10 @@ pub fn enforce_add_constraints<E: FieldElement>(
     1
 }
 
-/// Enforces constraints of the NEG operation. The NEG operation updates the top element
-/// in the stack with its inverse. Therefore, the following constraints are enforced:
-/// - The first element in the next frame should be the negation of first element in the
-///   current frame, therefore, their sum should be 0. s0` + s0 = 0.
+/// Enforces constraints of the NEG operation. The NEG operation updates the top element in the
+/// stack with its inverse. Therefore, the following constraints are enforced:
+/// - The first element in the next frame should be the negation of first element in the current
+///   frame, therefore, their sum should be 0. s0` + s0 = 0.
 pub fn enforce_neg_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
     result: &mut [E],
@@ -135,8 +135,8 @@ pub fn enforce_neg_constraints<E: FieldElement>(
 
 /// Enforces constraints of the MUL operation. The MUL operation multiplies the first two elements
 /// in the current trace. Therefore, the following constraints are enforced:
-/// - The first element in the next frame should be the product of the first two elements in
-///   the current frame. s0` - s0 * s1 = 0
+/// - The first element in the next frame should be the product of the first two elements in the
+///   current frame. s0` - s0 * s1 = 0
 pub fn enforce_mul_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
     result: &mut [E],
@@ -154,8 +154,8 @@ pub fn enforce_mul_constraints<E: FieldElement>(
 
 /// Enforces constraints of the INV operation. The INV operation updates the top element
 /// in the stack with its inverse. Therefore, the following constraints are enforced:
-/// - The next element in the next frame should be the inverse of first element in the
-///   current frame. s0` * s0 = 1.
+/// - The next element in the next frame should be the inverse of first element in the current
+///   frame. s0` * s0 = 1.
 pub fn enforce_inv_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
     result: &mut [E],
@@ -277,8 +277,9 @@ pub fn enforce_eq_constraints<E: FieldElement>(
     // Enforce that either c or difference between a & b is zero.
     result[0] = op_flag * are_equal(diff_top_elements * c, E::ZERO);
 
-    // It is the inverse of the diff of the top two element in the current frame if the diff is not ZERO;
-    // otherwise it could be anything. The value is fetched from the first register in the user op helper.
+    // It is the inverse of the diff of the top two element in the current frame if the diff is not
+    // ZERO; otherwise it could be anything. The value is fetched from the first register in the
+    // user op helper.
     let diff_inv = frame.user_op_helper(0);
 
     let helper_agg_value = E::ONE - diff_top_elements * diff_inv;
@@ -305,7 +306,8 @@ pub fn enforce_eqz_constraints<E: FieldElement>(
     result[0] = op_flag * are_equal(a * b, E::ZERO);
 
     // It is the inverse of the top element in the current frame if the top element is not ZERO; it
-    // could be anything otherwise. The value is fetched from the first register in the user op helper.
+    // could be anything otherwise. The value is fetched from the first register in the user op
+    // helper.
     let inv = frame.user_op_helper(0);
 
     let helper_agg_value = E::ONE - a * inv;
@@ -316,9 +318,10 @@ pub fn enforce_eqz_constraints<E: FieldElement>(
     2
 }
 
-/// Enforces constraints of the EXPACC operation. The EXPACC operation computes a single turn of exponent
-/// accumulation for the given inputs. Therefore, the following constraints are enforced:
-/// - The first element in the next frame should be a binary which is enforced as a general constraint.
+/// Enforces constraints of the EXPACC operation. The EXPACC operation computes a single turn of
+/// exponent accumulation for the given inputs. Therefore, the following constraints are enforced:
+/// - The first element in the next frame should be a binary which is enforced as a general
+///   constraint.
 /// - The exp value in the next frame should be the square of exp value in the current frame.
 /// - The accumulation value in the next frame is the product of the accumulation value in the
 /// current frame and the value which needs to be included in this turn.

air/src/constraints/stack/field_ops/tests.rs

@@ -156,30 +156,30 @@ fn test_not_stack_operation() {
 fn test_and_stack_operation() {
     let expected = [ZERO; NUM_CONSTRAINTS];
 
-    // ----------------- top elements are 0 and 0 -----------------------------------------------------
+    // ----------------- top elements are 0 and 0 -------------------------------------------------
     let a = ZERO;
     let b = ZERO;
     let frame = get_and_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 0 and 1 -----------------------------------------------------
+    // ----------------- top elements are 0 and 1 -------------------------------------------------
 
     let a = ZERO;
     let b = ONE;
     let frame = get_and_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 1 and 0 -----------------------------------------------------
+    // ----------------- top elements are 1 and 0 -------------------------------------------------
 
     let a = ONE;
     let b = ZERO;
     let frame = get_and_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 1 and 1 -----------------------------------------------------
+    // ----------------- top elements are 1 and 1 -------------------------------------------------
 
     let a = ONE;
     let b = ONE;
@@ -194,30 +194,30 @@ fn test_and_stack_operation() {
 fn test_or_stack_operation() {
     let expected = [ZERO; NUM_CONSTRAINTS];
 
-    // ----------------- top elements are 0 and 0 -----------------------------------------------------
+    // ----------------- top elements are 0 and 0 -------------------------------------------------
     let a = ZERO;
     let b = ZERO;
     let frame = get_or_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 0 and 1 -----------------------------------------------------
+    // ----------------- top elements are 0 and 1 -------------------------------------------------
 
     let a = ZERO;
     let b = ONE;
     let frame = get_or_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 1 and 0 -----------------------------------------------------
+    // ----------------- top elements are 1 and 0 -------------------------------------------------
 
     let a = ONE;
     let b = ZERO;
     let frame = get_or_test_frame(a, b);
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ----------------- top elements are 1 and 1 -----------------------------------------------------
+    // ----------------- top elements are 1 and 1 -------------------------------------------------
 
     let a = ONE;
     let b = ONE;

air/src/constraints/stack/mod.rs

@@ -35,10 +35,10 @@ pub const NUM_GENERAL_CONSTRAINTS: usize = 17;
 /// The degrees of constraints in the general stack operations. Each operation being executed
 /// either shifts the stack to the left, right or doesn't effect it at all. Therefore, majority
 /// of the general transitions of a stack item would be common across the operations and composite
-/// flags were introduced to compute the individual stack item transition. A particular item lets say
-/// at depth ith in the next stack frame can be transitioned into from ith depth (no shift op) or
-/// (i+1)th depth(left shift) or (i-1)th depth(right shift) in the current frame. Therefore, the VM
-/// would require only 16 general constraints to encompass all the 16 stack positions.
+/// flags were introduced to compute the individual stack item transition. A particular item lets
+/// say at depth ith in the next stack frame can be transitioned into from ith depth (no shift op)
+/// or (i+1)th depth(left shift) or (i-1)th depth(right shift) in the current frame. Therefore, the
+/// VM would require only 16 general constraints to encompass all the 16 stack positions.
 /// The last constraint checks if the top element in the stack is a binary or not.
 pub const CONSTRAINT_DEGREES: [usize; NUM_GENERAL_CONSTRAINTS] = [
     // Each degree are being multiplied with the respective composite flags which are of degree 7.

air/src/constraints/stack/op_flags/mod.rs

@@ -61,9 +61,10 @@ const DEGREE_4_OPCODE_ENDS: usize = DEGREE_4_OPCODE_STARTS + 31;
 /// values which helps in reducing the number of field multiplication operations being used in the
 /// calculation of the operation flag.
 ///
-/// The operation flag values are computed separately for degree 7 and degree 6 and 4 stack operations.
-/// Only one flag will be set to ONE and rest all would be ZERO for an execution trace. It also computes
-/// the composite flags using individual stack operation flags for generic stack constraints.
+/// The operation flag values are computed separately for degree 7 and degree 6 and 4 stack
+/// operations. Only one flag will be set to ONE and rest all would be ZERO for an execution trace.
+/// It also computes the composite flags using individual stack operation flags for generic stack
+/// constraints.
 pub struct OpFlags<E: FieldElement> {
     degree7_op_flags: [E; NUM_DEGREE_7_OPS],
     degree6_op_flags: [E; NUM_DEGREE_6_OPS],
@@ -195,7 +196,8 @@ impl<E: FieldElement> OpFlags<E> {
 
         // flag when the items from first point onwards are copied over. It doesn't have noop.
         let no_change_1_flag = f0000 - degree7_op_flags[0];
-        // flag when the items from second point onwards are shifted to the left. It doesn't have assert.
+        // flag when the items from second point onwards are shifted to the left. It doesn't have
+        // assert.
         let left_change_1_flag = f0100 - degree7_op_flags[32];
 
         // --- computation of the degree 6 operation flags ----------------------------------------

air/src/constraints/stack/op_flags/tests.rs

@@ -568,7 +568,7 @@ fn composite_flags() {
     assert_eq!(op_flags.control_flow(), ONE);
     assert_eq!(op_flags.top_binary(), ZERO);
 
-    // ----------------------------------- left shift -----------------------------------------------
+    // ----------------------------------- left shift ---------------------------------------------
 
     frame.current_mut()[DECODER_TRACE_OFFSET + IS_LOOP_FLAG_COL_IDX] = ONE;
 

air/src/constraints/stack/overflow/tests.rs

@@ -14,7 +14,7 @@ use vm_core::{Felt, FieldElement, Operation, ONE, ZERO};
 fn test_stack_overflow_constraints() {
     let expected = [ZERO; NUM_CONSTRAINTS];
 
-    // ------------------ right shift operation ----------------------------------------------------
+    // ------------------ right shift operation ---------------------------------------------------
 
     let depth = 16 + rand_value::<u32>() as u64;
     let mut frame = generate_evaluation_frame(Operation::Pad.op_code().into());
@@ -33,7 +33,7 @@ fn test_stack_overflow_constraints() {
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ------------------ left shift operation- depth 16 ----------------------------------------------------
+    // ------------------ left shift operation- depth 16 ------------------------------------------
 
     let depth = 16;
     let mut frame = generate_evaluation_frame(Operation::Drop.op_code().into());
@@ -52,7 +52,7 @@ fn test_stack_overflow_constraints() {
     let result = get_constraint_evaluation(frame);
     assert_eq!(expected, result);
 
-    // ------------------ left shift operation- depth 17 ----------------------------------------------------
+    // ------------------ left shift operation- depth 17 ------------------------------------------
 
     let depth = 17;
     let mut frame = generate_evaluation_frame(Operation::Drop.op_code().into());
@@ -99,9 +99,10 @@ fn test_stack_depth_air() {
     // block with a control block opcode.
     let mut frame = generate_evaluation_frame(Operation::Split.op_code().into());
 
-    // At the start of a control block, the second part of the hasher state gets populated with h2. Therefore, the 7th
-    // hasher element alone can't be used as a flag if it's the end of a call block, and the stack depth air constraint
-    // will fail in all control flow operations, which shifts the stack either to the right or left.
+    // At the start of a control block, the second part of the hasher state gets populated with h2.
+    // Therefore, the 7th hasher element alone can't be used as a flag if it's the end of a call
+    // block, and the stack depth air constraint will fail in all control flow operations, which
+    // shifts the stack either to the right or left.
     frame.current_mut()[CLK_COL_IDX] = ZERO;
     frame.current_mut()[B0_COL_IDX] = Felt::new(depth);
     frame.current_mut()[STACK_TRACE_OFFSET] = ONE;

air/src/constraints/stack/stack_manipulation/mod.rs

@@ -165,10 +165,10 @@ pub fn enforce_dup_movup_n_constraints<E: FieldElement>(
 
 /// Enforces constraints of the SWAP operation. The SWAP operation swaps the first
 /// two elements in the stack. Therefore, the following constraints are enforced:
-/// - The first element in the current frame should be equal to the second element in the
-///   next frame.
-/// - The second element in the current frame should be equal to the first element in the
-///   next frame.
+/// - The first element in the current frame should be equal to the second element in the next
+///   frame.
+/// - The second element in the current frame should be equal to the first element in the next
+///   frame.
 pub fn enforce_swap_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
     result: &mut [E],
@@ -190,17 +190,16 @@ pub fn enforce_swap_constraints<E: FieldElement>(
 /// - The SWAPW operation swaps the elements 0,1,2,3 with 4,5,6,7 in the stack.
 /// - The SWAPW2 operation swaps the elements 0,1,2,3 with 8,9,10,11 in the stack.
 /// - The SWAPW3 operation swaps the elements 0,1,2,3 with 12,13,14,15 in the stack.
-/// - The SWAPDW operation swaps the elements 0,1,2,3,4,5,6,7 with 8,9,10,11,12,13,14,15
-///   in the stack.
+/// - The SWAPDW operation swaps the elements 0,1,2,3,4,5,6,7 with 8,9,10,11,12,13,14,15 in the
+///   stack.
 ///
 /// Therefore, the following constraints are enforced:
-/// - During any frame, only one of these operation can be present (it is possible that
-///   none of these operations are present), therefore, the respective stack item can only
-///   transition into certain state and we can use this to combine these transition into
-///   one constraints where each transition are weighted by their respective flag. for eg.
-///   in the case of SWAPW3 the first item of the stack gets replaced with the 12 items and
-///   vice versa, therefore, only SWAPW3 transition will be ONE and rest all flags would be
-///   ZERO.
+/// - During any frame, only one of these operation can be present (it is possible that none of
+///   these operations are present), therefore, the respective stack item can only transition into
+///   certain state and we can use this to combine these transition into one constraints where each
+///   transition are weighted by their respective flag. for eg. in the case of SWAPW3 the first item
+///   of the stack gets replaced with the 12 items and vice versa, therefore, only SWAPW3 transition
+///   will be ONE and rest all flags would be ZERO.
 #[allow(clippy::needless_range_loop)]
 pub fn enforce_swapwx_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,
@@ -274,9 +273,8 @@ pub fn enforce_movdnn_constraints<E: FieldElement>(
 ///   is 1. The stack remains the same if the top element is 0.
 ///
 /// Therefore, the following constraints are enforced:
-/// - The top two elements or elements 1,2,3,4 should be swapped in the case of CSWAP and
-///   CSWAPW respectively if the top element is 1, the state remains the same if the top
-///   element is 0.
+/// - The top two elements or elements 1,2,3,4 should be swapped in the case of CSWAP and CSWAPW
+///   respectively if the top element is 1, the state remains the same if the top element is 0.
 #[allow(clippy::needless_range_loop)]
 pub fn enforce_cswapx_constraints<E: FieldElement>(
     frame: &EvaluationFrame<E>,