Unregress error spans in constant errors

Author: oli-obk

src/librustc/middle/const_val.rs

@@ -155,7 +155,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
             ConstEvalErrDescription::Backtrace(miri, frames) => {
                 diag.span_label(self.span, format!("{}", miri));
                 for frame in frames {
-                    diag.span_label(frame.span, format!("inside call to {}", frame.location));
+                    diag.span_label(frame.span, format!("inside call to `{}`", frame.location));
                 }
             }
         }

src/librustc_mir/hair/pattern/mod.rs

@@ -788,7 +788,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
             let field = Field::new(i);
             let val = match cv.val {
                 ConstVal::Value(miri) => const_val_field(
-                    self.tcx, self.param_env, instance, span,
+                    self.tcx, self.param_env, instance,
                     variant_opt, field, miri, cv.ty,
                 ).unwrap(),
                 _ => bug!("{:#?} is not a valid adt", cv),

src/librustc_mir/interpret/const_eval.rs

@@ -61,7 +61,7 @@ pub fn eval_body_with_mir<'a, 'mir, 'tcx>(
     mir: &'mir mir::Mir<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
 ) -> Option<(Value, Pointer, Ty<'tcx>)> {
-    let (res, ecx, _) = eval_body_and_ecx(tcx, cid, Some(mir), param_env);
+    let (res, ecx) = eval_body_and_ecx(tcx, cid, Some(mir), param_env);
     match res {
         Ok(val) => Some(val),
         Err(mut err) => {
@@ -76,7 +76,7 @@ pub fn eval_body<'a, 'tcx>(
     cid: GlobalId<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
 ) -> Option<(Value, Pointer, Ty<'tcx>)> {
-    let (res, ecx, _) = eval_body_and_ecx(tcx, cid, None, param_env);
+    let (res, ecx) = eval_body_and_ecx(tcx, cid, None, param_env);
     match res {
         Ok(val) => Some(val),
         Err(mut err) => {
@@ -91,7 +91,7 @@ fn eval_body_and_ecx<'a, 'mir, 'tcx>(
     cid: GlobalId<'tcx>,
     mir: Option<&'mir mir::Mir<'tcx>>,
     param_env: ty::ParamEnv<'tcx>,
-) -> (EvalResult<'tcx, (Value, Pointer, Ty<'tcx>)>, EvalContext<'a, 'mir, 'tcx, CompileTimeEvaluator>, Span) {
+) -> (EvalResult<'tcx, (Value, Pointer, Ty<'tcx>)>, EvalContext<'a, 'mir, 'tcx, CompileTimeEvaluator>) {
     debug!("eval_body: {:?}, {:?}", cid, param_env);
     let mut ecx = EvalContext::new(tcx, param_env, CompileTimeEvaluator, ());
     // we start out with the best span we have
@@ -155,7 +155,7 @@ fn eval_body_and_ecx<'a, 'mir, 'tcx>(
         };
         Ok((value, ptr, layout.ty))
     })();
-    (res, ecx, span)
+    (res, ecx)
 }
 
 pub struct CompileTimeEvaluator;
@@ -367,7 +367,6 @@ pub fn const_val_field<'a, 'tcx>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     instance: ty::Instance<'tcx>,
-    span: Span,
     variant: Option<usize>,
     field: mir::Field,
     value: Value,
@@ -403,7 +402,7 @@ pub fn const_val_field<'a, 'tcx>(
             ty,
         })),
         Err(err) => {
-            let trace = ecx.generate_stacktrace(None);
+            let (trace, span) = ecx.generate_stacktrace(None);
             let err = ErrKind::Miri(err, trace);
             Err(ConstEvalErr {
                 kind: err.into(),
@@ -490,7 +489,7 @@ pub fn const_eval_provider<'a, 'tcx>(
         }
     };
 
-    let (res, ecx, span) = eval_body_and_ecx(tcx, cid, None, key.param_env);
+    let (res, ecx) = eval_body_and_ecx(tcx, cid, None, key.param_env);
     res.map(|(miri_value, _, miri_ty)| {
         tcx.mk_const(ty::Const {
             val: ConstVal::Value(miri_value),
@@ -500,7 +499,7 @@ pub fn const_eval_provider<'a, 'tcx>(
         if tcx.is_static(def_id).is_some() {
             ecx.report(&mut err, true, None);
         }
-        let trace = ecx.generate_stacktrace(None);
+        let (trace, span) = ecx.generate_stacktrace(None);
         let err = ErrKind::Miri(err, trace);
         ConstEvalErr {
             kind: err.into(),

src/librustc_mir/interpret/eval_context.rs

@@ -1566,7 +1566,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         Ok(())
     }
 
-    pub fn generate_stacktrace(&self, explicit_span: Option<Span>) -> Vec<FrameInfo> {
+    pub fn generate_stacktrace(&self, explicit_span: Option<Span>) -> (Vec<FrameInfo>, Span) {
         let mut last_span = None;
         let mut frames = Vec::new();
         // skip 1 because the last frame is just the environment of the constant
@@ -1590,7 +1590,15 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             };
             frames.push(FrameInfo { span, location });
         }
-        frames
+        let frame = self.frame();
+        let bb = &frame.mir.basic_blocks()[frame.block];
+        let span = if let Some(stmt) = bb.statements.get(frame.stmt) {
+            stmt.source_info.span
+        } else {
+            bb.terminator().source_info.span
+        };
+        trace!("generate stacktrace: {:#?}, {:?}", frames, explicit_span);
+        (frames, span)
     }
 
     pub fn report(&self, e: &mut EvalError, as_err: bool, explicit_span: Option<Span>) {
@@ -1654,9 +1662,10 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                     "constant evaluation error",
                 )
             };
+            let (frames, span) = self.generate_stacktrace(explicit_span);
             err.span_label(span, e.to_string());
-            for FrameInfo { span, location } in self.generate_stacktrace(explicit_span) {
-                err.span_note(span, &format!("inside call to {}", location));
+            for FrameInfo { span, location } in frames {
+                err.span_note(span, &format!("inside call to `{}`", location));
             }
             err.emit();
         } else {

src/librustc_mir/transform/const_prop.rs

@@ -80,7 +80,7 @@ impl<'b, 'a, 'tcx:'b> ConstPropagator<'b, 'a, 'tcx> {
         let value = match self.tcx.const_eval(self.param_env.and(cid)) {
             Ok(val) => val,
             Err(err) => {
-                err.report(self.tcx, span, "constant propagated");
+                err.report(self.tcx, err.span, "constant propagated");
                 return None;
             },
         };

src/librustc_trans/mir/constant.rs

@@ -203,7 +203,6 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
                         bx.tcx(),
                         ty::ParamEnv::empty(traits::Reveal::All),
                         self.instance,
-                        constant.span,
                         None,
                         mir::Field::new(field as usize),
                         c,

src/test/ui/const-eval-overflow-2.stderr

@@ -1,8 +1,8 @@
 error[E0080]: constant evaluation error
-  --> $DIR/const-eval-overflow-2.rs:21:1
+  --> $DIR/const-eval-overflow-2.rs:21:25
    |
 21 | const NEG_NEG_128: i8 = -NEG_128;
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to negate with overflow
+   |                         ^^^^^^^^ attempt to negate with overflow
    |
 note: for pattern here
   --> $DIR/const-eval-overflow-2.rs:26:9

src/test/ui/const-eval-overflow-4.stderr

@@ -2,7 +2,7 @@ error[E0080]: constant evaluation error
   --> $DIR/const-eval-overflow-4.rs:23:13
    |
 23 |     : [u32; (i8::MAX as i8 + 1i8) as usize]
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to add with overflow
+   |             ^^^^^^^^^^^^^^^^^^^^^ attempt to add with overflow
 
 error: aborting due to previous error
 

src/test/ui/const-eval/conditional_array_execution.stderr

@@ -5,16 +5,10 @@ error[E0080]: constant evaluation error
    |                    ^^^ referenced constant has errors
 
 error[E0080]: constant evaluation error
-  --> $DIR/conditional_array_execution.rs:13:1
+  --> $DIR/conditional_array_execution.rs:13:19
    |
 13 | const FOO: u32 = [X - Y, Y - X][(X < Y) as usize]; //~ E0080
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
-   |
-note: for constant propagated here
-  --> $DIR/conditional_array_execution.rs:16:20
-   |
-16 |     println!("{}", FOO); //~ E0080
-   |                    ^^^
+   |                   ^^^^^ attempt to subtract with overflow
 
 error: aborting due to 2 previous errors
 

src/test/ui/const-eval/index_out_of_bound.rs

@@ -10,6 +10,5 @@
 
 static FOO: i32 = [][0];
 //~^ ERROR E0080
-//~| ERROR E0080
 
 fn main() {}