From 438bee5fb1a988fe6bd5a4f06d33cfb25df72f9c Mon Sep 17 00:00:00 2001
From: bjorn3 <bjorn3@users.noreply.github.com>
Date: Mon, 5 Nov 2018 18:03:47 +0100
Subject: [PATCH] Rustup to rustc 1.32.0-nightly (e6c5cf923 2018-11-04)

---
 src/abi.rs    |  2 +-
 src/base.rs   |  4 ++--
 src/common.rs | 16 ++++++++--------
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/abi.rs b/src/abi.rs
index 42119a9bfad..24645279f97 100644
--- a/src/abi.rs
+++ b/src/abi.rs
@@ -456,7 +456,7 @@ pub fn codegen_terminator_call<'a, 'tcx: 'a>(
     args: &[Operand<'tcx>],
     destination: &Option<(Place<'tcx>, BasicBlock)>,
 ) {
-    let fn_ty = fx.monomorphize(&func.ty(&fx.mir.local_decls, fx.tcx));
+    let fn_ty = fx.monomorphize(&func.ty(fx.mir, fx.tcx));
     let sig = ty_fn_sig(fx.tcx, fn_ty);
 
     // Unpack arguments tuple for closures
diff --git a/src/base.rs b/src/base.rs
index 81ab980c334..3d4112dba10 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -402,7 +402,7 @@ fn trans_stmt<'a, 'tcx: 'a>(
                     place.write_place_ref(fx, lval);
                 }
                 Rvalue::BinaryOp(bin_op, lhs, rhs) => {
-                    let ty = fx.monomorphize(&lhs.ty(&fx.mir.local_decls, fx.tcx));
+                    let ty = fx.monomorphize(&lhs.ty(fx.mir, fx.tcx));
                     let lhs = trans_operand(fx, lhs);
                     let rhs = trans_operand(fx, rhs);
 
@@ -422,7 +422,7 @@ fn trans_stmt<'a, 'tcx: 'a>(
                     lval.write_cvalue(fx, res);
                 }
                 Rvalue::CheckedBinaryOp(bin_op, lhs, rhs) => {
-                    let ty = fx.monomorphize(&lhs.ty(&fx.mir.local_decls, fx.tcx));
+                    let ty = fx.monomorphize(&lhs.ty(fx.mir, fx.tcx));
                     let lhs = trans_operand(fx, lhs);
                     let rhs = trans_operand(fx, rhs);
 
diff --git a/src/common.rs b/src/common.rs
index 39bd293a289..f642384634a 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -20,7 +20,7 @@ pub fn pointer_ty(tcx: TyCtxt) -> types::Type {
 }
 
 fn scalar_to_cton_type(tcx: TyCtxt, scalar: &Scalar) -> Type {
-    match scalar.value.size(tcx).bits() {
+    match scalar.value.size(&tcx).bits() {
         8 => types::I8,
         16 => types::I16,
         32 => types::I32,
@@ -530,7 +530,7 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> {
                         scalar_to_cton_type(fx.tcx, b),
                         MemFlags::new(),
                         addr,
-                        a.value.size(fx.tcx).bytes() as u32 as i32,
+                        a.value.size(&fx.tcx).bytes() as u32 as i32,
                     );
                     CPlace::Addr(ptr, Some(extra), inner_layout)
                 }
@@ -558,7 +558,7 @@ impl<'a, 'tcx: 'a> CPlace<'tcx> {
                             MemFlags::new(),
                             extra.expect("unsized type without metadata"),
                             dest.expect_addr(),
-                            a.value.size(fx.tcx).bytes() as u32 as i32,
+                            a.value.size(&fx.tcx).bytes() as u32 as i32,
                         );
                     }
                     _ => bug!(
@@ -643,29 +643,29 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> fmt::Debug for FunctionCx<'a, 'tcx, B> {
     }
 }
 
-impl<'a, 'tcx: 'a, B: Backend> LayoutOf for &'a FunctionCx<'a, 'tcx, B> {
+impl<'a, 'tcx: 'a, B: Backend> LayoutOf for FunctionCx<'a, 'tcx, B> {
     type Ty = Ty<'tcx>;
     type TyLayout = TyLayout<'tcx>;
 
-    fn layout_of(self, ty: Ty<'tcx>) -> TyLayout<'tcx> {
+    fn layout_of(&self, ty: Ty<'tcx>) -> TyLayout<'tcx> {
         let ty = self.monomorphize(&ty);
         self.tcx.layout_of(ParamEnv::reveal_all().and(&ty)).unwrap()
     }
 }
 
-impl<'a, 'tcx, B: Backend + 'a> layout::HasTyCtxt<'tcx> for &'a FunctionCx<'a, 'tcx, B> {
+impl<'a, 'tcx, B: Backend + 'a> layout::HasTyCtxt<'tcx> for FunctionCx<'a, 'tcx, B> {
     fn tcx<'b>(&'b self) -> TyCtxt<'b, 'tcx, 'tcx> {
         self.tcx
     }
 }
 
-impl<'a, 'tcx, B: Backend + 'a> layout::HasDataLayout for &'a FunctionCx<'a, 'tcx, B> {
+impl<'a, 'tcx, B: Backend + 'a> layout::HasDataLayout for FunctionCx<'a, 'tcx, B> {
     fn data_layout(&self) -> &layout::TargetDataLayout {
         &self.tcx.data_layout
     }
 }
 
-impl<'a, 'tcx, B: Backend + 'a> HasTargetSpec for &'a FunctionCx<'a, 'tcx, B> {
+impl<'a, 'tcx, B: Backend + 'a> HasTargetSpec for FunctionCx<'a, 'tcx, B> {
     fn target_spec(&self) -> &Target {
         &self.tcx.sess.target.target
     }