Rename HighLevelILInstruction to Instruction in Rust API

emesare · emesare · commit 20ef71e66250 · 2025-05-03T22:14:33.000-04:00
diff --git a/rust/src/high_level_il/block.rs b/rust/src/high_level_il/block.rs
@@ -3,15 +3,15 @@ use std::ops::Range;
 use crate::basic_block::{BasicBlock, BlockContext};
 use crate::rc::Ref;
 
-use super::{HighLevelILFunction, HighLevelILInstruction, HighLevelInstructionIndex};
+use super::{HighLevelILFunction, HighLevelInstructionIndex, Instruction};
 
 pub struct HighLevelILBlockIter {
     function: Ref<HighLevelILFunction>,
     range: Range<usize>,
 }
 
 impl Iterator for HighLevelILBlockIter {
-    type Item = HighLevelILInstruction;
+    type Item = Instruction;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.range
@@ -34,11 +34,11 @@ impl core::fmt::Debug for HighLevelILBlock {
 }
 
 impl BlockContext for HighLevelILBlock {
-    type Instruction = HighLevelILInstruction;
+    type Instruction = Instruction;
     type InstructionIndex = HighLevelInstructionIndex;
     type Iter = HighLevelILBlockIter;
 
-    fn start(&self, block: &BasicBlock<Self>) -> HighLevelILInstruction {
+    fn start(&self, block: &BasicBlock<Self>) -> Instruction {
         // TODO: Is this start index already mappedd?????
         self.function
             .instruction_from_index(block.start_index())
diff --git a/rust/src/high_level_il/function.rs b/rust/src/high_level_il/function.rs
@@ -3,7 +3,7 @@ use std::hash::{Hash, Hasher};
 
 use binaryninjacore_sys::*;
 
-use super::{HighLevelILBlock, HighLevelILInstruction, HighLevelInstructionIndex};
+use super::{HighLevelILBlock, HighLevelInstructionIndex, Instruction};
 use crate::basic_block::BasicBlock;
 use crate::function::{Function, Location};
 use crate::rc::{Array, Ref, RefCountable};
@@ -23,28 +23,22 @@ impl HighLevelILFunction {
         Self { handle, full_ast }.to_owned()
     }
 
-    pub fn instruction_from_index(
-        &self,
-        index: HighLevelInstructionIndex,
-    ) -> Option<HighLevelILInstruction> {
+    pub fn instruction_from_index(&self, index: HighLevelInstructionIndex) -> Option<Instruction> {
         if index.0 >= self.instruction_count() {
             None
         } else {
-            Some(HighLevelILInstruction::new(self.to_owned(), index))
+            Some(Instruction::new(self.to_owned(), index))
         }
     }
 
     pub fn instruction_from_expr_index(
         &self,
         expr_index: HighLevelInstructionIndex,
-    ) -> Option<HighLevelILInstruction> {
+    ) -> Option<Instruction> {
         if expr_index.0 >= self.expression_count() {
             None
         } else {
-            Some(HighLevelILInstruction::new_expr(
-                self.to_owned(),
-                expr_index,
-            ))
+            Some(Instruction::new_expr(self.to_owned(), expr_index))
         }
     }
 
@@ -53,11 +47,11 @@ impl HighLevelILFunction {
         HighLevelInstructionIndex(unsafe { BNGetHighLevelILRootExpr(self.handle) })
     }
 
-    pub fn root(&self) -> HighLevelILInstruction {
-        HighLevelILInstruction::new_expr(self.as_ast(), self.root_instruction_index())
+    pub fn root(&self) -> Instruction {
+        Instruction::new_expr(self.as_ast(), self.root_instruction_index())
     }
 
-    pub fn set_root(&self, new_root: &HighLevelILInstruction) {
+    pub fn set_root(&self, new_root: &Instruction) {
         unsafe { BNSetHighLevelILRootExpr(self.handle, new_root.expr_index.0) }
     }
 
@@ -130,7 +124,7 @@ impl HighLevelILFunction {
     ///
     /// Since SSA variables can only be defined once, this will return the single instruction where that occurs.
     /// For SSA variable version 0s, which don't have definitions, this will return None instead.
-    pub fn ssa_variable_definition(&self, variable: SSAVariable) -> Option<HighLevelILInstruction> {
+    pub fn ssa_variable_definition(&self, variable: SSAVariable) -> Option<Instruction> {
         let index = unsafe {
             BNGetHighLevelILSSAVarDefinition(
                 self.handle,
@@ -141,13 +135,13 @@ impl HighLevelILFunction {
         self.instruction_from_index(HighLevelInstructionIndex(index))
     }
 
-    pub fn ssa_memory_definition(&self, version: usize) -> Option<HighLevelILInstruction> {
+    pub fn ssa_memory_definition(&self, version: usize) -> Option<Instruction> {
         let index = unsafe { BNGetHighLevelILSSAMemoryDefinition(self.handle, version) };
         self.instruction_from_index(HighLevelInstructionIndex(index))
     }
 
     /// Gets all the instructions that use the given SSA variable.
-    pub fn ssa_variable_uses(&self, variable: SSAVariable) -> Array<HighLevelILInstruction> {
+    pub fn ssa_variable_uses(&self, variable: SSAVariable) -> Array<Instruction> {
         let mut count = 0;
         let instrs = unsafe {
             BNGetHighLevelILSSAVarUses(
@@ -161,7 +155,7 @@ impl HighLevelILFunction {
         unsafe { Array::new(instrs, count, self.to_owned()) }
     }
 
-    pub fn ssa_memory_uses(&self, version: usize) -> Array<HighLevelILInstruction> {
+    pub fn ssa_memory_uses(&self, version: usize) -> Array<Instruction> {
         let mut count = 0;
         let instrs = unsafe { BNGetHighLevelILSSAMemoryUses(self.handle, version, &mut count) };
         assert!(!instrs.is_null());
@@ -176,11 +170,7 @@ impl HighLevelILFunction {
     }
 
     /// Determines if `variable` is live at a given point in the function
-    pub fn is_ssa_variable_live_at(
-        &self,
-        variable: SSAVariable,
-        instr: &HighLevelILInstruction,
-    ) -> bool {
+    pub fn is_ssa_variable_live_at(&self, variable: SSAVariable, instr: &Instruction) -> bool {
         unsafe {
             BNIsHighLevelILSSAVarLiveAt(
                 self.handle,
@@ -191,7 +181,7 @@ impl HighLevelILFunction {
         }
     }
 
-    pub fn variable_definitions(&self, variable: Variable) -> Array<HighLevelILInstruction> {
+    pub fn variable_definitions(&self, variable: Variable) -> Array<Instruction> {
         let mut count = 0;
         let defs = unsafe {
             BNGetHighLevelILVariableDefinitions(self.handle, &variable.into(), &mut count)
@@ -200,7 +190,7 @@ impl HighLevelILFunction {
         unsafe { Array::new(defs, count, self.to_owned()) }
     }
 
-    pub fn variable_uses(&self, variable: Variable) -> Array<HighLevelILInstruction> {
+    pub fn variable_uses(&self, variable: Variable) -> Array<Instruction> {
         let mut count = 0;
         let instrs =
             unsafe { BNGetHighLevelILVariableUses(self.handle, &variable.into(), &mut count) };
@@ -209,7 +199,7 @@ impl HighLevelILFunction {
     }
 
     /// Determines if `variable` is live at a given point in the function
-    pub fn is_variable_live_at(&self, variable: Variable, instr: &HighLevelILInstruction) -> bool {
+    pub fn is_variable_live_at(&self, variable: Variable, instr: &Instruction) -> bool {
         unsafe { BNIsHighLevelILVarLiveAt(self.handle, &variable.into(), instr.expr_index.0) }
     }
 
diff --git a/rust/src/high_level_il/instruction.rs b/rust/src/high_level_il/instruction.rs
@@ -40,15 +40,15 @@ impl Display for HighLevelInstructionIndex {
 }
 
 #[derive(Clone)]
-pub struct HighLevelILInstruction {
+pub struct Instruction {
     pub function: Ref<HighLevelILFunction>,
     pub address: u64,
     pub expr_index: HighLevelInstructionIndex,
     pub size: usize,
-    pub kind: HighLevelILInstructionKind,
+    pub kind: InstructionKind,
 }
 
-impl HighLevelILInstruction {
+impl Instruction {
     pub(crate) fn new(
         function: Ref<HighLevelILFunction>,
         index: HighLevelInstructionIndex,
@@ -65,7 +65,7 @@ impl HighLevelILInstruction {
         let op =
             unsafe { BNGetHighLevelILByIndex(function.handle, expr_index.0, function.full_ast) };
         use BNHighLevelILOperation::*;
-        use HighLevelILInstructionKind as Op;
+        use InstructionKind as Op;
         let kind = match op.operation {
             HLIL_NOP => Op::Nop,
             HLIL_BREAK => Op::Break,
@@ -553,8 +553,8 @@ impl HighLevelILInstruction {
     }
 
     pub fn lift(&self) -> HighLevelILLiftedInstruction {
-        use HighLevelILInstructionKind::*;
         use HighLevelILLiftedInstructionKind as Lifted;
+        use InstructionKind::*;
         let kind = match self.kind {
             Nop => Lifted::Nop,
             Break => Lifted::Break,
@@ -949,13 +949,13 @@ impl HighLevelILInstruction {
     }
 }
 
-impl CoreArrayProvider for HighLevelILInstruction {
+impl CoreArrayProvider for Instruction {
     type Raw = usize;
     type Context = Ref<HighLevelILFunction>;
     type Wrapped<'a> = Self;
 }
 
-unsafe impl CoreArrayProviderInner for HighLevelILInstruction {
+unsafe impl CoreArrayProviderInner for Instruction {
     unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
         unsafe { BNFreeILInstructionList(raw) }
     }
@@ -965,7 +965,7 @@ unsafe impl CoreArrayProviderInner for HighLevelILInstruction {
     }
 }
 
-impl Debug for HighLevelILInstruction {
+impl Debug for Instruction {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
         // TODO: Actual debug impl please!
         write!(
@@ -978,7 +978,7 @@ impl Debug for HighLevelILInstruction {
 }
 
 #[derive(Debug, Copy, Clone)]
-pub enum HighLevelILInstructionKind {
+pub enum InstructionKind {
     Nop,
     Break,
     Continue,
diff --git a/rust/src/operand_iter.rs b/rust/src/operand_iter.rs
@@ -4,7 +4,7 @@ use binaryninjacore_sys::BNHighLevelILOperation;
 use binaryninjacore_sys::BNMediumLevelILOperation;
 
 use crate::high_level_il::{
-    HighLevelILFunction, HighLevelILInstruction, HighLevelInstructionIndex,
+    HighLevelILFunction, HighLevelInstructionIndex, Instruction as HighLevelILInstruction,
 };
 use crate::medium_level_il::{
     MediumLevelILFunction, MediumLevelILInstruction, MediumLevelInstructionIndex,
diff --git a/rust/tests/high_level_il.rs b/rust/tests/high_level_il.rs
@@ -1,6 +1,6 @@
 use binaryninja::binary_view::BinaryViewExt;
 use binaryninja::headless::Session;
-use binaryninja::high_level_il::{HighLevelILInstructionKind, HighLevelInstructionIndex};
+use binaryninja::high_level_il::{HighLevelInstructionIndex, InstructionKind};
 use std::path::PathBuf;
 
 #[test]
@@ -27,7 +27,7 @@ fn test_hlil_info() {
     assert_eq!(instr_0.address, image_base + 0x00025f22);
     println!("{:?}", instr_0.kind);
     match instr_0.kind {
-        HighLevelILInstructionKind::Ret(op) => {
+        InstructionKind::Ret(op) => {
             assert_eq!(op.first_src, 4);
             assert_eq!(op.num_srcs, 1);
         }
