Rust: Refactor Architecture trait to enforce method implementations for associated types at compile-time

arch/msp430/src/architecture.rs

@@ -1,11 +1,11 @@
-use crate::flag::{Flag, FlagClass, FlagGroup, FlagWrite};
+use crate::flag::{Flag, FlagWrite};
 use crate::lift::lift_instruction;
 use crate::register::Register;
 
 use binaryninja::{
     architecture::{
         Architecture, CoreArchitecture, CustomArchitectureHandle, FlagCondition, InstructionInfo,
-        UnusedIntrinsic, UnusedRegisterStack,
+        UnusedFlagClass, UnusedFlagGroup, UnusedIntrinsic, UnusedRegisterStack,
     },
     disassembly::{InstructionTextToken, InstructionTextTokenKind},
     Endianness,
@@ -16,9 +16,7 @@ use msp430_asm::{
     single_operand::SingleOperand, two_operand::TwoOperand,
 };
 
-use binaryninja::architecture::{
-    BranchKind, FlagClassId, FlagGroupId, FlagId, FlagWriteId, RegisterId,
-};
+use binaryninja::architecture::BranchKind;
 use binaryninja::low_level_il::expression::ValueExpr;
 use binaryninja::low_level_il::{LowLevelILMutableExpression, LowLevelILMutableFunction};
 
@@ -47,8 +45,8 @@ impl Architecture for Msp430 {
     type RegisterInfo = Register;
     type Flag = Flag;
     type FlagWrite = FlagWrite;
-    type FlagClass = FlagClass;
-    type FlagGroup = FlagGroup;
+    type FlagClass = UnusedFlagClass;
+    type FlagGroup = UnusedFlagGroup<Flag>;
     type Intrinsic = UnusedIntrinsic;
 
     fn endianness(&self) -> Endianness {
@@ -71,14 +69,6 @@ impl Architecture for Msp430 {
         6
     }
 
-    fn opcode_display_len(&self) -> usize {
-        self.max_instr_len()
-    }
-
-    fn associated_arch_by_addr(&self, _addr: u64) -> CoreArchitecture {
-        self.handle
-    }
-
     fn instruction_info(&self, data: &[u8], addr: u64) -> Option<InstructionInfo> {
         match msp430_asm::decode(data) {
             Ok(inst) => {
@@ -230,120 +220,6 @@ impl Architecture for Msp430 {
         None
     }
 
-    fn registers_all(&self) -> Vec<Self::Register> {
-        vec![
-            Register::Pc,
-            Register::Sp,
-            Register::Sr,
-            Register::Cg,
-            Register::R4,
-            Register::R5,
-            Register::R6,
-            Register::R7,
-            Register::R8,
-            Register::R9,
-            Register::R10,
-            Register::R11,
-            Register::R12,
-            Register::R13,
-            Register::R14,
-            Register::R15,
-        ]
-    }
-
-    fn registers_full_width(&self) -> Vec<Self::Register> {
-        vec![
-            Register::Pc,
-            Register::Sp,
-            Register::Sr,
-            Register::Cg,
-            Register::R4,
-            Register::R5,
-            Register::R6,
-            Register::R7,
-            Register::R8,
-            Register::R9,
-            Register::R10,
-            Register::R11,
-            Register::R12,
-            Register::R13,
-            Register::R14,
-            Register::R15,
-        ]
-    }
-
-    fn registers_global(&self) -> Vec<Self::Register> {
-        Vec::new()
-    }
-
-    fn registers_system(&self) -> Vec<Self::Register> {
-        Vec::new()
-    }
-
-    fn flags(&self) -> Vec<Self::Flag> {
-        vec![Flag::C, Flag::Z, Flag::N, Flag::V]
-    }
-
-    fn flag_write_types(&self) -> Vec<Self::FlagWrite> {
-        vec![
-            FlagWrite::All,
-            FlagWrite::Nz,
-            FlagWrite::Nvz,
-            FlagWrite::Cnz,
-        ]
-    }
-
-    fn flag_classes(&self) -> Vec<Self::FlagClass> {
-        Vec::new()
-    }
-
-    fn flag_groups(&self) -> Vec<Self::FlagGroup> {
-        Vec::new()
-    }
-
-    fn stack_pointer_reg(&self) -> Option<Self::Register> {
-        Some(Register::Sp)
-    }
-
-    fn link_reg(&self) -> Option<Self::Register> {
-        None
-    }
-
-    fn register_from_id(&self, id: RegisterId) -> Option<Self::Register> {
-        match id.try_into() {
-            Ok(register) => Some(register),
-            Err(_) => None,
-        }
-    }
-
-    fn flag_from_id(&self, id: FlagId) -> Option<Self::Flag> {
-        match id.try_into() {
-            Ok(flag) => Some(flag),
-            Err(_) => {
-                tracing::error!("invalid flag id {}", id);
-                None
-            }
-        }
-    }
-
-    fn flag_write_from_id(&self, id: FlagWriteId) -> Option<Self::FlagWrite> {
-        match id.try_into() {
-            Ok(flag_write) => Some(flag_write),
-            Err(_) => {
-                tracing::error!("invalid flag write id {}", id);
-                None
-            }
-        }
-    }
-
-    fn flag_class_from_id(&self, _: FlagClassId) -> Option<Self::FlagClass> {
-        None
-    }
-
-    fn flag_group_from_id(&self, _: FlagGroupId) -> Option<Self::FlagGroup> {
-        None
-    }
-
     fn handle(&self) -> Self::Handle {
         self.custom_handle
     }

arch/msp430/src/flag.rs

@@ -1,8 +1,7 @@
 use binaryninja::architecture;
-use binaryninja::architecture::{FlagClassId, FlagGroupId, FlagId, FlagRole, FlagWriteId};
+use binaryninja::architecture::{CoreArchitecture, FlagId, FlagRole, FlagWriteId, UnusedFlagClass};
 
 use std::borrow::Cow;
-use std::collections::HashMap;
 
 // NOTE: GIE, CPUOFF, OSCOFF, SG0, and SG1 not implemented as it's not clear how they would be used
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -14,7 +13,11 @@ pub enum Flag {
 }
 
 impl architecture::Flag for Flag {
-    type FlagClass = FlagClass;
+    type FlagClass = UnusedFlagClass;
+
+    fn flags(_arch: &CoreArchitecture) -> Vec<Self> {
+        vec![Flag::C, Flag::Z, Flag::N, Flag::V]
+    }
 
     fn name(&self) -> Cow<'_, str> {
         match self {
@@ -43,58 +46,18 @@ impl architecture::Flag for Flag {
         }
         .into()
     }
-}
 
-impl TryFrom<FlagId> for Flag {
-    type Error = ();
-    fn try_from(flag: FlagId) -> Result<Self, Self::Error> {
-        match flag.0 {
-            0 => Ok(Self::C),
-            1 => Ok(Self::Z),
-            2 => Ok(Self::N),
-            8 => Ok(Self::V),
-            _ => Err(()),
+    fn from_id(_arch: &CoreArchitecture, id: FlagId) -> Option<Self> {
+        match id.0 {
+            0 => Some(Self::C),
+            1 => Some(Self::Z),
+            2 => Some(Self::N),
+            8 => Some(Self::V),
+            _ => None,
         }
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct FlagClass {}
-
-impl architecture::FlagClass for FlagClass {
-    fn name(&self) -> Cow<'_, str> {
-        unimplemented!()
-    }
-
-    fn id(&self) -> FlagClassId {
-        unimplemented!()
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum FlagGroup {}
-
-impl architecture::FlagGroup for FlagGroup {
-    type FlagType = Flag;
-    type FlagClass = FlagClass;
-
-    fn name(&self) -> Cow<'_, str> {
-        unimplemented!()
-    }
-
-    fn id(&self) -> FlagGroupId {
-        unimplemented!()
-    }
-
-    fn flags_required(&self) -> Vec<Self::FlagType> {
-        unimplemented!()
-    }
-
-    fn flag_conditions(&self) -> HashMap<Self::FlagClass, architecture::FlagCondition> {
-        unimplemented!()
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum FlagWrite {
     All,
@@ -105,7 +68,16 @@ pub enum FlagWrite {
 
 impl architecture::FlagWrite for FlagWrite {
     type FlagType = Flag;
-    type FlagClass = FlagClass;
+    type FlagClass = UnusedFlagClass;
+
+    fn flag_write_types(_arch: &CoreArchitecture) -> Vec<Self> {
+        vec![
+            FlagWrite::All,
+            FlagWrite::Nz,
+            FlagWrite::Nvz,
+            FlagWrite::Cnz,
+        ]
+    }
 
     fn name(&self) -> Cow<'_, str> {
         match self {
@@ -130,6 +102,16 @@ impl architecture::FlagWrite for FlagWrite {
         .into()
     }
 
+    fn from_id(_arch: &CoreArchitecture, id: FlagWriteId) -> Option<Self> {
+        match id.0 {
+            1 => Some(Self::All),
+            2 => Some(Self::Nz),
+            3 => Some(Self::Nvz),
+            4 => Some(Self::Cnz),
+            _ => None,
+        }
+    }
+
     fn flags_written(&self) -> Vec<Self::FlagType> {
         match self {
             Self::All => vec![Flag::C, Flag::N, Flag::V, Flag::Z],
@@ -139,17 +121,3 @@ impl architecture::FlagWrite for FlagWrite {
         }
     }
 }
-
-impl TryFrom<FlagWriteId> for FlagWrite {
-    type Error = ();
-
-    fn try_from(value: FlagWriteId) -> Result<Self, Self::Error> {
-        match value.0 {
-            1 => Ok(Self::All),
-            2 => Ok(Self::Nz),
-            3 => Ok(Self::Nvz),
-            4 => Ok(Self::Cnz),
-            _ => Err(()),
-        }
-    }
-}

arch/msp430/src/register.rs

@@ -1,5 +1,4 @@
-use binaryninja::architecture;
-use binaryninja::architecture::{ImplicitRegisterExtend, RegisterId};
+use binaryninja::architecture::{self, CoreArchitecture, ImplicitRegisterExtend, RegisterId};
 
 use binaryninja::low_level_il::LowLevelILRegisterKind;
 use std::borrow::Cow;
@@ -112,6 +111,35 @@ impl architecture::Register for Register {
         }
         .into()
     }
+
+    fn from_id(_arch: &CoreArchitecture, id: RegisterId) -> Option<Self> {
+        id.try_into().ok()
+    }
+
+    fn registers_all(_: &CoreArchitecture) -> Vec<Self> {
+        vec![
+            Register::Pc,
+            Register::Sp,
+            Register::Sr,
+            Register::Cg,
+            Register::R4,
+            Register::R5,
+            Register::R6,
+            Register::R7,
+            Register::R8,
+            Register::R9,
+            Register::R10,
+            Register::R11,
+            Register::R12,
+            Register::R13,
+            Register::R14,
+            Register::R15,
+        ]
+    }
+
+    fn stack_pointer_reg(_: &CoreArchitecture) -> Option<Self> {
+        Some(Register::Sp)
+    }
 }
 
 impl architecture::RegisterInfo for Register {