Merge pull request #288 from 0xPolygonMiden/tohrnii-evaluator-fix

fix(ir): throw an error on segment mismatch in evaluators

ir/src/constraint_builder/evaluators.rs

@@ -78,11 +78,18 @@ impl ConstraintBuilder {
     ) -> Result<Vec<Vec<usize>>, SemanticError> {
         // get the offsets for the trace binding accesses as a vector of indices
         let mut offsets: Vec<Vec<usize>> = Vec::new();
-        for segment in args.iter() {
+        for (segment, segment_binding_access) in args.iter().enumerate() {
             let mut segment_offsets = Vec::new();
-            for trace_binding_access in segment {
+            for trace_binding_access in segment_binding_access {
                 let trace_access = self.symbol_table.get_trace_access(trace_binding_access)?;
 
+                if trace_access.trace_segment() as usize != segment {
+                    return Err(SemanticError::evaluator_trace_segment_mismatch(
+                        trace_access.trace_segment(),
+                        segment,
+                    ));
+                }
+
                 // bindings referencing more than one trace element must be split into one offset
                 // per trace element.
                 for inner_offset in 0..trace_access.size() {

ir/src/tests/evaluators.rs

@@ -177,3 +177,27 @@ fn ev_fn_call_with_column_group() {
     let result = AirIR::new(parsed);
     assert!(result.is_ok());
 }
+
+#[test]
+fn err_ev_fn_call_wrong_segment_columns() {
+    let source = "
+    ev is_binary([x]):
+        enf x^2 = x
+    
+    trace_columns:
+        main: [b]
+        aux: [c]
+    
+    public_inputs:
+        stack_inputs: [16]
+    
+    boundary_constraints:
+        enf b.first = 0
+    
+    integrity_constraints:
+        enf is_binary([c])";
+
+    let parsed = parse(source).expect("Parsing failed");
+    let result = AirIR::new(parsed);
+    assert!(result.is_err());
+}

ir/src/validation/error.rs

@@ -157,6 +157,15 @@ impl SemanticError {
         ))
     }
 
+    pub(crate) fn evaluator_trace_segment_mismatch(
+        trace_segment: u8,
+        required_segment: usize,
+    ) -> Self {
+        SemanticError::InvalidUsage(format!(
+            "Evaluator function expected binding in trace segment {required_segment}, but was given binding in trace segment {trace_segment}.",
+        ))
+    }
+
     // --- INVALID CONSTRAINT ERRORS --------------------------------------------------------------
 
     pub(crate) fn incompatible_constraint_domains(