Fixed tests and examples from ownership change

Author: cpdt

README.md

@@ -106,8 +106,8 @@ fn jit_compile_sum(
     let y = function.get_nth_param(1)?.into_int_value();
     let z = function.get_nth_param(2)?.into_int_value();
 
-    let sum = builder.build_int_add(&x, &y, "sum");
-    let sum = builder.build_int_add(&sum, &z, "sum");
+    let sum = builder.build_int_add(x, y, "sum");
+    let sum = builder.build_int_add(sum, z, "sum");
 
     builder.build_return(Some(&sum));
 

examples/jit.rs

@@ -32,8 +32,8 @@ fn jit_compile_sum(
     let y = function.get_nth_param(1)?.into_int_value();
     let z = function.get_nth_param(2)?.into_int_value();
 
-    let sum = builder.build_int_add(&x, &y, "sum");
-    let sum = builder.build_int_add(&sum, &z, "sum");
+    let sum = builder.build_int_add(x, y, "sum");
+    let sum = builder.build_int_add(sum, z, "sum");
 
     builder.build_return(Some(&sum));
 

examples/kaleidoscope/main.rs

@@ -941,19 +941,19 @@ impl<'a> Compiler<'a> {
                     let rhs = self.compile_expr(right)?;
 
                     match op {
-                        '+' => Ok(self.builder.build_float_add(&lhs, &rhs, "tmpadd")),
-                        '-' => Ok(self.builder.build_float_sub(&lhs, &rhs, "tmpsub")),
-                        '*' => Ok(self.builder.build_float_mul(&lhs, &rhs, "tmpmul")),
-                        '/' => Ok(self.builder.build_float_div(&lhs, &rhs, "tmpdiv")),
+                        '+' => Ok(self.builder.build_float_add(lhs, rhs, "tmpadd")),
+                        '-' => Ok(self.builder.build_float_sub(lhs, rhs, "tmpsub")),
+                        '*' => 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")
+                            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")
+                            self.builder.build_unsigned_int_to_float(cmp, self.context.f64_type(), "tmpbool")
                         }),
 
                         custom => {
@@ -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");
@@ -1069,11 +1069,11 @@ impl<'a> Compiler<'a> {
                 let end_cond = self.compile_expr(end)?;
 
                 let curr_var = self.builder.build_load(&start_alloca, var_name);
-                let next_var = self.builder.build_float_add(curr_var.as_float_value(), &step, "nextvar");
+                let next_var = self.builder.build_float_add(curr_var.into_float_value(), step, "nextvar");
 
                 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

@@ -594,7 +594,7 @@ impl Builder {
     ///
     /// builder.position_at_end(&entry_block);
     ///
-    /// let shift = builder.build_left_shift(&value, &n, "left_shift"); // value << n
+    /// let shift = builder.build_left_shift(value, n, "left_shift"); // value << n
     ///
     /// builder.build_return(Some(&shift));
     /// ```
@@ -663,7 +663,7 @@ impl Builder {
     ///
     /// // Whether or not your right shift is sign extended (true) or logical (false) depends
     /// // on the boolean input parameter:
-    /// let shift = builder.build_right_shift(&value, &n, false, "right_shift"); // value >> n
+    /// let shift = builder.build_right_shift(value, n, false, "right_shift"); // value >> n
     ///
     /// builder.build_return(Some(&shift));
     /// ```

tests/test_builder.rs

@@ -68,7 +68,7 @@ fn test_null_checked_ptr_ops() {
 
     let ptr = function.get_first_param().unwrap().into_pointer_value();
 
-    let is_null = builder.build_is_null(&ptr, "is_null");
+    let is_null = builder.build_is_null(ptr, "is_null");
 
     let ret_0 = function.append_basic_block("ret_0");
     let ret_idx = function.append_basic_block("ret_idx");
@@ -82,9 +82,9 @@ fn test_null_checked_ptr_ops() {
 
     // FIXME: This might not work if compiled on non 64bit devices. Ideally we'd
     // be able to create pointer sized ints easily
-    let ptr_as_int = builder.build_ptr_to_int(&ptr, &i64_type, "ptr_as_int");
-    let new_ptr_as_int = builder.build_int_add(&ptr_as_int, &one, "add");
-    let new_ptr = builder.build_int_to_ptr(&new_ptr_as_int, &i8_ptr_type, "int_as_ptr");
+    let ptr_as_int = builder.build_ptr_to_int(ptr, i64_type, "ptr_as_int");
+    let new_ptr_as_int = builder.build_int_add(ptr_as_int, one, "add");
+    let new_ptr = builder.build_int_to_ptr(new_ptr_as_int, i8_ptr_type, "int_as_ptr");
     let index1 = builder.build_load(&new_ptr, "deref");
 
     builder.build_return(Some(&index1));
@@ -105,7 +105,7 @@ fn test_null_checked_ptr_ops() {
 
     let ptr = function.get_first_param().unwrap().into_pointer_value();
 
-    let is_not_null = builder.build_is_not_null(&ptr, "is_not_null");
+    let is_not_null = builder.build_is_not_null(ptr, "is_not_null");
 
     let ret_idx = function.append_basic_block("ret_idx");
     let ret_0 = function.append_basic_block("ret_0");
@@ -119,9 +119,9 @@ fn test_null_checked_ptr_ops() {
 
     // FIXME: This might not work if compiled on non 64bit devices. Ideally we'd
     // be able to create pointer sized ints easily
-    let ptr_as_int = builder.build_ptr_to_int(&ptr, &i64_type, "ptr_as_int");
-    let new_ptr_as_int = builder.build_int_add(&ptr_as_int, &one, "add");
-    let new_ptr = builder.build_int_to_ptr(&new_ptr_as_int, &i8_ptr_type, "int_as_ptr");
+    let ptr_as_int = builder.build_ptr_to_int(ptr, i64_type, "ptr_as_int");
+    let new_ptr_as_int = builder.build_int_add(ptr_as_int, one, "add");
+    let new_ptr = builder.build_int_to_ptr(new_ptr_as_int, i8_ptr_type, "int_as_ptr");
     let index1 = builder.build_load(&new_ptr, "deref");
 
     builder.build_return(Some(&index1));
@@ -167,7 +167,7 @@ fn test_binary_ops() {
     let left = fn_value.get_first_param().unwrap().into_int_value();
     let right = fn_value.get_last_param().unwrap().into_int_value();
 
-    let and = builder.build_and(&left, &right, "and_op");
+    let and = builder.build_and(left, right, "and_op");
 
     builder.build_return(Some(&and));
 
@@ -184,7 +184,7 @@ fn test_binary_ops() {
     let left = fn_value.get_first_param().unwrap().into_int_value();
     let right = fn_value.get_last_param().unwrap().into_int_value();
 
-    let or = builder.build_or(&left, &right, "or_op");
+    let or = builder.build_or(left, right, "or_op");
 
     builder.build_return(Some(&or));
 
@@ -201,7 +201,7 @@ fn test_binary_ops() {
     let left = fn_value.get_first_param().unwrap().into_int_value();
     let right = fn_value.get_last_param().unwrap().into_int_value();
 
-    let xor = builder.build_xor(&left, &right, "xor_op");
+    let xor = builder.build_xor(left, right, "xor_op");
 
     builder.build_return(Some(&xor));
 
@@ -274,7 +274,7 @@ fn test_switch() {
 
     builder.position_at_end(&else_);
 
-    let double = builder.build_int_mul(&value, &i8_two, "double");
+    let double = builder.build_int_mul(value, i8_two, "double");
 
     builder.build_return(Some(&double));
 
@@ -312,7 +312,7 @@ fn test_bit_shifts() {
 
     builder.position_at_end(&entry);
 
-    let shift = builder.build_left_shift(&value, &bits, "shl");
+    let shift = builder.build_left_shift(value, bits, "shl");
 
     builder.build_return(Some(&shift));
 
@@ -328,7 +328,7 @@ fn test_bit_shifts() {
 
     builder.position_at_end(&entry);
 
-    let shift = builder.build_right_shift(&value, &bits, false, "shr");
+    let shift = builder.build_right_shift(value, bits, false, "shr");
 
     builder.build_return(Some(&shift));
 
@@ -344,7 +344,7 @@ fn test_bit_shifts() {
 
     builder.position_at_end(&entry);
 
-    let shift = builder.build_right_shift(&value, &bits, true, "shr");
+    let shift = builder.build_right_shift(value, bits, true, "shr");
 
     builder.build_return(Some(&shift));
 

tests/test_execution_engine.rs

@@ -81,7 +81,7 @@ fn test_jit_execution_engine() {
     builder.position_at_end(&check_argc);
 
     let eq = IntPredicate::EQ;
-    let argc_check = builder.build_int_compare(eq, &main_argc, &three_i32, "argc_cmp");
+    let argc_check = builder.build_int_compare(eq, main_argc, three_i32, "argc_cmp");
 
     builder.build_conditional_branch(&argc_check, &check_arg3, &error1);
 

tests/test_tari_example.rs

@@ -26,8 +26,8 @@ fn test_tari_example() {
     let y = function.get_nth_param(1).unwrap().into_int_value();
     let z = function.get_nth_param(2).unwrap().into_int_value();
 
-    let sum = builder.build_int_add(&x, &y, "sum");
-    let sum = builder.build_int_add(&sum, &z, "sum");
+    let sum = builder.build_int_add(x, y, "sum");
+    let sum = builder.build_int_add(sum, z, "sum");
 
     builder.build_return(Some(&sum));
 

tests/test_values.rs

@@ -46,8 +46,8 @@ fn test_instructions() {
     let f32_val = f32_type.const_float(::std::f64::consts::PI);
 
     let store_instruction = builder.build_store(&arg1, &f32_val);
-    let ptr_val = builder.build_ptr_to_int(&arg1, &i64_type, "ptr_val");
-    let ptr = builder.build_int_to_ptr(&ptr_val, &f32_ptr_type, "ptr");
+    let ptr_val = builder.build_ptr_to_int(arg1, i64_type, "ptr_val");
+    let ptr = builder.build_int_to_ptr(ptr_val, f32_ptr_type, "ptr");
     let free_instruction = builder.build_free(&arg1);
     let return_instruction = builder.build_return(None);