Moved is_sized method into BasicType trait

Author: TheDan64

src/builder.rs

@@ -12,7 +12,7 @@ use crate::basic_block::BasicBlock;
 use crate::values::{AggregateValue, AggregateValueEnum, AsValueRef, BasicValue, BasicValueEnum, PhiValue, FunctionValue, IntValue, PointerValue, VectorValue, InstructionValue, GlobalValue, IntMathValue, FloatMathValue, PointerMathValue, InstructionOpcode, CallSiteValue};
 #[llvm_versions(3.9..=latest)]
 use crate::values::StructValue;
-use crate::types::{AsTypeRef, BasicType, BasicTypeEnum, IntMathType, FloatMathType, PointerType, PointerMathType};
+use crate::types::{AsTypeRef, BasicType, IntMathType, FloatMathType, PointerType, PointerMathType};
 
 use std::ffi::CString;
 use std::marker::PhantomData;
@@ -350,15 +350,7 @@ impl<'ctx> Builder<'ctx> {
     // TODOC: Heap allocation
     pub fn build_malloc<T: BasicType<'ctx>>(&self, ty: T, name: &str) -> Result<PointerValue<'ctx>, &'static str> {
         // LLVMBulidMalloc segfaults if ty is unsized
-        let is_sized = match ty.as_basic_type_enum() {
-            BasicTypeEnum::ArrayType(ty) => ty.is_sized(),
-            BasicTypeEnum::FloatType(ty) => ty.is_sized(),
-            BasicTypeEnum::IntType(ty) => ty.is_sized(),
-            BasicTypeEnum::PointerType(ty) => ty.is_sized(),
-            BasicTypeEnum::StructType(ty) => ty.is_sized(),
-            BasicTypeEnum::VectorType(ty) => ty.is_sized(),
-        };
-        if !is_sized {
+        if !ty.is_sized() {
             return Err("Cannot build malloc call for an unsized type");
         }
 
@@ -379,15 +371,7 @@ impl<'ctx> Builder<'ctx> {
         name: &str
     ) -> Result<PointerValue<'ctx>, &'static str> {
         // LLVMBulidArrayMalloc segfaults if ty is unsized
-        let is_sized = match ty.as_basic_type_enum() {
-            BasicTypeEnum::ArrayType(ty) => ty.is_sized(),
-            BasicTypeEnum::FloatType(ty) => ty.is_sized(),
-            BasicTypeEnum::IntType(ty) => ty.is_sized(),
-            BasicTypeEnum::PointerType(ty) => ty.is_sized(),
-            BasicTypeEnum::StructType(ty) => ty.is_sized(),
-            BasicTypeEnum::VectorType(ty) => ty.is_sized(),
-        };
-        if !is_sized {
+        if !ty.is_sized() {
             return Err("Cannot build array malloc call for an unsized type");
         }
 

src/types/array_type.rs

@@ -5,7 +5,7 @@ use crate::AddressSpace;
 use crate::context::ContextRef;
 use crate::support::LLVMString;
 use crate::types::traits::AsTypeRef;
-use crate::types::{Type, BasicTypeEnum, PointerType, FunctionType};
+use crate::types::{Type, BasicTypeEnum, BasicType, PointerType, FunctionType};
 use crate::values::{AsValueRef, ArrayValue, IntValue};
 
 /// An `ArrayType` is the type of contiguous constants or variables.
@@ -23,24 +23,6 @@ impl<'ctx> ArrayType<'ctx> {
         }
     }
 
-    // REVIEW: Can be unsized if inner type is opaque struct
-    /// Gets whether or not this `ArrayType` is sized or not.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let i8_type = context.i8_type();
-    /// let i8_array_type = i8_type.array_type(3);
-    ///
-    /// assert!(i8_array_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.array_type.is_sized()
-    }
-
     // TODO: impl only for ArrayType<!StructType<Opaque>>
     /// Gets the size of this `ArrayType`. Value may vary depending on the target architecture.
     ///

src/types/float_type.rs

@@ -150,24 +150,6 @@ impl<'ctx> FloatType<'ctx> {
         FloatValue::new(self.float_type.const_zero())
     }
 
-    // REVIEW: Always true -> const fn?
-    /// Gets whether or not this `FloatType` is sized or not. This is likely
-    /// always true and may be removed in the future.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let f32_type = context.f32_type();
-    ///
-    /// assert!(f32_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.float_type.is_sized()
-    }
-
     /// Gets the size of this `FloatType`. Value may vary depending on the target architecture.
     ///
     /// # Example

src/types/int_type.rs

@@ -249,24 +249,6 @@ impl<'ctx> IntType<'ctx> {
         self.int_type.get_context()
     }
 
-    // REVIEW: Always true -> const fn on trait?
-    /// Gets whether or not this `IntType` is sized or not. This is likely
-    /// always true and may be removed in the future.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let i8_type = context.i8_type();
-    ///
-    /// assert!(i8_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.int_type.is_sized()
-    }
-
     /// Gets the size of this `IntType`. Value may vary depending on the target architecture.
     ///
     /// # Example

src/types/ptr_type.rs

@@ -5,7 +5,7 @@ use crate::AddressSpace;
 use crate::context::ContextRef;
 use crate::support::LLVMString;
 use crate::types::traits::AsTypeRef;
-use crate::types::{AnyTypeEnum, Type, BasicTypeEnum, ArrayType, FunctionType, VectorType};
+use crate::types::{AnyTypeEnum, BasicTypeEnum, ArrayType, FunctionType, Type, VectorType};
 use crate::values::{AsValueRef, ArrayValue, PointerValue, IntValue};
 
 use std::convert::TryFrom;
@@ -25,26 +25,6 @@ impl<'ctx> PointerType<'ctx> {
         }
     }
 
-    // REVIEW: Always true -> const fn on trait?
-    /// Gets whether or not this `PointerType` is sized or not. This is likely
-    /// always true and may be removed in the future.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    /// use inkwell::AddressSpace;
-    ///
-    /// let context = Context::create();
-    /// let i8_type = context.i8_type();
-    /// let i8_ptr_type = i8_type.ptr_type(AddressSpace::Generic);
-    ///
-    /// assert!(i8_ptr_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.ptr_type.is_sized()
-    }
-
     /// Gets the size of this `PointerType`. Value may vary depending on the target architecture.
     ///
     /// # Example

src/types/struct_type.rs

@@ -10,7 +10,7 @@ use crate::AddressSpace;
 use crate::context::ContextRef;
 use crate::support::LLVMString;
 use crate::types::traits::AsTypeRef;
-use crate::types::{Type, BasicTypeEnum, ArrayType, PointerType, FunctionType};
+use crate::types::{ArrayType, BasicType, BasicTypeEnum, PointerType, FunctionType, Type};
 use crate::values::{ArrayValue, BasicValueEnum, StructValue, IntValue, AsValueRef};
 
 /// A `StructType` is the type of a heterogeneous container of types.
@@ -103,25 +103,6 @@ impl<'ctx> StructType<'ctx> {
         StructValue::new(self.struct_type.const_zero())
     }
 
-    // REVIEW: Can be false if opaque. To make a const fn, we'd have to have
-    // have separate impls for Struct<Opaque> and StructType<T*>
-    /// Gets whether or not this `StructType` is sized or not.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let f32_type = context.f32_type();
-    /// let f32_struct_type = context.struct_type(&[f32_type.into()], false);
-    ///
-    /// assert!(f32_struct_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.struct_type.is_sized()
-    }
-
     // TODO: impl it only for StructType<T*>?
     /// Gets the size of this `StructType`. Value may vary depending on the target architecture.
     ///

src/types/traits.rs

@@ -41,7 +41,8 @@ pub trait BasicType<'ctx>: AnyType<'ctx> {
 
     /// Create a `FunctionType` with this `BasicType` as its return type.
     ///
-    /// Example:
+    /// # Example:
+    ///
     /// ```no_run
     /// use inkwell::context::Context;
     /// use inkwell::types::BasicType;
@@ -55,6 +56,25 @@ pub trait BasicType<'ctx>: AnyType<'ctx> {
         Type::new(self.as_type_ref()).fn_type(param_types, is_var_args)
     }
 
+    /// Determines whether or not this `BasicType` is sized or not.
+    /// For example, opaque structs are unsized.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use inkwell::context::Context;
+    /// use inkwell::types::BasicType;
+    ///
+    /// let context = Context::create();
+    /// let f32_type = context.f32_type();
+    /// let f32_vec_type = f32_type.vec_type(40);
+    ///
+    /// assert!(f32_vec_type.is_sized());
+    /// ```
+    fn is_sized(&self) -> bool {
+        Type::new(self.as_type_ref()).is_sized()
+    }
+
     /// Create an `ArrayType` with this `BasicType` as its elements.
     ///
     /// Example:
@@ -67,7 +87,6 @@ pub trait BasicType<'ctx>: AnyType<'ctx> {
     /// let int_basic_type = int.as_basic_type_enum();
     /// assert_eq!(int_basic_type.array_type(32), int.array_type(32));
     /// ```
-    // FIXME: We shouldn't be able to create arrays of void types
     fn array_type(&self, size: u32) -> ArrayType<'ctx> {
         Type::new(self.as_type_ref()).array_type(size)
     }
@@ -86,7 +105,6 @@ pub trait BasicType<'ctx>: AnyType<'ctx> {
     /// let addr_space = AddressSpace::Generic;
     /// assert_eq!(int_basic_type.ptr_type(addr_space), int.ptr_type(addr_space));
     /// ```
-    // FIXME: We shouldn't be able to create pointer of void types
     fn ptr_type(&self, address_space: AddressSpace) -> PointerType<'ctx> {
         Type::new(self.as_type_ref()).ptr_type(address_space)
     }

src/types/vec_type.rs

@@ -4,7 +4,7 @@ use llvm_sys::prelude::{LLVMTypeRef, LLVMValueRef};
 use crate::AddressSpace;
 use crate::context::ContextRef;
 use crate::support::LLVMString;
-use crate::types::{ArrayType, BasicTypeEnum, Type, traits::AsTypeRef, FunctionType, PointerType};
+use crate::types::{ArrayType, BasicTypeEnum, BasicType, Type, traits::AsTypeRef, FunctionType, PointerType};
 use crate::values::{AsValueRef, ArrayValue, BasicValue, VectorValue, IntValue};
 
 /// A `VectorType` is the type of a multiple value SIMD constant or variable.
@@ -22,26 +22,8 @@ impl<'ctx> VectorType<'ctx> {
         }
     }
 
-    // REVIEW: Can be unsized if inner type is opaque struct
-    /// Gets whether or not this `VectorType` is sized or not.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use inkwell::context::Context;
-    ///
-    /// let context = Context::create();
-    /// let f32_type = context.f32_type();
-    /// let f32_vec_type = f32_type.vec_type(40);
-    ///
-    /// assert!(f32_vec_type.is_sized());
-    /// ```
-    pub fn is_sized(&self) -> bool {
-        self.vec_type.is_sized()
-    }
-
     // TODO: impl only for VectorType<!StructType<Opaque>>
-    // REVIEW: What about Opaque struct hiding in deeper levels?
+    // REVIEW: What about Opaque struct hiding in deeper levels
     // like VectorType<ArrayType<StructType<Opaque>>>?
     /// Gets the size of this `VectorType`. Value may vary depending on the target architecture.
     ///

src/values/traits.rs

@@ -90,7 +90,7 @@ pub trait BasicValue<'ctx>: AnyValue<'ctx> {
     }
 
     // REVIEW: Possible encompassing methods to implement:
-    // is_sized, get/set metadata
+    // get/set metadata
 }
 
 /// Represents a value which is permitted in integer math operations