All Builder methods now take &mut self instead of &self

[rust.git] / src / librustc_codegen_ssa / mir / statement.rs

diff --git a/src/librustc_codegen_ssa/mir/statement.rs b/src/librustc_codegen_ssa/mir/statement.rs
index 40af52c05a374c9173b8c367efe2c00c75808fce..0303a221ac565a652d01a91db723a4e2164d831b 100644 (file)
--- a/src/librustc_codegen_ssa/mir/statement.rs
+++ b/src/librustc_codegen_ssa/mir/statement.rs
@@ -19,12 +19,12 @@
 impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn codegen_statement(
         &mut self,
-        bx: Bx,
+        mut bx: Bx,
         statement: &mir::Statement<'tcx>
     ) -> Bx {
         debug!("codegen_statement(statement={:?})", statement);
 
-        self.set_debug_loc(&bx, statement.source_info);
+        self.set_debug_loc(&mut bx, statement.source_info);
         match statement.kind {
             mir::StatementKind::Assign(ref place, ref rvalue) => {
                 if let mir::Place::Local(index) = *place {
@@ -53,39 +53,39 @@ pub fn codegen_statement(
                         }
                     }
                 } else {
-                    let cg_dest = self.codegen_place(&bx, place);
+                    let cg_dest = self.codegen_place(&mut bx, place);
                     self.codegen_rvalue(bx, cg_dest, rvalue)
                 }
             }
             mir::StatementKind::SetDiscriminant{ref place, variant_index} => {
-                self.codegen_place(&bx, place)
-                    .codegen_set_discr(&bx, variant_index);
+                self.codegen_place(&mut bx, place)
+                    .codegen_set_discr(&mut bx, variant_index);
                 bx
             }
             mir::StatementKind::StorageLive(local) => {
                 if let LocalRef::Place(cg_place) = self.locals[local] {
-                    cg_place.storage_live(&bx);
+                    cg_place.storage_live(&mut bx);
                 } else if let LocalRef::UnsizedPlace(cg_indirect_place) = self.locals[local] {
-                    cg_indirect_place.storage_live(&bx);
+                    cg_indirect_place.storage_live(&mut bx);
                 }
                 bx
             }
             mir::StatementKind::StorageDead(local) => {
                 if let LocalRef::Place(cg_place) = self.locals[local] {
-                    cg_place.storage_dead(&bx);
+                    cg_place.storage_dead(&mut bx);
                 } else if let LocalRef::UnsizedPlace(cg_indirect_place) = self.locals[local] {
-                    cg_indirect_place.storage_dead(&bx);
+                    cg_indirect_place.storage_dead(&mut bx);
                 }
                 bx
             }
             mir::StatementKind::InlineAsm { ref asm, ref outputs, ref inputs } => {
                 let outputs = outputs.iter().map(|output| {
-                    self.codegen_place(&bx, output)
+                    self.codegen_place(&mut bx, output)
                 }).collect();
 
                 let input_vals = inputs.iter()
                     .fold(Vec::with_capacity(inputs.len()), |mut acc, (span, input)| {
-                        let op = self.codegen_operand(&bx, input);
+                        let op = self.codegen_operand(&mut bx, input);
                         if let OperandValue::Immediate(_) = op.val {
                             acc.push(op.immediate());
                         } else {