eval_mir_constant doesn't need a builder param

Author: bjorn3

src/librustc_codegen_ssa/mir/block.rs

@@ -640,7 +640,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             span_bug!(span, "shuffle indices must be constant");
                         }
                         mir::Operand::Constant(ref constant) => {
-                            let c = self.eval_mir_constant(&bx, constant);
+                            let c = self.eval_mir_constant(constant);
                             let (llval, ty) = self.simd_shuffle_indices(
                                 &bx,
                                 constant.span,

src/librustc_codegen_ssa/mir/constant.rs

@@ -3,41 +3,38 @@ use rustc_mir::const_eval::const_field;
 use rustc::mir;
 use rustc_data_structures::indexed_vec::Idx;
 use rustc::mir::interpret::GlobalId;
-use rustc::ty::{self, Ty};
-use rustc::ty::layout;
+use rustc::ty::{self, Ty, TyCtxt};
+use rustc::ty::layout::{self, HasTyCtxt};
 use syntax::source_map::Span;
 use crate::traits::*;
 
 use super::FunctionCx;
 
-impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
-    fn fully_evaluate(
-        &mut self,
-        bx: &Bx,
-        constant: &'tcx ty::LazyConst<'tcx>,
-    ) -> Result<ty::Const<'tcx>, ErrorHandled> {
-        match *constant {
-            ty::LazyConst::Unevaluated(def_id, ref substs) => {
-                let tcx = bx.tcx();
-                let param_env = ty::ParamEnv::reveal_all();
-                let instance = ty::Instance::resolve(tcx, param_env, def_id, substs).unwrap();
-                let cid = GlobalId {
-                    instance,
-                    promoted: None,
-                };
-                tcx.const_eval(param_env.and(cid))
-            },
-            ty::LazyConst::Evaluated(constant) => Ok(constant),
-        }
+fn fully_evaluate<'a, 'tcx: 'a>(
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    constant: &'tcx ty::LazyConst<'tcx>,
+) -> Result<ty::Const<'tcx>, ErrorHandled> {
+    match *constant {
+        ty::LazyConst::Unevaluated(def_id, ref substs) => {
+            let param_env = ty::ParamEnv::reveal_all();
+            let instance = ty::Instance::resolve(tcx, param_env, def_id, substs).unwrap();
+            let cid = GlobalId {
+                instance,
+                promoted: None,
+            };
+            tcx.const_eval(param_env.and(cid))
+        },
+        ty::LazyConst::Evaluated(constant) => Ok(constant),
     }
+}
 
+impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn eval_mir_constant(
-        &mut self,
-        bx: &Bx,
+        &self,
         constant: &mir::Constant<'tcx>,
     ) -> Result<ty::Const<'tcx>, ErrorHandled> {
         let c = self.monomorphize(&constant.literal);
-        self.fully_evaluate(bx, c)
+        fully_evaluate(self.cx.tcx(), c)
     }
 
     /// process constant containing SIMD shuffle indices

src/librustc_codegen_ssa/mir/operand.rs

@@ -457,7 +457,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
             mir::Operand::Constant(ref constant) => {
                 let ty = self.monomorphize(&constant.ty);
-                self.eval_mir_constant(bx, constant)
+                self.eval_mir_constant(constant)
                     .and_then(|c| OperandRef::from_const(bx, c))
                     .unwrap_or_else(|err| {
                         match err {