feat: decompose Instruction::Constrain into multiple more basic constraints

compiler/noirc_evaluator/src/ssa/ir/dfg.rs

@@ -166,12 +166,33 @@ impl DataFlowGraph {
                 SimplifiedToMultiple(simplification)
             }
             SimplifyResult::Remove => InstructionRemoved,
-            result @ (SimplifyResult::SimplifiedToInstruction(_) | SimplifyResult::None) => {
-                let instruction = result.instruction().unwrap_or(instruction);
-                let id = self.make_instruction(instruction, ctrl_typevars);
-                self.blocks[block].insert_instruction(id);
-                self.locations.insert(id, call_stack);
-                InsertInstructionResult::Results(id, self.instruction_results(id))
+            result @ (SimplifyResult::SimplifiedToInstruction(_)
+            | SimplifyResult::SimplifiedToInstructionMultiple(_)
+            | SimplifyResult::None) => {
+                let instructions = result.instructions().unwrap_or(vec![instruction]);
+
+                if instructions.len() > 1 {
+                    // There's currently no way to pass results from one instruction in `instructions` on to the next.
+                    // We then restrict this to only support multiple instructions if they're all `Instruction::Constrain`
+                    // as this instruction type does not have any results.
+                    assert!(
+                        instructions.iter().all(|instruction| matches!(instruction, Instruction::Constrain(..))),
+                        "`SimplifyResult::SimplifiedToInstructionMultiple` only supports `Constrain` instructions"
+                    );
+                }
+
+                let mut instructions = instructions.into_iter().peekable();
+
+                while let Some(instruction) = instructions.next() {
+                    let id = self.make_instruction(instruction, ctrl_typevars.clone());
+                    self.blocks[block].insert_instruction(id);
+                    self.locations.insert(id, call_stack.clone());
+
+                    if instructions.peek().is_none() {
+                        return InsertInstructionResult::Results(id, self.instruction_results(id));
+                    }
+                }
+                unreachable!("At least one instruction must be returned. To not insert an instruction, use `SimplifyResult::Remove`")
             }
         }
     }

compiler/noirc_evaluator/src/ssa/ir/instruction.rs

@@ -432,73 +432,11 @@ impl Instruction {
                 }
             }
             Instruction::Constrain(lhs, rhs, msg) => {
-                if dfg.resolve(*lhs) == dfg.resolve(*rhs) {
-                    // Remove trivial case `assert_eq(x, x)`
-                    SimplifyResult::Remove
+                let constraints = decompose_constrain(*lhs, *rhs, msg.clone(), dfg);
+                if constraints.is_empty() {
+                    Remove
                 } else {
-                    match (&dfg[dfg.resolve(*lhs)], &dfg[dfg.resolve(*rhs)]) {
-                        (
-                            Value::NumericConstant { constant, typ },
-                            Value::Instruction { instruction, .. },
-                        )
-                        | (
-                            Value::Instruction { instruction, .. },
-                            Value::NumericConstant { constant, typ },
-                        ) if *typ == Type::bool() => {
-                            match dfg[*instruction] {
-                                Instruction::Binary(Binary {
-                                    lhs,
-                                    rhs,
-                                    operator: BinaryOp::Eq,
-                                }) if constant.is_one() => {
-                                    // Replace an explicit two step equality assertion
-                                    //
-                                    // v2 = eq v0, u32 v1
-                                    // constrain v2 == u1 1
-                                    //
-                                    // with a direct assertion of equality between the two values
-                                    //
-                                    // v2 = eq v0, u32 v1
-                                    // constrain v0 == v1
-                                    //
-                                    // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
-                                    // will likely be removed through dead instruction elimination.
-
-                                    SimplifiedToInstruction(Instruction::Constrain(
-                                        lhs,
-                                        rhs,
-                                        msg.clone(),
-                                    ))
-                                }
-                                Instruction::Not(value) => {
-                                    // Replace an assertion that a not instruction is truthy
-                                    //
-                                    // v1 = not v0
-                                    // constrain v1 == u1 1
-                                    //
-                                    // with an assertion that the not instruction input is falsy
-                                    //
-                                    // v1 = not v0
-                                    // constrain v0 == u1 0
-                                    //
-                                    // Note that this doesn't remove the value `v1` as it may be used in other instructions, but it
-                                    // will likely be removed through dead instruction elimination.
-                                    let reversed_constant = FieldElement::from(!constant.is_one());
-                                    let reversed_constant =
-                                        dfg.make_constant(reversed_constant, Type::bool());
-                                    SimplifiedToInstruction(Instruction::Constrain(
-                                        value,
-                                        reversed_constant,
-                                        msg.clone(),
-                                    ))
-                                }
-
-                                _ => None,
-                            }
-                        }
-
-                        _ => None,
-                    }
+                    SimplifiedToInstructionMultiple(constraints)
                 }
             }
             Instruction::ArrayGet { array, index } => {
@@ -619,6 +557,129 @@ fn simplify_cast(value: ValueId, dst_typ: &Type, dfg: &mut DataFlowGraph) -> Sim
     }
 }
 
+/// Try to decompose this constrain instruction. This constraint will be broken down such that it instead constrains
+/// all the values which are used to compute the values which were being constrained.
+fn decompose_constrain(
+    lhs: ValueId,
+    rhs: ValueId,
+    msg: Option<String>,
+    dfg: &mut DataFlowGraph,
+) -> Vec<Instruction> {
+    let lhs = dfg.resolve(lhs);
+    let rhs = dfg.resolve(rhs);
+
+    if lhs == rhs {
+        // Remove trivial case `assert_eq(x, x)`
+        Vec::new()
+    } else {
+        match (&dfg[lhs], &dfg[rhs]) {
+            (Value::NumericConstant { constant, typ }, Value::Instruction { instruction, .. })
+            | (Value::Instruction { instruction, .. }, Value::NumericConstant { constant, typ })
+                if *typ == Type::bool() =>
+            {
+                match dfg[*instruction] {
+                    Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Eq })
+                        if constant.is_one() =>
+                    {
+                        // Replace an explicit two step equality assertion
+                        //
+                        // v2 = eq v0, u32 v1
+                        // constrain v2 == u1 1
+                        //
+                        // with a direct assertion of equality between the two values
+                        //
+                        // v2 = eq v0, u32 v1
+                        // constrain v0 == v1
+                        //
+                        // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
+                        // will likely be removed through dead instruction elimination.
+
+                        vec![Instruction::Constrain(lhs, rhs, msg)]
+                    }
+
+                    Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Mul })
+                        if constant.is_one() && dfg.type_of_value(lhs) == Type::bool() =>
+                    {
+                        // Replace an equality assertion on a boolean multiplication
+                        //
+                        // v2 = mul v0, v1
+                        // constrain v2 == u1 1
+                        //
+                        // with a direct assertion that each value is equal to 1
+                        //
+                        // v2 = mul v0, v1
+                        // constrain v0 == 1
+                        // constrain v1 == 1
+                        //
+                        // This is due to the fact that for `v2` to be 1 then both `v0` and `v1` are 1.
+                        //
+                        // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
+                        // will likely be removed through dead instruction elimination.
+                        let one = FieldElement::one();
+                        let one = dfg.make_constant(one, Type::bool());
+
+                        [
+                            decompose_constrain(lhs, one, msg.clone(), dfg),
+                            decompose_constrain(rhs, one, msg, dfg),
+                        ]
+                        .concat()
+                    }
+
+                    Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Or })
+                        if constant.is_zero() =>
+                    {
+                        // Replace an equality assertion on an OR
+                        //
+                        // v2 = or v0, v1
+                        // constrain v2 == u1 0
+                        //
+                        // with a direct assertion that each value is equal to 0
+                        //
+                        // v2 = or v0, v1
+                        // constrain v0 == 0
+                        // constrain v1 == 0
+                        //
+                        // This is due to the fact that for `v2` to be 0 then both `v0` and `v1` are 0.
+                        //
+                        // Note that this doesn't remove the value `v2` as it may be used in other instructions, but it
+                        // will likely be removed through dead instruction elimination.
+                        let zero = FieldElement::zero();
+                        let zero = dfg.make_constant(zero, dfg.type_of_value(lhs));
+
+                        [
+                            decompose_constrain(lhs, zero, msg.clone(), dfg),
+                            decompose_constrain(rhs, zero, msg, dfg),
+                        ]
+                        .concat()
+                    }
+
+                    Instruction::Not(value) => {
+                        // Replace an assertion that a not instruction is truthy
+                        //
+                        // v1 = not v0
+                        // constrain v1 == u1 1
+                        //
+                        // with an assertion that the not instruction input is falsy
+                        //
+                        // v1 = not v0
+                        // constrain v0 == u1 0
+                        //
+                        // Note that this doesn't remove the value `v1` as it may be used in other instructions, but it
+                        // will likely be removed through dead instruction elimination.
+                        let reversed_constant = FieldElement::from(!constant.is_one());
+                        let reversed_constant = dfg.make_constant(reversed_constant, Type::bool());
+                        decompose_constrain(value, reversed_constant, msg, dfg)
+                    }
+
+                    _ => vec![Instruction::Constrain(lhs, rhs, msg)],
+                }
+            }
+
+            _ => vec![Instruction::Constrain(lhs, rhs, msg)],
+        }
+    }
+}
+
 /// The possible return values for Instruction::return_types
 pub(crate) enum InstructionResultType {
     /// The result type of this instruction matches that of this operand
@@ -1107,6 +1168,10 @@ pub(crate) enum SimplifyResult {
     /// Replace this function with an simpler but equivalent instruction.
     SimplifiedToInstruction(Instruction),
 
+    /// Replace this function with a set of simpler but equivalent instructions.
+    /// This is currently only to be used for [`Instruction::Constrain`].
+    SimplifiedToInstructionMultiple(Vec<Instruction>),
+
     /// Remove the instruction, it is unnecessary
     Remove,
 
@@ -1115,9 +1180,10 @@ pub(crate) enum SimplifyResult {
 }
 
 impl SimplifyResult {
-    pub(crate) fn instruction(self) -> Option<Instruction> {
+    pub(crate) fn instructions(self) -> Option<Vec<Instruction>> {
         match self {
-            SimplifyResult::SimplifiedToInstruction(instruction) => Some(instruction),
+            SimplifyResult::SimplifiedToInstruction(instruction) => Some(vec![instruction]),
+            SimplifyResult::SimplifiedToInstructionMultiple(instructions) => Some(instructions),
             _ => None,
         }
     }

test_programs/execution_success/struct_equality/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "struct_equality"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/struct_equality/Prover.toml

@@ -0,0 +1,4 @@
+[x]
+bar = true
+baz = [1, 2, 3]
+foo = 42

test_programs/execution_success/struct_equality/src/main.nr

@@ -0,0 +1,19 @@
+// This test demonstrates how SSA optimizations breaks down a struct equality assertion
+// to assert directly on the struct's fields rather than using a predicate.
+
+struct MyStruct {
+    foo: Field,
+    bar: bool,
+    baz: [u8; 3]
+}
+
+impl Eq for MyStruct {
+    fn eq(self, other: MyStruct) -> bool {
+        (self.foo == other.foo) & (self.bar == other.bar) & (self.baz == other.baz)
+    }
+}
+
+fn main(x: MyStruct) {
+    let y = MyStruct { foo: 42, bar: true, baz: [1, 2, 3] };
+    assert(x.eq(y));
+}