Allow obtaining BasicBlock from get_used_value

Author: TheDan64

src/values/basic_value_use.rs

@@ -1,7 +1,10 @@
-use values::{BasicValueEnum, InstructionValue};
-use llvm_sys::core::{LLVMGetNextUse, LLVMGetUser, LLVMGetUsedValue};
+use either::{Either, Either::{Left, Right}};
+use llvm_sys::core::{LLVMGetNextUse, LLVMGetUser, LLVMGetUsedValue, LLVMIsABasicBlock, LLVMValueAsBasicBlock};
 use llvm_sys::prelude::LLVMUseRef;
 
+use basic_block::BasicBlock;
+use values::{BasicValueEnum, InstructionValue};
+
 /// A usage of a `BasicValue` in an `InstructionValue`.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct BasicValueUse(LLVMUseRef);
@@ -118,7 +121,7 @@ impl BasicValueUse {
         InstructionValue::new(user)
     }
 
-    /// Gets the used value(a `BasicValueEnum`) of this use.
+    /// Gets the used value(a `BasicValueEnum` or `BasicBlock`) of this use.
     ///
     /// ```no_run
     /// use inkwell::AddressSpace;
@@ -149,15 +152,29 @@ impl BasicValueUse {
     /// let bitcast_use_value = free_operand0_instruction
     ///     .get_first_use()
     ///     .unwrap()
-    ///     .get_used_value();
+    ///     .get_used_value()
+    ///     .left()
+    ///     .unwrap();
     ///
     /// assert_eq!(bitcast_use_value, free_operand0);
     /// ```
-    pub fn get_used_value(&self) -> BasicValueEnum {
+    pub fn get_used_value(&self) -> Either<BasicValueEnum, BasicBlock> {
         let used_value = unsafe {
             LLVMGetUsedValue(self.0)
         };
 
-        BasicValueEnum::new(used_value)
+        let is_basic_block = unsafe {
+            !LLVMIsABasicBlock(used_value).is_null()
+        };
+
+        if is_basic_block {
+            let used_value = unsafe {
+                LLVMValueAsBasicBlock(used_value)
+            };
+
+            Right(BasicBlock::new(used_value).expect("BasicBlock should be valid"))
+        } else {
+            Left(BasicValueEnum::new(used_value))
+        }
     }
 }

tests/all/test_instruction_values.rs

@@ -83,7 +83,9 @@ fn test_operands() {
     let bitcast_use_value = free_operand0_instruction
         .get_first_use()
         .unwrap()
-        .get_used_value();
+        .get_used_value()
+        .left()
+        .unwrap();
     let free_call_param = free_instruction.get_operand(0).unwrap().left().unwrap();
 
     assert_eq!(bitcast_use_value, free_call_param);
@@ -109,8 +111,8 @@ fn test_operands() {
 
     assert_eq!(store_operand_use0.get_user(), store_instruction);
     assert_eq!(store_operand_use1.get_user(), store_instruction);
-    assert_eq!(store_operand_use0.get_used_value(), f32_val);
-    assert_eq!(store_operand_use1.get_used_value(), arg1);
+    assert_eq!(store_operand_use0.get_used_value().left().unwrap(), f32_val);
+    assert_eq!(store_operand_use1.get_used_value().left().unwrap(), arg1);
 
     assert!(store_instruction.get_operand_use(2).is_none());
     assert!(store_instruction.get_operand_use(3).is_none());
@@ -150,6 +152,10 @@ fn test_basic_block_operand() {
 
     assert_eq!(bb_operand, basic_block2);
 
+    let bb_operand_use = branch_instruction.get_operand_use(0).unwrap();
+
+    assert_eq!(bb_operand_use.get_used_value().right().unwrap(), basic_block2);
+
     builder.position_at_end(&basic_block2);
     builder.build_return(None);