WIP

Author: spastorino

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -230,7 +230,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
 
     fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {
         let check = match terminator.kind {
-            mir::TerminatorKind::Call { func: mir::Operand::Constant(ref c), ref args, .. } => {
+            mir::TerminatorKind::Call { func: mir::Operand::Constant(box(_, ref c)), ref args, .. } => {
                 match *c.ty().kind() {
                     ty::FnDef(did, _) => Some((did, args)),
                     _ => None,

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -633,10 +633,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         // checked by const-qualification, which also
                         // promotes any complex rvalues to constants.
                         if i == 2 && intrinsic.as_str().starts_with("simd_shuffle") {
-                            if let mir::Operand::Constant(constant) = arg {
-                                let c = self.eval_mir_constant(constant);
+                            if let mir::Operand::Constant(box(span, constant)) = arg {
+                                let c = self.eval_mir_constant(*span, constant);
                                 let (llval, ty) =
-                                    self.simd_shuffle_indices(&bx, constant.span, constant.ty(), c);
+                                    self.simd_shuffle_indices(&bx, *span, constant.ty(), c);
                                 return OperandRef {
                                     val: Immediate(llval),
                                     layout: bx.layout_of(ty),
@@ -821,9 +821,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         out_place.map(|out_place| self.codegen_place(&mut bx, out_place.as_ref()));
                     InlineAsmOperandRef::InOut { reg, late, in_value, out_place }
                 }
-                mir::InlineAsmOperand::Const { ref value } => {
+                mir::InlineAsmOperand::Const { span, ref value } => {
                     let const_value = self
-                        .eval_mir_constant(value)
+                        .eval_mir_constant(span, value)
                         .unwrap_or_else(|_| span_bug!(span, "asm const cannot be resolved"));
                     let ty = value.ty();
                     let size = bx.layout_of(ty).size;

compiler/rustc_codegen_ssa/src/mir/constant.rs

@@ -13,15 +13,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn eval_mir_constant_to_operand(
         &self,
         bx: &mut Bx,
+        span: Span,
         constant: &mir::Constant<'tcx>,
     ) -> Result<OperandRef<'tcx, Bx::Value>, ErrorHandled> {
-        let val = self.eval_mir_constant(constant)?;
+        let val = self.eval_mir_constant(span, constant)?;
         let ty = self.monomorphize(constant.ty());
         Ok(OperandRef::from_const(bx, val, ty))
     }
 
     pub fn eval_mir_constant(
         &self,
+        span: Span,
         constant: &mir::Constant<'tcx>,
     ) -> Result<ConstValue<'tcx>, ErrorHandled> {
         let ct = self.monomorphize(constant.literal);
@@ -35,12 +37,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 .tcx()
                 .const_eval_resolve(ty::ParamEnv::reveal_all(), ct, None)
                 .map_err(|err| {
-                    self.cx.tcx().sess.span_err(constant.span, "erroneous constant encountered");
+                    self.cx.tcx().sess.span_err(span, "erroneous constant encountered");
                     err
                 }),
             ty::ConstKind::Value(value) => Ok(value),
             err => span_bug!(
-                constant.span,
+                span,
                 "encountered bad ConstKind after monomorphizing: {:?}",
                 err
             ),

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -420,7 +420,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             None => continue,
                         };
 
-                        if let Ok(operand) = self.eval_mir_constant_to_operand(bx, &c) {
+                        if let Ok(operand) = self.eval_mir_constant_to_operand(bx, var.source_info.span, &c) {
                             let base = Self::spill_operand_to_stack(
                                 &operand,
                                 Some(var.name.to_string()),

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -188,14 +188,14 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     // Evaluate all required consts; codegen later assumes that CTFE will never fail.
     let mut all_consts_ok = true;
-    for const_ in &mir.required_consts {
-        if let Err(err) = fx.eval_mir_constant(const_) {
+    for (span, const_) in &mir.required_consts {
+        if let Err(err) = fx.eval_mir_constant(*span, const_) {
             all_consts_ok = false;
             match err {
                 // errored or at least linted
                 ErrorHandled::Reported(ErrorReported) | ErrorHandled::Linted => {}
                 ErrorHandled::TooGeneric => {
-                    span_bug!(const_.span, "codgen encountered polymorphic constant: {:?}", err)
+                    span_bug!(*span, "codgen encountered polymorphic constant: {:?}", err)
                 }
             }
         }

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -437,10 +437,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_consume(bx, place.as_ref())
             }
 
-            mir::Operand::Constant(ref constant) => {
+            mir::Operand::Constant(box(span, ref constant)) => {
                 // This cannot fail because we checked all required_consts in advance.
-                self.eval_mir_constant_to_operand(bx, constant).unwrap_or_else(|_err| {
-                    span_bug!(constant.span, "erroneous constant not captured by required_consts")
+                self.eval_mir_constant_to_operand(bx, span, constant).unwrap_or_else(|_err| {
+                    span_bug!(span, "erroneous constant not captured by required_consts")
                 })
             }
         }

compiler/rustc_middle/src/mir/mod.rs

@@ -217,7 +217,7 @@ pub struct Body<'tcx> {
 
     /// Constants that are required to evaluate successfully for this MIR to be well-formed.
     /// We hold in this field all the constants we are not able to evaluate yet.
-    pub required_consts: Vec<Constant<'tcx>>,
+    pub required_consts: Vec<(Span, Constant<'tcx>)>,
 
     /// Does this body use generic parameters. This is used for the `ConstEvaluatable` check.
     ///
@@ -1222,6 +1222,7 @@ pub enum InlineAsmOperand<'tcx> {
         out_place: Option<Place<'tcx>>,
     },
     Const {
+        span: Span,
         value: Box<Constant<'tcx>>,
     },
     SymFn {
@@ -2029,7 +2030,7 @@ pub enum Operand<'tcx> {
     Move(Place<'tcx>),
 
     /// Synthesizes a constant value.
-    Constant(Box<Constant<'tcx>>),
+    Constant(Box<(Span, Constant<'tcx>)>),
 }
 
 #[cfg(target_arch = "x86_64")]
@@ -2057,11 +2058,10 @@ impl<'tcx> Operand<'tcx> {
         span: Span,
     ) -> Self {
         let ty = tcx.type_of(def_id).subst(tcx, substs);
-        Operand::Constant(box Constant {
-            span,
+        Operand::Constant(box (span, Constant {
             user_ty: None,
             literal: ConstantKind::Ty(ty::Const::zero_sized(tcx, ty)),
-        })
+        }))
     }
 
     pub fn is_move(&self) -> bool {
@@ -2088,11 +2088,10 @@ impl<'tcx> Operand<'tcx> {
             };
             scalar_size == type_size
         });
-        Operand::Constant(box Constant {
-            span,
+        Operand::Constant(box (span, Constant {
             user_ty: None,
             literal: ConstantKind::Val(val.into(), ty),
-        })
+        }))
     }
 
     pub fn to_copy(&self) -> Self {
@@ -2113,9 +2112,9 @@ impl<'tcx> Operand<'tcx> {
 
     /// Returns the `Constant` that is the target of this `Operand`, or `None` if this `Operand` is a
     /// place.
-    pub fn constant(&self) -> Option<&Constant<'tcx>> {
+    pub fn constant(&self) -> Option<(&Span, &Constant<'tcx>)> {
         match self {
-            Operand::Constant(x) => Some(&**x),
+            Operand::Constant(box(span, c)) => Some((span, c)),
             Operand::Copy(_) | Operand::Move(_) => None,
         }
     }
@@ -2426,8 +2425,6 @@ impl<'tcx> Debug for Rvalue<'tcx> {
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, TyEncodable, TyDecodable, Hash, HashStable)]
 pub struct Constant<'tcx> {
-    pub span: Span,
-
     /// Optional user-given type: for something like
     /// `collect::<Vec<_>>`, this would be present and would
     /// indicate that `Vec<_>` was explicitly specified.

compiler/rustc_middle/src/mir/tcx.rs

@@ -227,7 +227,7 @@ impl<'tcx> Operand<'tcx> {
     {
         match self {
             &Operand::Copy(ref l) | &Operand::Move(ref l) => l.ty(local_decls, tcx).ty,
-            &Operand::Constant(ref c) => c.literal.ty(),
+            &Operand::Constant(box (_, ref c)) => c.literal.ty(),
         }
     }
 }

compiler/rustc_middle/src/mir/terminator.rs

@@ -527,7 +527,8 @@ impl<'tcx> TerminatorKind<'tcx> {
                         InlineAsmOperand::InOut { reg, late, in_value, out_place: None } => {
                             write!(fmt, "in{}out({}) {:?} => _", print_late(late), reg, in_value)?;
                         }
-                        InlineAsmOperand::Const { value } => {
+                        InlineAsmOperand::Const { value, .. } => {
+                            // FIXME consider span?
                             write!(fmt, "const {:?}", value)?;
                         }
                         InlineAsmOperand::SymFn { value } => {

compiler/rustc_middle/src/mir/type_foldable.rs

@@ -336,7 +336,6 @@ impl<'tcx, R: Idx, C: Idx> TypeFoldable<'tcx> for BitMatrix<R, C> {
 impl<'tcx> TypeFoldable<'tcx> for Constant<'tcx> {
     fn super_fold_with<F: TypeFolder<'tcx>>(self, folder: &mut F) -> Self {
         Constant {
-            span: self.span,
             user_ty: self.user_ty.fold_with(folder),
             literal: self.literal.fold_with(folder),
         }