Fixed FunctionValue::get_return_type() and moved it to FunctionType

Author: TheDan64

src/types/fn_type.rs

@@ -1,4 +1,5 @@
-use llvm_sys::core::{LLVMGetParamTypes, LLVMIsFunctionVarArg, LLVMCountParamTypes};
+use llvm_sys::LLVMTypeKind;
+use llvm_sys::core::{LLVMGetParamTypes, LLVMIsFunctionVarArg, LLVMCountParamTypes, LLVMGetReturnType, LLVMGetTypeKind};
 use llvm_sys::prelude::LLVMTypeRef;
 
 use std::fmt;
@@ -10,7 +11,6 @@ use crate::support::LLVMString;
 use crate::types::traits::AsTypeRef;
 use crate::types::{PointerType, Type, BasicTypeEnum};
 
-// REVIEW: Add a get_return_type() -> Option<BasicTypeEnum>?
 /// A `FunctionType` is the type of a function variable.
 #[derive(PartialEq, Eq, Clone, Copy)]
 pub struct FunctionType {
@@ -167,6 +167,35 @@ impl FunctionType {
         self.fn_type.print_to_stderr()
     }
 
+    /// Gets the return type of this `FunctionType`.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use inkwell::context::Context;
+    ///
+    /// let context = Context::create();
+    /// let f32_type = context.f32_type();
+    /// let fn_type = f32_type.fn_type(&[], true);
+    ///
+    /// assert_eq!(fn_type.get_return_type().unwrap().into_float_type(), f32_type);
+    /// ```
+    pub fn get_return_type(&self) -> Option<BasicTypeEnum> {
+        let ty = unsafe {
+            LLVMGetReturnType(self.as_type_ref())
+        };
+
+        let kind = unsafe {
+            LLVMGetTypeKind(ty)
+        };
+
+        if let LLVMTypeKind::LLVMVoidTypeKind = kind {
+            return None;
+        }
+
+        Some(BasicTypeEnum::new(ty))
+    }
+
     // REVIEW: Can you do undef for functions?
     // Seems to "work" - no UB or SF so far but fails
     // LLVMIsAFunction() check. Commenting out for further research

src/values/fn_value.rs

@@ -1,5 +1,5 @@
 use llvm_sys::analysis::{LLVMVerifierFailureAction, LLVMVerifyFunction, LLVMViewFunctionCFG, LLVMViewFunctionCFGOnly};
-use llvm_sys::core::{LLVMIsAFunction, LLVMIsConstant, LLVMGetLinkage, LLVMTypeOf, LLVMGetPreviousFunction, LLVMGetNextFunction, LLVMGetParam, LLVMCountParams, LLVMGetLastParam, LLVMCountBasicBlocks, LLVMGetFirstParam, LLVMGetNextParam, LLVMGetBasicBlocks, LLVMGetReturnType, LLVMAppendBasicBlock, LLVMDeleteFunction, LLVMGetElementType, LLVMGetLastBasicBlock, LLVMGetFirstBasicBlock, LLVMGetEntryBasicBlock, LLVMGetIntrinsicID, LLVMGetFunctionCallConv, LLVMSetFunctionCallConv, LLVMGetGC, LLVMSetGC, LLVMSetLinkage, LLVMSetParamAlignment, LLVMGetParams};
+use llvm_sys::core::{LLVMIsAFunction, LLVMIsConstant, LLVMGetLinkage, LLVMGetPreviousFunction, LLVMGetNextFunction, LLVMGetParam, LLVMCountParams, LLVMGetLastParam, LLVMCountBasicBlocks, LLVMGetFirstParam, LLVMGetNextParam, LLVMGetBasicBlocks, LLVMAppendBasicBlock, LLVMDeleteFunction, LLVMGetLastBasicBlock, LLVMGetFirstBasicBlock, LLVMGetEntryBasicBlock, LLVMGetIntrinsicID, LLVMGetFunctionCallConv, LLVMSetFunctionCallConv, LLVMGetGC, LLVMSetGC, LLVMSetLinkage, LLVMSetParamAlignment, LLVMGetParams};
 #[llvm_versions(3.7 => latest)]
 use llvm_sys::core::{LLVMGetPersonalityFn, LLVMSetPersonalityFn};
 #[llvm_versions(3.9 => latest)]
@@ -15,9 +15,9 @@ use crate::attributes::Attribute;
 use crate::basic_block::BasicBlock;
 use crate::module::Linkage;
 use crate::support::LLVMString;
-use crate::types::{BasicTypeEnum, FunctionType};
+use crate::types::{FunctionType, PointerType};
 use crate::values::traits::AsValueRef;
-use crate::values::{BasicValueEnum, GlobalValue, Value, MetadataValue};
+use crate::values::{BasicValueEnum, GlobalValue, MetadataValue, Value};
 
 #[derive(PartialEq, Eq, Clone, Copy, Hash)]
 pub struct FunctionValue {
@@ -201,14 +201,6 @@ impl FunctionValue {
         raw_vec.iter().map(|val| BasicBlock::new(*val).unwrap()).collect()
     }
 
-    pub fn get_return_type(&self) -> BasicTypeEnum {
-        let type_ = unsafe {
-            LLVMGetReturnType(LLVMGetElementType(LLVMTypeOf(self.fn_value.value)))
-        };
-
-        BasicTypeEnum::new(type_)
-    }
-
     pub fn get_param_iter(&self) -> ParamValueIter {
         ParamValueIter {
             param_iter_value: self.fn_value.value,
@@ -262,7 +254,9 @@ impl FunctionValue {
     }
 
     pub fn get_type(&self) -> FunctionType {
-        FunctionType::new(self.fn_value.get_type())
+        let ptr_type = PointerType::new(self.fn_value.get_type());
+
+        ptr_type.get_element_type().into_function_type()
     }
 
     pub fn has_metadata(&self) -> bool {

tests/all/test_basic_block.rs

@@ -97,7 +97,7 @@ fn test_get_basic_blocks() {
     let function = module.add_function("testing", fn_type, None);
 
     assert_eq!(function.get_name(), &*CString::new("testing").unwrap());
-    assert_eq!(function.get_return_type().into_int_type().get_bit_width(), 1);
+    assert_eq!(fn_type.get_return_type().unwrap().into_int_type().get_bit_width(), 1);
 
     assert!(function.get_last_basic_block().is_none());
     assert_eq!(function.get_basic_blocks().len(), 0);

tests/all/test_values.rs

@@ -22,6 +22,10 @@ fn test_linkage() {
 
     let function = module.add_function("free_f32", fn_type, None);
 
+    assert_eq!(function.get_type(), fn_type);
+    assert!(function.get_type().get_return_type().is_none());
+    assert!(fn_type.get_return_type().is_none());
+
     assert_eq!(function.get_linkage(), External);
 }
 
@@ -686,8 +690,7 @@ fn test_function_value_no_params() {
     let fn_type = void_type.fn_type(&[], false);
     let fn_value = module.add_function("no_params", fn_type, None);
 
-    // REVIEW: According to this, fn_value.get_type() is a void ptr??
-    // assert_eq!(fn_value.get_type(), fn_type);
+    assert_eq!(fn_value.get_type(), fn_type);
     assert_eq!(fn_value.count_params(), 0);
     assert_eq!(fn_value.get_param_iter().collect::<Vec<_>>().len(), 0);
     assert_eq!(fn_value.get_params().len(), 0);