[Rust] Express expression vs instruction index for MLIL and HLIL APIs

This was done to fix unintended behavior using an instruction or expression index in place of the other.

Fixes https://github.com/Vector35/binaryninja-api/issues/6897

5 files changed, 392 insertions, 325 deletions

diff --git a/rust/src/medium_level_il/block.rs b/rust/src/medium_level_il/block.rs
index 1fcd51ca..162b19b0 100644
--- a/rust/src/medium_level_il/block.rs
+++ b/rust/src/medium_level_il/block.rs
@@ -14,8 +14,6 @@ impl BlockContext for MediumLevelILBlock {
     type Iter = MediumLevelILBlockIter;
 
     fn start(&self, block: &BasicBlock<Self>) -> MediumLevelILInstruction {
-        // TODO: instruction_from_index says that it is not mapped and will do the call
-        // TODO: What if this IS already MAPPED!?!?!?
         self.function
             .instruction_from_index(block.start_index())
             .unwrap()
diff --git a/rust/src/medium_level_il/function.rs b/rust/src/medium_level_il/function.rs
index bdbe3159..8751111b 100644
--- a/rust/src/medium_level_il/function.rs
+++ b/rust/src/medium_level_il/function.rs
@@ -2,7 +2,10 @@ use binaryninjacore_sys::*;
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
-use super::{MediumLevelILBlock, MediumLevelILInstruction, MediumLevelInstructionIndex};
+use super::{
+    MediumLevelExpressionIndex, MediumLevelILBlock, MediumLevelILInstruction,
+    MediumLevelInstructionIndex,
+};
 use crate::architecture::CoreArchitecture;
 use crate::basic_block::BasicBlock;
 use crate::confidence::Conf;
@@ -33,7 +36,7 @@ impl MediumLevelILFunction {
     }
 
     pub fn instruction_at<L: Into<Location>>(&self, loc: L) -> Option<MediumLevelILInstruction> {
-        Some(MediumLevelILInstruction::new(
+        Some(MediumLevelILInstruction::from_instr_index(
             self.to_owned(),
             self.instruction_index_at(loc)?,
         ))
@@ -64,18 +67,21 @@ impl MediumLevelILFunction {
         if index.0 >= self.instruction_count() {
             None
         } else {
-            Some(MediumLevelILInstruction::new(self.to_owned(), index))
+            Some(MediumLevelILInstruction::from_instr_index(
+                self.to_owned(),
+                index,
+            ))
         }
     }
 
     pub fn instruction_from_expr_index(
         &self,
-        expr_index: MediumLevelInstructionIndex,
+        expr_index: MediumLevelExpressionIndex,
     ) -> Option<MediumLevelILInstruction> {
         if expr_index.0 >= self.expression_count() {
             None
         } else {
-            Some(MediumLevelILInstruction::new_expr(
+            Some(MediumLevelILInstruction::from_expr_index(
                 self.to_owned(),
                 expr_index,
             ))
@@ -402,7 +408,7 @@ impl MediumLevelILFunction {
         unsafe { BNMediumLevelILSetCurrentAddress(self.handle, arch, location.addr) }
     }
 
-    /// Returns the [`BasicBlock`] at the given instruction `index`.
+    /// Returns the [`BasicBlock`] at the given instruction `index`. Function must be finalized.
     ///
     /// You can also retrieve this using [`MediumLevelILInstruction::basic_block`].
     pub fn basic_block_containing_index(
diff --git a/rust/src/medium_level_il/instruction.rs b/rust/src/medium_level_il/instruction.rs
index 70d69b7f..3af9e424 100644
--- a/rust/src/medium_level_il/instruction.rs
+++ b/rust/src/medium_level_il/instruction.rs
@@ -41,30 +41,76 @@ impl Display for MediumLevelInstructionIndex {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MediumLevelExpressionIndex(pub usize);
+
+impl MediumLevelExpressionIndex {
+    pub fn next(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+impl From<usize> for MediumLevelExpressionIndex {
+    fn from(index: usize) -> Self {
+        Self(index)
+    }
+}
+
+impl From<u64> for MediumLevelExpressionIndex {
+    fn from(index: u64) -> Self {
+        Self(index as usize)
+    }
+}
+
+impl Display for MediumLevelExpressionIndex {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_fmt(format_args!("{}", self.0))
+    }
+}
+
 #[derive(Clone)]
 pub struct MediumLevelILInstruction {
     pub function: Ref<MediumLevelILFunction>,
     pub address: u64,
-    // TODO; Because this structure is incorrectly named instruction, we want to make it clear that we actually have the expression index.
-    pub expr_index: MediumLevelInstructionIndex,
+    pub instr_index: MediumLevelInstructionIndex,
+    pub expr_index: MediumLevelExpressionIndex,
     pub size: usize,
     pub kind: MediumLevelILInstructionKind,
 }
 
 impl MediumLevelILInstruction {
-    pub(crate) fn new(
+    pub(crate) fn from_instr_index(
         function: Ref<MediumLevelILFunction>,
-        index: MediumLevelInstructionIndex,
+        instr_index: MediumLevelInstructionIndex,
     ) -> Self {
-        // TODO: If op.sourceOperation == BN_INVALID_OPERAND && op.operation == MLIL_NOP return None
-        let expr_index = unsafe { BNGetMediumLevelILIndexForInstruction(function.handle, index.0) };
-        Self::new_expr(function, MediumLevelInstructionIndex(expr_index))
+        // Get the associated expression index for the top-level instruction.
+        let expr_index_raw =
+            unsafe { BNGetMediumLevelILIndexForInstruction(function.handle, instr_index.0) };
+        Self::new(
+            function,
+            instr_index,
+            MediumLevelExpressionIndex(expr_index_raw),
+        )
+    }
+
+    pub(crate) fn from_expr_index(
+        function: Ref<MediumLevelILFunction>,
+        expr_index: MediumLevelExpressionIndex,
+    ) -> Self {
+        // Get the associated top-level instruction index for the expression.
+        let instr_index_raw =
+            unsafe { BNGetMediumLevelILInstructionForExpr(function.handle, expr_index.0) };
+        Self::new(
+            function,
+            MediumLevelInstructionIndex(instr_index_raw),
+            expr_index,
+        )
     }
 
-    // TODO: I need MediumLevelILExpression YESTERDAY!!!!
-    pub(crate) fn new_expr(
+    pub(crate) fn new(
         function: Ref<MediumLevelILFunction>,
-        expr_index: MediumLevelInstructionIndex,
+        instr_index: MediumLevelInstructionIndex,
+        expr_index: MediumLevelExpressionIndex,
     ) -> Self {
         // TODO: If op.sourceOperation == BN_INVALID_OPERAND && op.operation == MLIL_NOP return None
         let op = unsafe { BNGetMediumLevelILByIndex(function.handle, expr_index.0) };
@@ -78,7 +124,7 @@ impl MediumLevelILInstruction {
             MLIL_ASSERT | MLIL_ASSERT_SSA | MLIL_FORCE_VER | MLIL_FORCE_VER_SSA => Op::Undef,
             MLIL_UNIMPL => Op::Unimpl,
             MLIL_IF => Op::If(MediumLevelILOperationIf {
-                condition: op.operands[0] as usize,
+                condition: MediumLevelExpressionIndex::from(op.operands[0]),
                 dest_true: MediumLevelInstructionIndex(op.operands[1] as usize),
                 dest_false: MediumLevelInstructionIndex(op.operands[2] as usize),
             }),
@@ -104,35 +150,35 @@ impl MediumLevelILInstruction {
                 size: op.size,
             }),
             MLIL_JUMP => Op::Jump(Jump {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
             }),
             MLIL_RET_HINT => Op::RetHint(Jump {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
             }),
             MLIL_STORE_SSA => Op::StoreSsa(StoreSsa {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
                 dest_memory: op.operands[1],
                 src_memory: op.operands[2],
-                src: op.operands[3] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_STORE_STRUCT_SSA => Op::StoreStructSsa(StoreStructSsa {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
                 offset: op.operands[1],
                 dest_memory: op.operands[2],
                 src_memory: op.operands[3],
-                src: op.operands[4] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[4]),
             }),
             MLIL_STORE_STRUCT => Op::StoreStruct(StoreStruct {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
                 offset: op.operands[1],
-                src: op.operands[2] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_STORE => Op::Store(Store {
-                dest: op.operands[0] as usize,
-                src: op.operands[1] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
+                src: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_JUMP_TO => Op::JumpTo(JumpTo {
-                dest: op.operands[0] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[0]),
                 num_operands: op.operands[1] as usize,
                 first_operand: op.operands[2] as usize,
             }),
@@ -145,11 +191,11 @@ impl MediumLevelILInstruction {
             MLIL_SET_VAR_FIELD => Op::SetVarField(SetVarField {
                 dest: get_var(op.operands[0]),
                 offset: op.operands[1],
-                src: op.operands[2] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_SET_VAR => Op::SetVar(SetVar {
                 dest: get_var(op.operands[0]),
-                src: op.operands[1] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FREE_VAR_SLOT_SSA => Op::FreeVarSlotSsa(FreeVarSlotSsa {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
@@ -159,22 +205,22 @@ impl MediumLevelILInstruction {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
                 prev: get_var_ssa(op.operands[0], op.operands[2] as usize),
                 offset: op.operands[3],
-                src: op.operands[4] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[4]),
             }),
             MLIL_SET_VAR_ALIASED_FIELD => Op::SetVarAliasedField(SetVarSsaField {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
                 prev: get_var_ssa(op.operands[0], op.operands[2] as usize),
                 offset: op.operands[3],
-                src: op.operands[4] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[4]),
             }),
             MLIL_SET_VAR_ALIASED => Op::SetVarAliased(SetVarAliased {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
                 prev: get_var_ssa(op.operands[0], op.operands[2] as usize),
-                src: op.operands[3] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_SET_VAR_SSA => Op::SetVarSsa(SetVarSsa {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
-                src: op.operands[2] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_VAR_PHI => Op::VarPhi(VarPhi {
                 dest: get_var_ssa(op.operands[0], op.operands[1] as usize),
@@ -193,7 +239,7 @@ impl MediumLevelILInstruction {
             MLIL_SET_VAR_SPLIT => Op::SetVarSplit(SetVarSplit {
                 high: get_var(op.operands[0]),
                 low: get_var(op.operands[1]),
-                src: op.operands[2] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_VAR_SPLIT_SSA => Op::VarSplitSsa(VarSplitSsa {
                 high: get_var_ssa(op.operands[0], op.operands[1] as usize),
@@ -202,212 +248,212 @@ impl MediumLevelILInstruction {
             MLIL_SET_VAR_SPLIT_SSA => Op::SetVarSplitSsa(SetVarSplitSsa {
                 high: get_var_ssa(op.operands[0], op.operands[1] as usize),
                 low: get_var_ssa(op.operands[2], op.operands[3] as usize),
-                src: op.operands[4] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[4]),
             }),
             MLIL_ADD => Op::Add(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_SUB => Op::Sub(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_AND => Op::And(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_OR => Op::Or(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_XOR => Op::Xor(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_LSL => Op::Lsl(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_LSR => Op::Lsr(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_ASR => Op::Asr(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_ROL => Op::Rol(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_ROR => Op::Ror(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MUL => Op::Mul(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MULU_DP => Op::MuluDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MULS_DP => Op::MulsDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_DIVU => Op::Divu(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_DIVU_DP => Op::DivuDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_DIVS => Op::Divs(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_DIVS_DP => Op::DivsDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MODU => Op::Modu(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MODU_DP => Op::ModuDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MODS => Op::Mods(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_MODS_DP => Op::ModsDp(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_E => Op::CmpE(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_NE => Op::CmpNe(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_SLT => Op::CmpSlt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_ULT => Op::CmpUlt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_SLE => Op::CmpSle(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_ULE => Op::CmpUle(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_SGE => Op::CmpSge(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_UGE => Op::CmpUge(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_SGT => Op::CmpSgt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_CMP_UGT => Op::CmpUgt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_TEST_BIT => Op::TestBit(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_ADD_OVERFLOW => Op::AddOverflow(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_E => Op::FcmpE(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_NE => Op::FcmpNe(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_LT => Op::FcmpLt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_LE => Op::FcmpLe(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_GE => Op::FcmpGe(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_GT => Op::FcmpGt(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_O => Op::FcmpO(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FCMP_UO => Op::FcmpUo(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FADD => Op::Fadd(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FSUB => Op::Fsub(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FMUL => Op::Fmul(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_FDIV => Op::Fdiv(BinaryOp {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
             }),
             MLIL_ADC => Op::Adc(BinaryOpCarry {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
-                carry: op.operands[2] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
+                carry: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_SBB => Op::Sbb(BinaryOpCarry {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
-                carry: op.operands[2] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
+                carry: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_RLC => Op::Rlc(BinaryOpCarry {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
-                carry: op.operands[2] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
+                carry: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_RRC => Op::Rrc(BinaryOpCarry {
-                left: op.operands[0] as usize,
-                right: op.operands[1] as usize,
-                carry: op.operands[2] as usize,
+                left: MediumLevelExpressionIndex::from(op.operands[0]),
+                right: MediumLevelExpressionIndex::from(op.operands[1]),
+                carry: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_CALL => Op::Call(Call {
                 num_outputs: op.operands[0] as usize,
                 first_output: op.operands[1] as usize,
-                dest: op.operands[2] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[2]),
                 num_params: op.operands[3] as usize,
                 first_param: op.operands[4] as usize,
             }),
@@ -432,7 +478,7 @@ impl MediumLevelILInstruction {
             MLIL_TAILCALL => Op::Tailcall(Call {
                 num_outputs: op.operands[0] as usize,
                 first_output: op.operands[1] as usize,
-                dest: op.operands[2] as usize,
+                dest: MediumLevelExpressionIndex::from(op.operands[2]),
                 num_params: op.operands[3] as usize,
                 first_param: op.operands[4] as usize,
             }),
@@ -457,7 +503,7 @@ impl MediumLevelILInstruction {
                 first_param: op.operands[4] as usize,
             }),
             MLIL_MEMORY_INTRINSIC_SSA => Op::MemoryIntrinsicSsa(MemoryIntrinsicSsa {
-                output: op.operands[0] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
                 intrinsic: op.operands[1] as u32,
                 num_params: op.operands[2] as usize,
                 first_param: op.operands[3] as usize,
@@ -471,124 +517,124 @@ impl MediumLevelILInstruction {
                 })
             }
             MLIL_CALL_SSA => Op::CallSsa(CallSsa {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
                 num_params: op.operands[2] as usize,
                 first_param: op.operands[3] as usize,
                 src_memory: op.operands[4],
             }),
             MLIL_TAILCALL_SSA => Op::TailcallSsa(CallSsa {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
                 num_params: op.operands[2] as usize,
                 first_param: op.operands[3] as usize,
                 src_memory: op.operands[4],
             }),
             MLIL_CALL_UNTYPED_SSA => Op::CallUntypedSsa(CallUntypedSsa {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
-                params: op.operands[2] as usize,
-                stack: op.operands[3] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
+                params: MediumLevelExpressionIndex::from(op.operands[2]),
+                stack: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_TAILCALL_UNTYPED_SSA => Op::TailcallUntypedSsa(CallUntypedSsa {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
-                params: op.operands[2] as usize,
-                stack: op.operands[3] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
+                params: MediumLevelExpressionIndex::from(op.operands[2]),
+                stack: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_SYSCALL_SSA => Op::SyscallSsa(SyscallSsa {
-                output: op.operands[0] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
                 num_params: op.operands[1] as usize,
                 first_param: op.operands[2] as usize,
                 src_memory: op.operands[3],
             }),
             MLIL_SYSCALL_UNTYPED_SSA => Op::SyscallUntypedSsa(SyscallUntypedSsa {
-                output: op.operands[0] as usize,
-                params: op.operands[1] as usize,
-                stack: op.operands[2] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                params: MediumLevelExpressionIndex::from(op.operands[1]),
+                stack: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_CALL_UNTYPED => Op::CallUntyped(CallUntyped {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
-                params: op.operands[2] as usize,
-                stack: op.operands[3] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
+                params: MediumLevelExpressionIndex::from(op.operands[2]),
+                stack: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_TAILCALL_UNTYPED => Op::TailcallUntyped(CallUntyped {
-                output: op.operands[0] as usize,
-                dest: op.operands[1] as usize,
-                params: op.operands[2] as usize,
-                stack: op.operands[3] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                dest: MediumLevelExpressionIndex::from(op.operands[1]),
+                params: MediumLevelExpressionIndex::from(op.operands[2]),
+                stack: MediumLevelExpressionIndex::from(op.operands[3]),
             }),
             MLIL_SYSCALL_UNTYPED => Op::SyscallUntyped(SyscallUntyped {
-                output: op.operands[0] as usize,
-                params: op.operands[1] as usize,
-                stack: op.operands[2] as usize,
+                output: MediumLevelExpressionIndex::from(op.operands[0]),
+                params: MediumLevelExpressionIndex::from(op.operands[1]),
+                stack: MediumLevelExpressionIndex::from(op.operands[2]),
             }),
             MLIL_NEG => Op::Neg(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_NOT => Op::Not(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_SX => Op::Sx(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_ZX => Op::Zx(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_LOW_PART => Op::LowPart(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_BOOL_TO_INT => Op::BoolToInt(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_UNIMPL_MEM => Op::UnimplMem(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FSQRT => Op::Fsqrt(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FNEG => Op::Fneg(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FABS => Op::Fabs(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FLOAT_TO_INT => Op::FloatToInt(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_INT_TO_FLOAT => Op::IntToFloat(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FLOAT_CONV => Op::FloatConv(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_ROUND_TO_INT => Op::RoundToInt(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FLOOR => Op::Floor(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_CEIL => Op::Ceil(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_FTRUNC => Op::Ftrunc(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_LOAD => Op::Load(UnaryOp {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
             }),
             MLIL_LOAD_STRUCT => Op::LoadStruct(LoadStruct {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
                 offset: op.operands[1],
             }),
             MLIL_LOAD_STRUCT_SSA => Op::LoadStructSsa(LoadStructSsa {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0] as usize),
                 offset: op.operands[1],
                 src_memory: op.operands[2],
             }),
             MLIL_LOAD_SSA => Op::LoadSsa(LoadSsa {
-                src: op.operands[0] as usize,
+                src: MediumLevelExpressionIndex::from(op.operands[0]),
                 src_memory: op.operands[1],
             }),
             MLIL_RET => Op::Ret(Ret {
@@ -639,6 +685,7 @@ impl MediumLevelILInstruction {
         Self {
             function,
             address: op.address,
+            instr_index,
             expr_index,
             size: op.size,
             kind,
@@ -679,7 +726,7 @@ impl MediumLevelILInstruction {
     fn get_expr_list(&self, operand_idx: usize) -> Vec<MediumLevelILInstruction> {
         self.get_operand_list(operand_idx)
             .into_iter()
-            .map(|val| MediumLevelInstructionIndex(val as usize))
+            .map(|val| MediumLevelExpressionIndex(val as usize))
             .filter_map(|idx| self.function.instruction_from_expr_index(idx))
             .collect()
     }
@@ -949,49 +996,60 @@ impl MediumLevelILInstruction {
             CallUntypedSsa(op) => Lifted::CallUntypedSsa(self.lift_call_untyped_ssa(op)),
             TailcallUntypedSsa(op) => Lifted::TailcallUntypedSsa(self.lift_call_untyped_ssa(op)),
 
-            SyscallSsa(op) => Lifted::SyscallSsa(LiftedSyscallSsa {
-                output: get_call_output_ssa(&MediumLevelILInstruction::new(
-                    self.function.clone(),
-                    MediumLevelInstructionIndex(op.output),
-                )),
-                params: self
-                    .get_expr_list(1)
-                    .iter()
-                    .map(|expr| expr.lift())
-                    .collect(),
-                src_memory: op.src_memory,
-            }),
-            SyscallUntypedSsa(op) => Lifted::SyscallUntypedSsa(LiftedSyscallUntypedSsa {
-                output: get_call_output_ssa(&MediumLevelILInstruction::new(
-                    self.function.clone(),
-                    MediumLevelInstructionIndex(op.output),
-                )),
-                params: get_call_params_ssa(&MediumLevelILInstruction::new(
-                    self.function.clone(),
-                    MediumLevelInstructionIndex(op.params),
-                ))
-                .iter()
-                .map(|param| param.lift())
-                .collect(),
-                stack: self.lift_operand(op.stack),
-            }),
+            SyscallSsa(op) => {
+                let output_instr = self
+                    .function
+                    .instruction_from_expr_index(op.output)
+                    .expect("Valid output expression index");
+                Lifted::SyscallSsa(LiftedSyscallSsa {
+                    output: get_call_output_ssa(&output_instr),
+                    params: self
+                        .get_expr_list(1)
+                        .iter()
+                        .map(|expr| expr.lift())
+                        .collect(),
+                    src_memory: op.src_memory,
+                })
+            }
+            SyscallUntypedSsa(op) => {
+                let output_instr = self
+                    .function
+                    .instruction_from_expr_index(op.output)
+                    .expect("Valid output expression index");
+                let params_instr = self
+                    .function
+                    .instruction_from_expr_index(op.params)
+                    .expect("Valid params expression index");
+                Lifted::SyscallUntypedSsa(LiftedSyscallUntypedSsa {
+                    output: get_call_output_ssa(&output_instr),
+                    params: get_call_params_ssa(&params_instr)
+                        .iter()
+                        .map(|param| param.lift())
+                        .collect(),
+                    stack: self.lift_operand(op.stack),
+                })
+            }
 
             CallUntyped(op) => Lifted::CallUntyped(self.lift_call_untyped(op)),
             TailcallUntyped(op) => Lifted::TailcallUntyped(self.lift_call_untyped(op)),
-            SyscallUntyped(op) => Lifted::SyscallUntyped(LiftedSyscallUntyped {
-                output: get_call_output(&MediumLevelILInstruction::new(
-                    self.function.clone(),
-                    MediumLevelInstructionIndex(op.output),
-                )),
-                params: get_call_params(&MediumLevelILInstruction::new(
-                    self.function.clone(),
-                    MediumLevelInstructionIndex(op.params),
-                ))
-                .iter()
-                .map(|param| param.lift())
-                .collect(),
-                stack: self.lift_operand(op.stack),
-            }),
+            SyscallUntyped(op) => {
+                let output_instr = self
+                    .function
+                    .instruction_from_expr_index(op.output)
+                    .expect("Valid output expression index");
+                let params_instr = self
+                    .function
+                    .instruction_from_expr_index(op.params)
+                    .expect("Valid params expression index");
+                Lifted::SyscallUntyped(LiftedSyscallUntyped {
+                    output: get_call_output(&output_instr),
+                    params: get_call_params(&params_instr)
+                        .iter()
+                        .map(|param| param.lift())
+                        .collect(),
+                    stack: self.lift_operand(op.stack),
+                })
+            }
 
             Neg(op) => Lifted::Neg(self.lift_unary_op(op)),
             Not(op) => Lifted::Not(self.lift_unary_op(op)),
@@ -1060,7 +1118,8 @@ impl MediumLevelILInstruction {
         MediumLevelILLiftedInstruction {
             function: self.function.clone(),
             address: self.address,
-            index: self.expr_index,
+            instr_index: self.instr_index,
+            expr_index: self.expr_index,
             size: self.size,
             kind,
         }
@@ -1090,7 +1149,7 @@ impl MediumLevelILInstruction {
     /// Returns the [`BasicBlock`] containing the given [`MediumLevelILInstruction`].
     pub fn basic_block(&self) -> Option<Ref<BasicBlock<MediumLevelILBlock>>> {
         // TODO: We might be able to .expect this if we guarantee that self.index is valid.
-        self.function.basic_block_containing_index(self.expr_index)
+        self.function.basic_block_containing_index(self.instr_index)
     }
 
     /// Possible values of expression using path-sensitive static data flow analysis
@@ -1494,17 +1553,14 @@ impl MediumLevelILInstruction {
         Variable::new(var.ty, index, var.storage)
     }
 
-    fn lift_operand(&self, expr_idx: usize) -> Box<MediumLevelILLiftedInstruction> {
-        // TODO: UGH, if your gonna call it expr_idx, call the instruction and expression!!!!!
-        // TODO: We dont even need to say instruction in the type!
-        // TODO: IF you want to have an instruction type, there needs to be a separate expression type
-        // TODO: See the lowlevelil module.
-        let expr_idx_is_really_instr_idx = MediumLevelInstructionIndex(expr_idx);
-        // TODO: See the comment in the unchecked function, ugh, i hate this..
+    fn lift_operand(
+        &self,
+        expr_idx: MediumLevelExpressionIndex,
+    ) -> Box<MediumLevelILLiftedInstruction> {
         let operand_instr = self
             .function
-            .instruction_from_expr_index(expr_idx_is_really_instr_idx)
-            .unwrap();
+            .instruction_from_expr_index(expr_idx)
+            .expect("Invalid operand expression index");
         Box::new(operand_instr.lift())
     }
 
@@ -1542,29 +1598,32 @@ impl MediumLevelILInstruction {
     }
 
     fn lift_call_untyped(&self, op: CallUntyped) -> LiftedCallUntyped {
+        let output_instr = self
+            .function
+            .instruction_from_expr_index(op.output)
+            .expect("Valid output expression index");
+        let params_instr = self
+            .function
+            .instruction_from_expr_index(op.params)
+            .expect("Valid params expression index");
         LiftedCallUntyped {
-            output: get_call_output(&MediumLevelILInstruction::new(
-                self.function.clone(),
-                MediumLevelInstructionIndex(op.output),
-            )),
+            output: get_call_output(&output_instr),
             dest: self.lift_operand(op.dest),
-            params: get_call_params(&MediumLevelILInstruction::new(
-                self.function.clone(),
-                MediumLevelInstructionIndex(op.params),
-            ))
-            .iter()
-            .map(|expr| expr.lift())
-            .collect(),
+            params: get_call_params(&params_instr)
+                .iter()
+                .map(|expr| expr.lift())
+                .collect(),
             stack: self.lift_operand(op.stack),
         }
     }
 
     fn lift_call_ssa(&self, op: CallSsa) -> LiftedCallSsa {
+        let output_instr = self
+            .function
+            .instruction_from_expr_index(op.output)
+            .expect("Valid output expression index");
         LiftedCallSsa {
-            output: get_call_output_ssa(&MediumLevelILInstruction::new(
-                self.function.clone(),
-                MediumLevelInstructionIndex(op.output),
-            )),
+            output: get_call_output_ssa(&output_instr),
             dest: self.lift_operand(op.dest),
             params: self
                 .get_expr_list(2)
@@ -1576,19 +1635,21 @@ impl MediumLevelILInstruction {
     }
 
     fn lift_call_untyped_ssa(&self, op: CallUntypedSsa) -> LiftedCallUntypedSsa {
+        let output_instr = self
+            .function
+            .instruction_from_expr_index(op.output)
+            .expect("Valid output expression index");
+        let params_instr = self
+            .function
+            .instruction_from_expr_index(op.params)
+            .expect("Valid params expression index");
         LiftedCallUntypedSsa {
-            output: get_call_output_ssa(&MediumLevelILInstruction::new(
-                self.function.clone(),
-                MediumLevelInstructionIndex(op.output),
-            )),
+            output: get_call_output_ssa(&output_instr),
             dest: self.lift_operand(op.dest),
-            params: get_call_params_ssa(&MediumLevelILInstruction::new(
-                self.function.clone(),
-                MediumLevelInstructionIndex(op.params),
-            ))
-            .iter()
-            .map(|param| param.lift())
-            .collect(),
+            params: get_call_params_ssa(&params_instr)
+                .iter()
+                .map(|param| param.lift())
+                .collect(),
             stack: self.lift_operand(op.stack),
         }
     }
@@ -1598,7 +1659,8 @@ impl Debug for MediumLevelILInstruction {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("MediumLevelILInstruction")
             .field("address", &self.address)
-            .field("index", &self.expr_index)
+            .field("instr_index", &self.instr_index)
+            .field("expr_index", &self.expr_index)
             .field("size", &self.size)
             .field("kind", &self.kind)
             .finish()
@@ -1617,8 +1679,6 @@ unsafe impl CoreArrayProviderInner for MediumLevelILInstruction {
     }
 
     unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
-        // TODO: This needs to be tested!!!!
-        // TODO: What if this does not need to be mapped!!!!
         context
             .instruction_from_index(MediumLevelInstructionIndex(*raw))
             .unwrap()
@@ -1832,9 +1892,9 @@ unsafe impl CoreArrayProviderInner for BranchDependence {
 
     unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
         Self {
-            instruction: MediumLevelILInstruction::new(
+            instruction: MediumLevelILInstruction::from_expr_index(
                 context.clone(),
-                MediumLevelInstructionIndex(raw.branch),
+                MediumLevelExpressionIndex(raw.branch),
             ),
             dependence: raw.dependence,
         }
diff --git a/rust/src/medium_level_il/lift.rs b/rust/src/medium_level_il/lift.rs
index 399bda78..e563f26d 100644
--- a/rust/src/medium_level_il/lift.rs
+++ b/rust/src/medium_level_il/lift.rs
@@ -1,5 +1,5 @@
 use super::operation::*;
-use super::{MediumLevelILFunction, MediumLevelInstructionIndex};
+use super::{MediumLevelExpressionIndex, MediumLevelILFunction, MediumLevelInstructionIndex};
 use crate::architecture::CoreIntrinsic;
 use crate::rc::Ref;
 use crate::variable::{ConstantData, SSAVariable, Variable};
@@ -27,7 +27,8 @@ pub enum MediumLevelILLiftedOperand {
 pub struct MediumLevelILLiftedInstruction {
     pub function: Ref<MediumLevelILFunction>,
     pub address: u64,
-    pub index: MediumLevelInstructionIndex,
+    pub instr_index: MediumLevelInstructionIndex,
+    pub expr_index: MediumLevelExpressionIndex,
     pub size: usize,
     pub kind: MediumLevelILLiftedInstructionKind,
 }
@@ -36,7 +37,8 @@ impl Debug for MediumLevelILLiftedInstruction {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("MediumLevelILLiftedInstruction")
             .field("address", &self.address)
-            .field("index", &self.index)
+            .field("instr_index", &self.instr_index)
+            .field("expr_index", &self.expr_index)
             .field("size", &self.size)
             .field("kind", &self.kind)
             .finish()
diff --git a/rust/src/medium_level_il/operation.rs b/rust/src/medium_level_il/operation.rs
index e8b70cc6..578087d0 100644
--- a/rust/src/medium_level_il/operation.rs
+++ b/rust/src/medium_level_il/operation.rs
@@ -1,4 +1,6 @@
-use super::{MediumLevelILLiftedInstruction, MediumLevelInstructionIndex};
+use super::{
+    MediumLevelExpressionIndex, MediumLevelILLiftedInstruction, MediumLevelInstructionIndex,
+};
 use crate::architecture::CoreIntrinsic;
 use crate::variable::{ConstantData, SSAVariable, Variable};
 use std::collections::BTreeMap;
@@ -6,7 +8,7 @@ use std::collections::BTreeMap;
 // IF
 #[derive(Debug, Copy, Clone)]
 pub struct MediumLevelILOperationIf {
-    pub condition: usize,
+    pub condition: MediumLevelExpressionIndex,
     pub dest_true: MediumLevelInstructionIndex,
     pub dest_false: MediumLevelInstructionIndex,
 }
@@ -51,7 +53,7 @@ pub struct LiftedConstData {
 // JUMP, RET_HINT
 #[derive(Debug, Copy, Clone)]
 pub struct Jump {
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedJump {
@@ -61,10 +63,10 @@ pub struct LiftedJump {
 // STORE_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct StoreSsa {
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
     pub dest_memory: u64,
     pub src_memory: u64,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreSsa {
@@ -77,11 +79,11 @@ pub struct LiftedStoreSsa {
 // STORE_STRUCT_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct StoreStructSsa {
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
     pub offset: u64,
     pub dest_memory: u64,
     pub src_memory: u64,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreStructSsa {
@@ -95,9 +97,9 @@ pub struct LiftedStoreStructSsa {
 // STORE_STRUCT
 #[derive(Debug, Copy, Clone)]
 pub struct StoreStruct {
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
     pub offset: u64,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreStruct {
@@ -109,8 +111,8 @@ pub struct LiftedStoreStruct {
 // STORE
 #[derive(Debug, Copy, Clone)]
 pub struct Store {
-    pub dest: usize,
-    pub src: usize,
+    pub dest: MediumLevelExpressionIndex,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStore {
@@ -121,7 +123,7 @@ pub struct LiftedStore {
 // JUMP_TO
 #[derive(Debug, Copy, Clone)]
 pub struct JumpTo {
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
     pub first_operand: usize,
     pub num_operands: usize,
 }
@@ -148,7 +150,7 @@ pub struct FreeVarSlot {
 pub struct SetVarField {
     pub dest: Variable,
     pub offset: u64,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarField {
@@ -161,8 +163,7 @@ pub struct LiftedSetVarField {
 #[derive(Debug, Copy, Clone)]
 pub struct SetVar {
     pub dest: Variable,
-    // TODO: Expression?
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVar {
@@ -183,7 +184,7 @@ pub struct SetVarSsaField {
     pub dest: SSAVariable,
     pub prev: SSAVariable,
     pub offset: u64,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSsaField {
@@ -198,7 +199,7 @@ pub struct LiftedSetVarSsaField {
 pub struct SetVarAliased {
     pub dest: SSAVariable,
     pub prev: SSAVariable,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarAliased {
@@ -211,7 +212,7 @@ pub struct LiftedSetVarAliased {
 #[derive(Debug, Copy, Clone)]
 pub struct SetVarSsa {
     pub dest: SSAVariable,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSsa {
@@ -257,7 +258,7 @@ pub struct VarSplit {
 pub struct SetVarSplit {
     pub high: Variable,
     pub low: Variable,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSplit {
@@ -278,7 +279,7 @@ pub struct VarSplitSsa {
 pub struct SetVarSplitSsa {
     pub high: SSAVariable,
     pub low: SSAVariable,
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSplitSsa {
@@ -290,8 +291,8 @@ pub struct LiftedSetVarSplitSsa {
 // ADD, SUB, AND, OR, XOR, LSL, LSR, ASR, ROL, ROR, MUL, MULU_DP, MULS_DP, DIVU, DIVU_DP, DIVS, DIVS_DP, MODU, MODU_DP, MODS, MODS_DP, CMP_E, CMP_NE, CMP_SLT, CMP_ULT, CMP_SLE, CMP_ULE, CMP_SGE, CMP_UGE, CMP_SGT, CMP_UGT, TEST_BIT, ADD_OVERFLOW, FCMP_E, FCMP_NE, FCMP_LT, FCMP_LE, FCMP_GE, FCMP_GT, FCMP_O, FCMP_UO, FADD, FSUB, FMUL, FDIV
 #[derive(Debug, Copy, Clone)]
 pub struct BinaryOp {
-    pub left: usize,
-    pub right: usize,
+    pub left: MediumLevelExpressionIndex,
+    pub right: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedBinaryOp {
@@ -302,9 +303,9 @@ pub struct LiftedBinaryOp {
 // ADC, SBB, RLC, RRC
 #[derive(Debug, Copy, Clone)]
 pub struct BinaryOpCarry {
-    pub left: usize,
-    pub right: usize,
-    pub carry: usize,
+    pub left: MediumLevelExpressionIndex,
+    pub right: MediumLevelExpressionIndex,
+    pub carry: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedBinaryOpCarry {
@@ -318,7 +319,7 @@ pub struct LiftedBinaryOpCarry {
 pub struct Call {
     pub first_output: usize,
     pub num_outputs: usize,
-    pub dest: usize,
+    pub dest: MediumLevelExpressionIndex,
     pub first_param: usize,
     pub num_params: usize,
 }
@@ -426,7 +427,7 @@ pub struct LiftedIntrinsicSsa {
 // MEMORY_INTRINSIC_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct MemoryIntrinsicSsa {
-    pub output: usize,
+    pub output: MediumLevelExpressionIndex,
     pub intrinsic: u32,
     pub first_param: usize,
     pub num_params: usize,
@@ -456,8 +457,8 @@ pub struct LiftedMemoryIntrinsicOutputSsa {
 // CALL_SSA, TAILCALL_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct CallSsa {
-    pub output: usize,
-    pub dest: usize,
+    pub output: MediumLevelExpressionIndex,
+    pub dest: MediumLevelExpressionIndex,
     pub first_param: usize,
     pub num_params: usize,
     pub src_memory: u64,
@@ -473,10 +474,10 @@ pub struct LiftedCallSsa {
 // CALL_UNTYPED_SSA, TAILCALL_UNTYPED_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct CallUntypedSsa {
-    pub output: usize,
-    pub dest: usize,
-    pub params: usize,
-    pub stack: usize,
+    pub output: MediumLevelExpressionIndex,
+    pub dest: MediumLevelExpressionIndex,
+    pub params: MediumLevelExpressionIndex,
+    pub stack: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCallUntypedSsa {
@@ -489,7 +490,7 @@ pub struct LiftedCallUntypedSsa {
 // SYSCALL_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct SyscallSsa {
-    pub output: usize,
+    pub output: MediumLevelExpressionIndex,
     pub first_param: usize,
     pub num_params: usize,
     pub src_memory: u64,
@@ -504,9 +505,9 @@ pub struct LiftedSyscallSsa {
 // SYSCALL_UNTYPED_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct SyscallUntypedSsa {
-    pub output: usize,
-    pub params: usize,
-    pub stack: usize,
+    pub output: MediumLevelExpressionIndex,
+    pub params: MediumLevelExpressionIndex,
+    pub stack: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSyscallUntypedSsa {
@@ -518,10 +519,10 @@ pub struct LiftedSyscallUntypedSsa {
 // CALL_UNTYPED, TAILCALL_UNTYPED
 #[derive(Debug, Copy, Clone)]
 pub struct CallUntyped {
-    pub output: usize,
-    pub dest: usize,
-    pub params: usize,
-    pub stack: usize,
+    pub output: MediumLevelExpressionIndex,
+    pub dest: MediumLevelExpressionIndex,
+    pub params: MediumLevelExpressionIndex,
+    pub stack: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCallUntyped {
@@ -534,9 +535,9 @@ pub struct LiftedCallUntyped {
 // SYSCALL_UNTYPED
 #[derive(Debug, Copy, Clone)]
 pub struct SyscallUntyped {
-    pub output: usize,
-    pub params: usize,
-    pub stack: usize,
+    pub output: MediumLevelExpressionIndex,
+    pub params: MediumLevelExpressionIndex,
+    pub stack: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSyscallUntyped {
@@ -548,7 +549,7 @@ pub struct LiftedSyscallUntyped {
 // NEG, NOT, SX, ZX, LOW_PART, BOOL_TO_INT, UNIMPL_MEM, FSQRT, FNEG, FABS, FLOAT_TO_INT, INT_TO_FLOAT, FLOAT_CONV, ROUND_TO_INT, FLOOR, CEIL, FTRUNC, LOAD
 #[derive(Debug, Copy, Clone)]
 pub struct UnaryOp {
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedUnaryOp {
@@ -558,7 +559,7 @@ pub struct LiftedUnaryOp {
 // LOAD_STRUCT
 #[derive(Debug, Copy, Clone)]
 pub struct LoadStruct {
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
     pub offset: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
@@ -570,7 +571,7 @@ pub struct LiftedLoadStruct {
 // LOAD_STRUCT_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct LoadStructSsa {
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
     pub offset: u64,
     pub src_memory: u64,
 }
@@ -584,7 +585,7 @@ pub struct LiftedLoadStructSsa {
 // LOAD_SSA
 #[derive(Debug, Copy, Clone)]
 pub struct LoadSsa {
-    pub src: usize,
+    pub src: MediumLevelExpressionIndex,
     pub src_memory: u64,
 }
 #[derive(Clone, Debug, PartialEq)]