Add ArrayType and VectorType functionality in new types

Author: TomBebbington

src/compile.rs

@@ -4,7 +4,7 @@ use ffi::prelude::LLVMValueRef;
 use context::Context;
 use libc::c_char;
 use value::Value;
-use ty::{StructType, FunctionType, PointerType, Type};
+use ty::*;
 use std::mem;
 use std::ffi::CStr;
 
@@ -157,7 +157,7 @@ macro_rules! compile_array(
                 unsafe { core::LLVMConstVector(values.as_ptr() as *mut LLVMValueRef, $num) }.into()
             }
             fn get_type(context: &'a Context) -> &'a Type {
-                Type::new_vector(Type::get::<T>(context), $num)
+                VectorType::new(Type::get::<T>(context), $num)
             }
         }
     )

src/ty.rs

@@ -35,14 +35,6 @@ impl Type {
     pub fn get<'a, T>(context:&'a Context) -> &'a Type where T:Compile<'a> {
         T::get_type(context)
     }
-    /// Make a new array with the length given.
-    pub fn new_array<'a>(element: &'a Type, length: usize) -> &'a Type {
-        unsafe { core::LLVMArrayType(element.into(), length as c_uint) }.into()
-    }
-    /// Make a new vector with the length given.
-    pub fn new_vector<'a>(element: &'a Type, length: usize) -> &'a Type {
-        unsafe { core::LLVMVectorType(element.into(), length as c_uint) }.into()
-    }
     /// Returns true if the size of the type is known at compile-time.
     ///
     /// This is equivalent to the type implementing `Sized` in Rust
@@ -196,4 +188,45 @@ impl IntegerType {
     pub fn get_width(&self) -> usize {
         unsafe { core::LLVMGetIntTypeWidth (self.into()) as usize }
     }
+}
+
+/// A vector type.
+pub struct VectorType;
+native_ref!{&VectorType = LLVMTypeRef}
+get_context!{VectorType, LLVMGetTypeContext}
+to_str!{VectorType, LLVMPrintTypeToString}
+sub!{VectorType, LLVMVectorTypeKind}
+impl VectorType {
+    /// Make a new vector type with the length given.
+    pub fn new(element: &Type, length: usize) -> &VectorType {
+        unsafe { core::LLVMVectorType(element.into(), length as c_uint) }.into()
+    }
+    /// Returns the element type of this vector type.
+    pub fn get_element(&self) -> &Type {
+        unsafe { mem::transmute(core::LLVMGetElementType(self.into())) }
+    }
+    /// Returns the number of elements in this vector type.
+    pub fn get_size(&self) -> usize {
+        unsafe { core::LLVMGetVectorSize(self.into()) as usize }
+    }
+}
+/// An array type.
+pub struct ArrayType;
+native_ref!{&ArrayType = LLVMTypeRef}
+get_context!{ArrayType, LLVMGetTypeContext}
+to_str!{ArrayType, LLVMPrintTypeToString}
+sub!{ArrayType, LLVMArrayTypeKind}
+impl ArrayType {
+    /// Make a new array type with the length given.
+    pub fn new(element: &Type, length: usize) -> &ArrayType {
+        unsafe { core::LLVMArrayType(element.into(), length as c_uint) }.into()
+    }
+    /// Returns the element type of this array type.
+    pub fn get_element(&self) -> &Type {
+        unsafe { mem::transmute(core::LLVMGetElementType(self.into())) }
+    }
+    /// Returns the number of elements in this vector type.
+    pub fn get_length(&self) -> usize {
+        unsafe { core::LLVMGetArrayLength(self.into()) as usize }
+    }
 }