chore!: allow backends to specify support for all opcode variants

acvm/src/compiler.rs

@@ -11,7 +11,7 @@ use acir::{
 use indexmap::IndexMap;
 use optimizers::GeneralOptimizer;
 use thiserror::Error;
-use transformers::{CSatTransformer, FallbackTransformer, IsOpcodeSupported, R1CSTransformer};
+use transformers::{CSatTransformer, FallbackTransformer, R1CSTransformer};
 
 use self::optimizers::RangeOptimizer;
 use self::optimizers::Simplifier;
@@ -22,10 +22,10 @@ pub enum CompileError {
     UnsupportedBlackBox(BlackBoxFunc),
 }
 
-pub fn compile(
+pub fn compile<F: Fn(&Opcode) -> bool>(
     acir: Circuit,
     np_language: Language,
-    is_opcode_supported: IsOpcodeSupported,
+    is_opcode_supported: F,
     simplifier: &Simplifier,
 ) -> Result<Circuit, CompileError> {
     // Instantiate the optimizer.

acvm/src/compiler/optimizers/simplify.rs

@@ -439,10 +439,7 @@ mod test {
         FieldElement,
     };
 
-    use crate::compiler::{
-        optimizers::Simplifier,
-        transformers::{FallbackTransformer, IsOpcodeSupported},
-    };
+    use crate::compiler::{optimizers::Simplifier, transformers::FallbackTransformer};
 
     #[test]
     fn simplify_test() {
@@ -479,7 +476,7 @@ mod test {
         simplifier.simplify(&mut circuit);
         assert_eq!(circuit.len(), 3);
         assert_eq!(simplifier.solved_gates.len(), 1);
-        let support_all: IsOpcodeSupported = |_| true;
+        let support_all = |_opcode: &Opcode| true;
         let mut acir = Circuit::default();
         acir.opcodes = circuit;
         let acir = FallbackTransformer::transform(acir, support_all, &simplifier).unwrap();

acvm/src/compiler/transformers/fallback.rs

@@ -7,16 +7,13 @@ use acir::{
     BlackBoxFunc,
 };
 
-// A predicate that returns true if the black box function is supported
-pub type IsOpcodeSupported = fn(&Opcode) -> bool;
-
 pub struct FallbackTransformer;
 
 impl FallbackTransformer {
     //ACIR pass which replace unsupported opcodes using arithmetic fallback
-    pub fn transform(
+    pub fn transform<F: Fn(&Opcode) -> bool>(
         acir: Circuit,
-        is_supported: IsOpcodeSupported,
+        is_supported: F,
         simplifier: &Simplifier,
     ) -> Result<Circuit, CompileError> {
         let mut acir_supported_opcodes = Vec::with_capacity(acir.opcodes.len());

acvm/src/compiler/transformers/mod.rs

@@ -4,5 +4,4 @@ mod r1cs;
 
 pub use csat::CSatTransformer;
 pub use fallback::FallbackTransformer;
-pub use fallback::IsOpcodeSupported;
 pub use r1cs::R1CSTransformer;

acvm/src/lib.rs

@@ -159,8 +159,8 @@ pub trait ProofSystemCompiler {
     /// if the language and proof system does not line up.
     fn np_language(&self) -> Language;
 
-    // Returns true if the backend supports the selected black box function
-    fn black_box_function_supported(&self, opcode: &BlackBoxFunc) -> bool;
+    // Returns true if the backend supports the selected opcode
+    fn opcode_supported(&self, opcode: &Opcode) -> bool;
 
     /// Returns the number of gates in a circuit
     fn get_exact_circuit_size(&self, circuit: &Circuit) -> Result<u32, Self::Error>;
@@ -227,9 +227,7 @@ pub fn checksum_constraint_system(cs: &Circuit) -> u32 {
 // This is set to match the previous functionality that we had
 // Where we could deduce what opcodes were supported
 // by knowing the np complete language
-pub fn default_is_opcode_supported(
-    language: Language,
-) -> compiler::transformers::IsOpcodeSupported {
+pub fn default_is_opcode_supported(language: Language) -> impl Fn(&Opcode) -> bool {
     // R1CS does not support any of the opcode except Arithmetic by default.
     // The compiler will replace those that it can -- ie range, xor, and
     fn r1cs_is_supported(opcode: &Opcode) -> bool {