add unit tests

Author: guipublic

compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs

@@ -209,8 +209,8 @@ fn block_cost(block: BasicBlockId, dfg: &DataFlowGraph) -> u32 {
                 1
             },
             // if less than 10 elements, it is translated into a store for each element
-            // if more than 10, it is a loop, so 10 should be a good estimate
-            Instruction::MakeArray { .. } => 10,
+            // if more than 10, it is a loop, so 20 should be a good estimate, worst case being 10 stores and ~10 index increments
+            Instruction::MakeArray { .. } => 20,
 
             Instruction::Allocate
             | Instruction::EnableSideEffectsIf { .. }
@@ -380,3 +380,143 @@ impl<'f> Context<'f> {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::ssa::{opt::assert_normalized_ssa_equals, Ssa};
+
+    #[test]
+    fn basic_jmpif() {
+        let src = "
+              brillig(inline) fn foo f0 {
+                b0(v0: u32):
+                v3 = eq v0, u32 0
+                jmpif v3 then: b2, else: b1
+                b1():
+                jmp b3(u32 5)
+                b2():
+                jmp b3(u32 3)
+                b3(v1: u32):
+                return v1
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        assert_eq!(ssa.main().reachable_blocks().len(), 4);
+
+        let expected = "
+            brillig(inline) fn foo f0 {
+            b0(v0: u32):
+             v2 = eq v0, u32 0
+             v3 = not v2
+             v4 = cast v2 as u32
+             v5 = cast v3 as u32
+             v7 = unchecked_mul v4, u32 3
+             v9 = unchecked_mul v5, u32 5
+             v10 = unchecked_add v7, v9
+             return v10
+            }
+            ";
+
+        let ssa = ssa.flatten_basic_conditionals();
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+
+    #[test]
+    fn array_jmpif() {
+        let src = r#"
+              brillig(inline) fn foo f0 {
+                b0(v0: u32):
+                    v3 = eq v0, u32 5
+                    jmpif v3 then: b2, else: b1
+                b1():
+                    v6 = make_array b"foo"
+                    jmp b3(v6)
+                b2():
+                    v10 = make_array b"bar"
+                    jmp b3(v10)
+                b3(v1: [u8; 3]):
+                    return v1
+            }
+            "#;
+        let ssa = Ssa::from_str(src).unwrap();
+        assert_eq!(ssa.main().reachable_blocks().len(), 4);
+        let ssa = ssa.flatten_basic_conditionals();
+        // make_array is not simplified
+        assert_normalized_ssa_equals(ssa, src);
+    }
+
+    #[test]
+    fn nested_jmpifs() {
+        let src = "
+            brillig(inline) fn foo f0 {
+            b0(v0: u32):
+                v5 = eq v0, u32 5
+                v6 = not v5
+                jmpif v5 then: b5, else: b1
+            b1():
+                v8 = lt v0, u32 3
+                jmpif v8 then: b3, else: b2
+            b2():
+                v9 = truncate v0 to 2 bits, max_bit_size: 32
+                jmp b4(v9)
+            b3():
+                v10 = truncate v0 to 1 bits, max_bit_size: 32
+                jmp b4(v10)
+            b4(v1: u32):
+                jmp b9(v1)
+            b5():
+                v12 = lt u32 2, v0
+                jmpif v12 then: b7, else: b6
+            b6():
+                v13 = truncate v0 to 3 bits, max_bit_size: 32
+                jmp b8(v13)
+            b7():
+                v14 = and v0, u32 2
+                jmp b8(v14)
+            b8(v2: u32):
+                jmp b9(v2)
+            b9(v3: u32):
+                return v3
+            }
+            ";
+        let ssa = Ssa::from_str(src).unwrap();
+        assert_eq!(ssa.main().reachable_blocks().len(), 10);
+
+        let expected = "
+            brillig(inline) fn foo f0 {
+            b0(v0: u32):
+                v3 = eq v0, u32 5
+                v4 = not v3
+                jmpif v3 then: b2, else: b1
+            b1():
+                v6 = lt v0, u32 3
+                v7 = truncate v0 to 1 bits, max_bit_size: 32
+                v8 = not v6
+                v9 = truncate v0 to 2 bits, max_bit_size: 32
+                v10 = cast v6 as u32
+                v11 = cast v8 as u32
+                v12 = unchecked_mul v10, v7
+                v13 = unchecked_mul v11, v9
+                v14 = unchecked_add v12, v13
+                jmp b3(v14)
+            b2():
+                v16 = lt u32 2, v0
+                v17 = and v0, u32 2
+                v18 = not v16
+                v19 = truncate v0 to 3 bits, max_bit_size: 32
+                v20 = cast v16 as u32
+                v21 = cast v18 as u32
+                v22 = unchecked_mul v20, v17
+                v23 = unchecked_mul v21, v19
+                v24 = unchecked_add v22, v23
+                jmp b3(v24)
+            b3(v1: u32):
+                return v1
+            }
+            ";
+
+        let ssa = ssa.flatten_basic_conditionals();
+        assert_eq!(ssa.main().reachable_blocks().len(), 4);
+        assert_normalized_ssa_equals(ssa, expected);
+    }
+}