Rename get_type to get_struct_type and return StructType

as it can only ever return a StructType

Author: TheDan64

src/module.rs

@@ -38,7 +38,7 @@ use crate::execution_engine::ExecutionEngine;
 use crate::memory_buffer::MemoryBuffer;
 use crate::support::LLVMString;
 use crate::targets::{InitializationConfig, Target, TargetTriple};
-use crate::types::{AsTypeRef, BasicType, FunctionType, BasicTypeEnum};
+use crate::types::{AsTypeRef, BasicType, FunctionType, StructType};
 use crate::values::{AsValueRef, FunctionValue, GlobalValue, MetadataValue};
 #[llvm_versions(7.0..=latest)]
 use crate::values::BasicValue;
@@ -291,7 +291,7 @@ impl<'ctx> Module<'ctx> {
     }
 
 
-    /// Gets a `BasicTypeEnum` of a named type in a `Module`.
+    /// Gets a named `StructType` from this `Module`'s `Context`.
     ///
     /// # Example
     ///
@@ -301,24 +301,24 @@ impl<'ctx> Module<'ctx> {
     /// let context = Context::create();
     /// let module = context.create_module("my_module");
     ///
-    /// assert!(module.get_type("foo").is_none());
+    /// assert!(module.get_struct_type("foo").is_none());
     ///
     /// let opaque = context.opaque_struct_type("foo");
     ///
-    /// assert_eq!(module.get_type("foo").unwrap(), opaque.into());
+    /// assert_eq!(module.get_struct_type("foo").unwrap(), opaque);
     /// ```
-    pub fn get_type(&self, name: &str) -> Option<BasicTypeEnum<'ctx>> {
+    pub fn get_struct_type(&self, name: &str) -> Option<StructType<'ctx>> {
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
-        let type_ = unsafe {
+        let struct_type = unsafe {
             LLVMGetTypeByName(self.module.get(), c_string.as_ptr())
         };
 
-        if type_.is_null() {
+        if struct_type.is_null() {
             return None;
         }
 
-        Some(BasicTypeEnum::new(type_))
+        Some(StructType::new(struct_type))
     }
 
     /// Assigns a `TargetTriple` to this `Module`.

tests/all/test_context.rs

@@ -1,7 +1,5 @@
-extern crate inkwell;
-
-use self::inkwell::AddressSpace;
-use self::inkwell::context::Context;
+use inkwell::AddressSpace;
+use inkwell::context::Context;
 
 #[test]
 fn test_no_context_double_free() {
@@ -13,21 +11,6 @@ fn test_no_context_double_free() {
     }
 }
 
-// FIXME: This isn't actually safe and stopped working as
-// of a recent rust version (late 2018)
-// #[test]
-// fn test_no_context_double_free2() {
-//     let context = Context::create();
-//     let int = context.i8_type();
-//     let context2 = int.get_context();
-
-//     fn move_(_: Context) {}
-
-//     move_(context);
-
-//     context2.i8_type().const_int(0, false);
-// }
-
 #[test]
 fn test_no_context_double_free3() {
     unsafe {
@@ -58,14 +41,11 @@ fn test_basic_block_context() {
     let void_type = context.void_type();
     let fn_type = void_type.fn_type(&[], false);
     let fn_value = module.add_function("my_fn", fn_type, None);
-    // REVIEW: Should get rid of this if it uses global ctx?
     let basic_block = context.append_basic_block(fn_value, "entry");
 
     assert_eq!(*basic_block.get_context(), context);
 }
 
-// REVIEW: Is it bad that StructType, which uses global ctx, uses types of
-// a local context?
 #[test]
 fn test_values_get_context() {
     let context = Context::create();

tests/all/test_module.rs

@@ -146,30 +146,30 @@ fn test_garbage_ir_fails_create_module_from_ir_copy() {
 }
 
 #[test]
-fn test_get_type() {
+fn test_get_struct_type() {
     let context = Context::create();
     let module = context.create_module("my_module");
 
     assert_eq!(*module.get_context(), context);
-    assert!(module.get_type("foo").is_none());
+    assert!(module.get_struct_type("foo").is_none());
 
     let opaque = context.opaque_struct_type("foo");
 
-    assert_eq!(module.get_type("foo").unwrap().into_struct_type(), opaque);
+    assert_eq!(module.get_struct_type("foo").unwrap(), opaque);
 }
 
 #[test]
-fn test_get_type_global_context() {
+fn test_get_struct_type_global_context() {
     unsafe {
         Context::get_global(|context| {
             let module = context.create_module("my_module");
 
             assert_eq!(*module.get_context(), *context);
-            assert!(module.get_type("foo").is_none());
+            assert!(module.get_struct_type("foo").is_none());
 
             let opaque = context.opaque_struct_type("foo");
 
-            assert_eq!(module.get_type("foo").unwrap().into_struct_type(), opaque);
+            assert_eq!(module.get_struct_type("foo").unwrap(), opaque);
         })
     }
 }