Removed reference requirement for op predicates

Author: TheDan64

examples/kaleidoscope/main.rs

@@ -946,12 +946,12 @@ impl<'a> Compiler<'a> {
                         '*' => Ok(self.builder.build_float_mul(&lhs, &rhs, "tmpmul")),
                         '/' => Ok(self.builder.build_float_div(&lhs, &rhs, "tmpdiv")),
                         '<' => Ok({
-                            let cmp = self.builder.build_float_compare(&FloatPredicate::ULT, &lhs, &rhs, "tmpcmp");
+                            let cmp = self.builder.build_float_compare(FloatPredicate::ULT, &lhs, &rhs, "tmpcmp");
 
                             self.builder.build_unsigned_int_to_float(&cmp, &self.context.f64_type(), "tmpbool")
                         }),
                         '>' => Ok({
-                            let cmp = self.builder.build_float_compare(&FloatPredicate::ULT, &rhs, &lhs, "tmpcmp");
+                            let cmp = self.builder.build_float_compare(FloatPredicate::ULT, &rhs, &lhs, "tmpcmp");
 
                             self.builder.build_unsigned_int_to_float(&cmp, &self.context.f64_type(), "tmpbool")
                         }),
@@ -1002,7 +1002,7 @@ impl<'a> Compiler<'a> {
 
                 // create condition by comparing without 0.0 and returning an int
                 let cond = self.compile_expr(cond)?;
-                let cond = self.builder.build_float_compare(&FloatPredicate::ONE, &cond, &zero_const, "ifcond");
+                let cond = self.builder.build_float_compare(FloatPredicate::ONE, &cond, &zero_const, "ifcond");
 
                 // build branch
                 let then_bb = self.context.append_basic_block(&parent, "then");
@@ -1073,7 +1073,7 @@ impl<'a> Compiler<'a> {
 
                 self.builder.build_store(&start_alloca, &next_var);
 
-                let end_cond = self.builder.build_float_compare(&FloatPredicate::ONE, &end_cond, &self.context.f64_type().const_float(0.0), "loopcond");
+                let end_cond = self.builder.build_float_compare(FloatPredicate::ONE, &end_cond, &self.context.f64_type().const_float(0.0), "loopcond");
                 let after_bb = self.context.append_basic_block(&parent, "afterloop");
 
                 self.builder.build_conditional_branch(&end_cond, &loop_bb, &after_bb);

src/builder.rs

@@ -789,7 +789,7 @@ impl Builder {
     }
 
     // SubType: <I>(&self, op, lhs: &IntValue<I>, rhs: &IntValue<I>, name) -> IntValue<bool> { ?
-    pub fn build_int_compare(&self, op: &IntPredicate, lhs: &IntValue, rhs: &IntValue, name: &str) -> IntValue {
+    pub fn build_int_compare(&self, op: IntPredicate, lhs: &IntValue, rhs: &IntValue, name: &str) -> IntValue {
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {
@@ -800,7 +800,7 @@ impl Builder {
     }
 
     // SubType: <F>(&self, op, lhs: &FloatValue<F>, rhs: &FloatValue<F>, name) -> IntValue<bool> { ?
-    pub fn build_float_compare(&self, op: &FloatPredicate, lhs: &FloatValue, rhs: &FloatValue, name: &str) -> IntValue {
+    pub fn build_float_compare(&self, op: FloatPredicate, lhs: &FloatValue, rhs: &FloatValue, name: &str) -> IntValue {
         let c_string = CString::new(name).expect("Conversion to CString failed unexpectedly");
 
         let value = unsafe {

src/values/int_value.rs

@@ -358,7 +358,7 @@ impl IntValue {
     }
 
     // SubType: rhs same as lhs; return IntValue<bool>
-    pub fn const_int_compare(&self, op: &IntPredicate, rhs: &IntValue) -> IntValue {
+    pub fn const_int_compare(&self, op: IntPredicate, rhs: &IntValue) -> IntValue {
         let value = unsafe {
             LLVMConstICmp(op.as_llvm_predicate(), self.as_value_ref(), rhs.as_value_ref())
         };