Add basic block iterator methods and use moderner version of not(ndebug)

Author: TomBebbington

src/block.rs

@@ -69,15 +69,20 @@ pub struct BlockIter<'a> {
     pub min: &'a BasicBlock,
     pub max: &'a BasicBlock
 }
+impl<'a> BlockIter<'a> {
+    pub fn new(function: &'a Function) -> BlockIter<'a> {
+        BlockIter {
+            min: unsafe { core::LLVMGetFirstBasicBlock(function.into()).into() },
+            max: unsafe { core::LLVMGetLastBasicBlock(function.into()).into() }
+        }
+    }
+}
 
 impl<'a> IntoIterator for &'a Function {
     type IntoIter = BlockIter<'a>;
     type Item = &'a BasicBlock;
     fn into_iter(self) -> BlockIter<'a> {
-        BlockIter {
-            min: unsafe { core::LLVMGetFirstBasicBlock(self.into()).into() },
-            max: unsafe { core::LLVMGetLastBasicBlock(self.into()).into() }
-        }
+        BlockIter::new(self)
     }
 }
 impl<'a> Iterator for BlockIter<'a> {

src/engine.rs

@@ -102,7 +102,7 @@ impl<'a> JitEngine {
     /// This will check that the types match at runtime when in debug mode, but not release mode.
     /// You should make sure to use debug mode if you want it to error when the types don't match.
     pub fn with_function<C, A, R>(&self, function: &'a Function, cb: C) where A:Compile<'a>, R:Compile<'a>, C:FnOnce(extern "C" fn (A) -> R) {
-        if cfg!(not(ndebug)) {
+        if cfg!(debug_assertions) {
             let ctx = function.get_context();
             let sig = function.get_signature();
             assert_eq!(Type::get::<R>(ctx), sig.get_return());

src/value.rs

@@ -6,7 +6,7 @@ use std::ffi::CString;
 use std::{fmt, mem};
 use std::ops::{Deref, Index};
 use std::marker::PhantomData;
-use block::BasicBlock;
+use block::{BasicBlock, BlockIter};
 use context::{Context, GetContext};
 use types::{FunctionType, Type};
 use util::{self, Sub};
@@ -230,6 +230,10 @@ impl Function {
             core::LLVMAppendBasicBlockInContext(self.get_context().into(), self.into(), ptr).into()
         })
     }
+    /// Iterate through this function's basic blocks.
+    pub fn blocks(&self) -> BlockIter {
+        BlockIter::new(self)
+    }
     /// Returns the entry block of this function or `None` if there is none.
     pub fn get_entry(&self) -> Option<&BasicBlock> {
         unsafe { mem::transmute(core::LLVMGetEntryBasicBlock(self.into())) }