Use new Sub instead of CastFrom, and use this to simplify casting code.

Author: TomBebbington

src/engine.rs

@@ -6,12 +6,11 @@ use ffi::target_machine::LLVMCodeModel;
 use cbox::{CBox, CSemiBox, DisposeRef};
 use std::marker::PhantomData;
 use std::{mem, ptr};
-use std::ops::*;
 use compile::Compile;
 use context::{Context, GetContext};
 use module::Module;
 use ty::{StructType, Type};
-use util::{self, CastFrom};
+use util::{self, Sub};
 use value::{Function, Value};
 
 /// An abstract interface for implementation execution of LLVM modules.
@@ -108,7 +107,7 @@ impl<'a> JitEngine {
             let sig = function.get_signature();
             assert_eq!(Type::get::<R>(ctx), sig.get_return());
             let arg = Type::get::<A>(ctx);
-            assert_eq!(sig.get_params(), if let Some(args) = StructType::cast(arg) {
+            assert_eq!(sig.get_params(), if let Some(args) = StructType::from_super(arg) {
                 args.get_elements()
             } else {
                 vec![arg]

src/lib.rs

@@ -34,4 +34,4 @@ pub use object::{ObjectFile, Symbol, Symbols};
 pub use target::{TargetData, Target};
 pub use ty::{FunctionType, StructType, Type};
 pub use value::{Alias, Arg, Attribute, Value, Function, GlobalValue, GlobalVariable, Linkage, Predicate};
-pub use util::CastFrom;
+pub use util::Sub;

src/ty.rs

@@ -4,7 +4,7 @@ use libc::{c_int, c_uint};
 use compile::Compile;
 use context::{Context, GetContext};
 use target::TargetData;
-use util::{self, CastFrom};
+use util::{self, Sub};
 use std::{fmt, mem};
 use std::marker::PhantomData;
 use std::iter::Iterator;
@@ -115,16 +115,11 @@ impl StructType {
         }
     }
 }
-impl CastFrom for StructType {
-    type From = Type;
-    fn cast(ty: &Type) -> Option<&StructType> {
+unsafe impl Sub<Type> for StructType {
+    fn is(ty: &Type) -> bool {
         unsafe {
             let kind = core::LLVMGetTypeKind(ty.into());
-            if kind as c_uint == LLVMTypeKind::LLVMStructTypeKind as c_uint {
-                mem::transmute(ty)
-            } else {
-                None
-            }
+            kind as c_uint == LLVMTypeKind::LLVMStructTypeKind as c_uint
         }
     }
 }
@@ -136,20 +131,14 @@ to_str!(StructType, LLVMPrintTypeToString);
 pub struct FunctionType;
 native_ref!(&FunctionType = LLVMTypeRef);
 deref!(FunctionType, Type);
-impl CastFrom for FunctionType {
-    type From = Type;
-    fn cast(mut ty: &Type) -> Option<&FunctionType> {
+unsafe impl Sub<Type> for FunctionType {
+    fn is(mut ty: &Type) -> bool {
         unsafe {
-            use libc::c_uint;
             while let Some(elem) = ty.get_element() {
                 ty = elem;
             }
             let kind = core::LLVMGetTypeKind(ty.into());
-            if kind as c_uint == LLVMTypeKind::LLVMFunctionTypeKind as c_uint {
-                mem::transmute(ty)
-            } else {
-                None
-            }
+            kind as c_uint == LLVMTypeKind::LLVMFunctionTypeKind as c_uint
         }
     }
 }

src/util.rs

@@ -1,15 +1,24 @@
 use libc::c_char;
 use std::ffi::{CStr, CString};
+use std::mem;
 use std::str;
-
-/// Cast from one type into another
-pub trait CastFrom {
-    /// The type that can be casted from.
-    type From;
-    /// Cast it
-    fn cast<'a>(ty: &'a Self::From) -> Option<&'a Self>;
+/// Indicates that this structure is a substructure of another.
+pub unsafe trait Sub<T>: Sized {
+    /// Check if the given super value is an instance of this type.
+    fn is(c: &T) -> bool;
+    /// Attempt to cast the given super value into an instance of this type.
+    fn from_super(c: &T) -> Option<&Self> {
+        if Self::is(c) {
+            Some(unsafe { mem::transmute(c) })
+        } else {
+            None
+        }
+    }
+    /// Cast this value to a super value.
+    fn to_super(&self) -> &T {
+        unsafe { mem::transmute(self) }
+    }
 }
-
 #[inline(always)]
 pub fn with_cstr<C, R>(text: &str, cb: C) -> R where C:FnOnce(*const c_char) -> R {
     let c_text = CString::new(text).unwrap();

src/value.rs

@@ -8,7 +8,31 @@ use std::ops::{Deref, Index};
 use block::BasicBlock;
 use context::{Context, GetContext};
 use ty::{FunctionType, Type};
-use util::{self, CastFrom};
+use util::{self, Sub};
+
+macro_rules! sub {
+    ($this:ty, $name:ident) => (
+        sub!{$this, $name, ::Value}
+    );
+    ($this:ty, $name:ident, $sup:ty) => (
+unsafe impl Sub<$sup> for $this {
+    fn is(value: &$sup) -> bool {
+        unsafe {
+            !core::$name(value.into()).is_null()
+        }
+    }
+    fn from_super(value: &$sup) -> Option<&$this> {
+        unsafe { mem::transmute(core::$name(value.into())) }
+    }
+}
+impl Deref for $this {
+    type Target = $sup;
+    fn deref(&self) -> &$sup {
+        self.to_super()
+    }
+}
+    )
+}
 
 /// A typed value that can be used as an operand in instructions.
 pub struct Value;
@@ -66,12 +90,7 @@ pub enum Predicate {
 /// An argument that is passed to a function.
 pub struct Arg;
 native_ref!(&Arg = LLVMValueRef);
-impl Deref for Arg {
-    type Target = Value;
-    fn deref(&self) -> &Value {
-        unsafe { mem::transmute(self) }
-    }
-}
+sub!{Arg, LLVMIsAArgument}
 impl Arg {
     /// Add the attribute given to this argument.
     pub fn add_attribute(&self, attr: Attribute) {
@@ -114,21 +133,7 @@ impl Arg {
 /// A value with global scope (eg: Function, Alias, Global variable)
 pub struct GlobalValue;
 native_ref!(&GlobalValue = LLVMValueRef);
-impl Deref for GlobalValue {
-    type Target = Value;
-    fn deref(&self) -> &Value {
-        unsafe { mem::transmute(self) }
-    }
-}
-impl CastFrom for GlobalValue {
-    type From = Value;
-    fn cast<'a>(val: &'a Value) -> Option<&'a GlobalValue> {
-        unsafe {
-            let global = mem::transmute(core::LLVMIsAGlobalValue(val.into()));
-            util::ptr_to_null(global)
-        }
-    }
-}
+sub!{GlobalValue, LLVMIsAGlobalValue}
 impl GlobalValue {
     /// Set the linkage type for this global
     pub fn set_linkage(&self, linkage: Linkage) {
@@ -154,21 +159,7 @@ impl GlobalValue {
 /// A global variable
 pub struct GlobalVariable;
 native_ref!(&GlobalVariable = LLVMValueRef);
-impl Deref for GlobalVariable {
-    type Target = GlobalValue;
-    fn deref(&self) -> &GlobalValue {
-        unsafe { mem::transmute(self) }
-    }
-}
-impl CastFrom for GlobalVariable {
-    type From = Value;
-    fn cast<'a>(val: &'a Value) -> Option<&'a GlobalVariable> {
-        unsafe {
-            let global = mem::transmute(core::LLVMIsAGlobalVariable(val.into()));
-            util::ptr_to_null(global)
-        }
-    }
-}
+sub!{GlobalVariable, LLVMIsAGlobalVariable, GlobalValue}
 impl GlobalVariable {
     /// Set the initial value of the global
     pub fn set_initializer(&self, val: &Value) {
@@ -200,34 +191,14 @@ impl GlobalVariable {
 /// An alias to another global value.
 pub struct Alias;
 native_ref!(&Alias = LLVMValueRef);
-impl Deref for Alias {
-    type Target = GlobalValue;
-    fn deref(&self) -> &GlobalValue {
-        unsafe { mem::transmute(self) }
-    }
-}
-impl CastFrom for Alias {
-    type From = Value;
-    fn cast<'a>(val: &'a Value) -> Option<&'a Alias> {
-        unsafe {
-            let alias = mem::transmute(core::LLVMIsAGlobalAlias(val.into()));
-            util::ptr_to_null(alias)
-        }
-    }
-}
-
+sub!{Alias, LLVMIsAGlobalAlias, GlobalValue}
 /// A function is a kind of value that can be called and contains blocks of code.
 ///
 /// To get the value of each argument to a function, you can use the index operator.
 /// For example, `&func[0]` is the value that represents the first argument to the function.
 pub struct Function;
 native_ref!(&Function = LLVMValueRef);
-impl Deref for Function {
-    type Target = GlobalValue;
-    fn deref(&self) -> &GlobalValue {
-        unsafe { mem::transmute(self) }
-    }
-}
+sub!{Function, LLVMIsAFunction, GlobalValue}
 impl Index<usize> for Function {
     type Output = Arg;
     fn index(&self, index: usize) -> &Arg {
@@ -240,19 +211,13 @@ impl Index<usize> for Function {
         }
     }
 }
-impl CastFrom for Function {
-    type From = Value;
-    fn cast<'a>(val: &'a Value) -> Option<&'a Function> {
-        let ty = val.get_type();
-        let mut is_func = ty.is_function();
-        if let Some(elem) = ty.get_element() {
-            is_func = is_func || elem.is_function()
-        }
-        if is_func {
-            Some(unsafe { mem::transmute(val) })
-        } else {
-            None
+unsafe impl Sub<Value> for Function {
+    fn is(value: &Value) -> bool {
+        let mut ty = value.get_type();
+        while let Some(elem) = ty.get_element() {
+            ty = elem;
         }
+        ty.is_function()
     }
 }
 impl Function {