feat!: change InstructionHandler to be a trait and require it everywhere in Rust

quil-rs/benches/get_frames_for_instruction.rs

@@ -3,6 +3,7 @@ mod corpus;
 use std::str::FromStr;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use quil_rs::instruction::{DefaultHandler, InstructionHandler as _};
 
 fn benchmark_quil_corpus(c: &mut Criterion) {
     corpus::from_corpus().iter().for_each(|cfg| {
@@ -15,7 +16,7 @@ fn benchmark_quil_corpus(c: &mut Criterion) {
                 |prog| {
                     for instruction in prog.body_instructions() {
                         for _ in 0..50 {
-                            let frames = prog.get_frames_for_instruction(instruction);
+                            let frames = DefaultHandler.matching_frames(&prog, instruction);
                             black_box(frames);
                         }
                     }

quil-rs/benches/scheduled_program_from_program.rs

@@ -1,5 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
-use quil_rs::{instruction::InstructionHandler, program::scheduling::ScheduledProgram};
+use quil_rs::{instruction::DefaultHandler, program::scheduling::ScheduledProgram};
 use std::str::FromStr;
 
 mod corpus;
@@ -12,22 +12,16 @@ fn benchmark_quil_corpus(c: &mut Criterion) {
             // Ignore any programs that would fail to schedule
             match quil_rs::Program::from_str(&cfg.program) {
                 Err(_) => false,
-                Ok(program) => {
-                    ScheduledProgram::from_program(&program, &mut InstructionHandler::default())
-                        .is_ok()
-                }
+                Ok(program) => ScheduledProgram::from_program(&program, &DefaultHandler).is_ok(),
             }
         })
         .for_each(|cfg| {
             group.bench_function(&cfg.name, |b| {
                 b.iter_batched(
                     || quil_rs::Program::from_str(&cfg.program).unwrap(),
                     |program| {
-                        let prog = ScheduledProgram::from_program(
-                            &program,
-                            &mut InstructionHandler::default(),
-                        )
-                        .expect("scheduling should not fail");
+                        let prog = ScheduledProgram::from_program(&program, &DefaultHandler)
+                            .expect("scheduling should not fail");
                         black_box(prog);
                     },
                     BatchSize::SmallInput,

quil-rs/src/instruction/classical.rs

@@ -420,6 +420,28 @@ impl std::hash::Hash for ComparisonOperand {
     }
 }
 
+pub trait ClassicalOperand: Clone + std::fmt::Debug {
+    fn memory_reference(&self) -> Option<&MemoryReference>;
+}
+
+macro_rules! classical_operands {
+    ($($operand:ident),* $(,)?) => {
+        $(
+            impl ClassicalOperand for $operand {
+                fn memory_reference(&self) -> Option<&MemoryReference> {
+                    if let Self::MemoryReference(memory_reference) = self {
+                        Some(memory_reference)
+                    } else {
+                        None
+                    }
+                }
+            }
+        )*
+    }
+}
+
+classical_operands! { ArithmeticOperand, BinaryOperand, ComparisonOperand }
+
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 #[cfg_attr(feature = "stubs", gen_stub_pyclass_enum)]
 #[cfg_attr(

quil-rs/src/instruction/extern_call.rs

@@ -967,8 +967,10 @@ impl Call {
     }
 
     /// Return the [`MemoryAccesses`] for the [`Call`] instruction given the [`ExternSignatureMap`].
-    /// This assumes ALL parameters are read, including mutable parameters.
-    pub(crate) fn get_memory_accesses(
+    /// If the type of the `EXTERN` has a return type, then the first argument is assumed to be
+    /// written to and not read from; all other parameters are assumed to be read from, and all
+    /// other mutable parameters are assumped to be written to as well.
+    pub(crate) fn default_memory_accesses(
         &self,
         extern_signatures: &ExternSignatureMap,
     ) -> Result<MemoryAccesses, CallResolutionError> {
@@ -979,10 +981,11 @@ impl Call {
 
         let mut reads = HashSet::new();
         let mut writes = HashSet::new();
+
         let mut arguments = self.arguments.iter();
+
         if extern_signature.return_type.is_some() {
-            if let Some(argument) = self.arguments.first() {
-                arguments.next();
+            if let Some(argument) = arguments.next() {
                 match argument {
                     UnresolvedCallArgument::MemoryReference(memory_reference) => {
                         reads.insert(memory_reference.name.clone());
@@ -996,6 +999,7 @@ impl Call {
                 }
             }
         }
+
         for (argument, parameter) in std::iter::zip(arguments, extern_signature.parameters.iter()) {
             match argument {
                 UnresolvedCallArgument::MemoryReference(memory_reference) => {