feat: add support for assert in brillig

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert/Prover.toml

@@ -0,0 +1 @@
+x = "1"

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert/src/main.nr

@@ -0,0 +1,11 @@
+// Tests a very simple program.
+// 
+// The features being tested is using assert on brillig
+fn main(x: Field)  {
+    assert(1 == conditional(x as bool));
+}
+
+unconstrained fn conditional(x : bool) -> Field {
+    assert(x);
+    1
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert_fail/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert_fail/Prover.toml

@@ -0,0 +1 @@
+x = "0"

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_assert_fail/src/main.nr

@@ -0,0 +1,11 @@
+// Tests a very simple program.
+// 
+// The features being tested is using assert on brillig
+fn main(x: Field)  {
+    assert(1 == conditional(x as bool));
+}
+
+unconstrained fn conditional(x : bool) -> Field {
+    assert(x);
+    1
+}

crates/nargo_cli/tests/test_data_ssa_refactor/config.toml

@@ -2,4 +2,4 @@ exclude = []
 
 
 # List of tests (as their directory name) expecting to fail: if the test pass, we report an error.
-fail = [""]
+fail = ["brillig_assert_fail"]

crates/noirc_evaluator/src/brillig/artifact.rs

@@ -17,12 +17,32 @@ pub(crate) struct BrilligArtifact {
     pub(crate) byte_code: Vec<BrilligOpcode>,
     /// The set of jumps that need to have their locations
     /// resolved.
-    unresolved_jumps: Vec<(JumpLabel, BasicBlockId)>,
+    unresolved_jumps: Vec<(JumpLabel, UnresolvedJumpLocation)>,
     /// A map of the basic blocks to their positions
     /// in the bytecode.
     blocks: HashMap<BasicBlockId, BlockLabel>,
 }
 
+/// When constructing the bytecode, there may be instructions
+/// which require one to jump to a specific `Block`
+/// or a position relative to the current instruction.
+///
+/// The position of a `Block` cannot always be known
+/// at this point in time, so Jumps are unresolved
+/// until all blocks have been processed in the `Block`
+/// variant of this enum.
+///
+/// Sometimes the relative position of an Jump
+/// may be known, from the Jump label, but since
+/// the absolute position of a Jump label is not known until
+/// after we have linked the bytecode to other functions.
+/// We add relative jumps into the `Relative` variant of this enum.
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum UnresolvedJumpLocation {
+    Block(BasicBlockId),
+    Relative(i32),
+}
+
 impl BrilligArtifact {
     /// Link some compiled brillig bytecode with its referenced artifacts.
     pub(crate) fn link(&mut self, obj: &BrilligArtifact) -> Vec<BrilligOpcode> {
@@ -46,7 +66,7 @@ impl BrilligArtifact {
     }
 
     /// Adds a unresolved jump to be fixed at the end of bytecode processing.
-    pub(crate) fn add_unresolved_jump(&mut self, destination: BasicBlockId) {
+    pub(crate) fn add_unresolved_jump(&mut self, destination: UnresolvedJumpLocation) {
         self.unresolved_jumps.push((self.code_len(), destination));
     }
 
@@ -65,10 +85,15 @@ impl BrilligArtifact {
     ///
     /// Note: This should only be called once all blocks are processed.
     fn resolve_jumps(&mut self) {
-        for (jump_label, block) in &self.unresolved_jumps {
+        for (jump_label, unresolved_location) in &self.unresolved_jumps {
             let jump_instruction = self.byte_code[*jump_label].clone();
 
-            let actual_block_location = self.blocks[block];
+            let actual_block_location = match unresolved_location {
+                UnresolvedJumpLocation::Block(b) => self.blocks[b],
+                UnresolvedJumpLocation::Relative(location) => {
+                    (location + *jump_label as i32) as usize
+                }
+            };
 
             match jump_instruction {
                 BrilligOpcode::Jump { location } => {
@@ -84,7 +109,7 @@ impl BrilligArtifact {
                         BrilligOpcode::JumpIfNot { condition, location: actual_block_location };
                 }
                 BrilligOpcode::JumpIf { condition, location } => {
-                    assert_eq!(location, 0,"location is not zero, which means that the jump label does not need resolving");
+                    assert_eq!(location, 0, "location is not zero, which means that the jump label does not need resolving");
 
                     self.byte_code[*jump_label] =
                         BrilligOpcode::JumpIf { condition, location: actual_block_location };

crates/noirc_evaluator/src/brillig/brillig_gen.rs

@@ -1,5 +1,5 @@
 use super::{
-    artifact::BrilligArtifact,
+    artifact::{BrilligArtifact, UnresolvedJumpLocation},
     binary::{type_of_binary_operation, BrilligBinaryOp},
     memory::BrilligMemory,
 };
@@ -101,13 +101,13 @@ impl BrilligGen {
 
     /// Adds a unresolved `Jump` instruction to the bytecode.
     fn jump(&mut self, target: BasicBlockId) {
-        self.obj.add_unresolved_jump(target);
+        self.obj.add_unresolved_jump(UnresolvedJumpLocation::Block(target));
         self.push_code(BrilligOpcode::Jump { location: 0 });
     }
 
     /// Adds a unresolved `JumpIf` instruction to the bytecode.
     fn jump_if(&mut self, condition: RegisterIndex, target: BasicBlockId) {
-        self.obj.add_unresolved_jump(target);
+        self.obj.add_unresolved_jump(UnresolvedJumpLocation::Block(target));
         self.push_code(BrilligOpcode::JumpIf { condition, location: 0 });
     }
 
@@ -160,6 +160,13 @@ impl BrilligGen {
                 let result_register = self.get_or_create_register(result_ids[0]);
                 self.convert_ssa_binary(binary, dfg, result_register);
             }
+            Instruction::Constrain(value) => {
+                let condition = self.convert_ssa_value(*value, dfg);
+                // jump to the relative location after the trap
+                self.obj.add_unresolved_jump(UnresolvedJumpLocation::Relative(2));
+                self.push_code(BrilligOpcode::JumpIf { condition, location: 0 });
+                self.push_code(BrilligOpcode::Trap);
+            }
             Instruction::Allocate => {
                 let pointer_register =
                     self.get_or_create_register(dfg.instruction_results(instruction_id)[0]);