Use the correct spans for const error reporting

oli-obk · oli-obk · commit bd69f9e7e958 · 2018-01-18T20:50:03.000+01:00
diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs
@@ -19,6 +19,7 @@ pub fn mk_borrowck_eval_cx<'a, 'mir, 'tcx>(
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     instance: Instance<'tcx>,
     mir: &'mir mir::Mir<'tcx>,
+    span: Span,
 ) -> EvalResult<'tcx, EvalContext<'a, 'mir, 'tcx, CompileTimeEvaluator>> {
     debug!("mk_borrowck_eval_cx: {:?}", instance);
     let param_env = tcx.param_env(instance.def_id());
@@ -27,7 +28,7 @@ pub fn mk_borrowck_eval_cx<'a, 'mir, 'tcx>(
     // insert a stack frame so any queries have the correct substs
     ecx.push_stack_frame(
         instance,
-        mir.span,
+        span,
         mir,
         Place::undef(),
         StackPopCleanup::None,
@@ -65,7 +66,7 @@ pub fn eval_body_with_mir<'a, 'mir, 'tcx>(
     match res {
         Ok(val) => Some(val),
         Err(mut err) => {
-            ecx.report(&mut err, true);
+            ecx.report(&mut err, true, None);
             None
         }
     }
@@ -80,7 +81,7 @@ pub fn eval_body<'a, 'tcx>(
     match res {
         Ok(val) => Some(val),
         Err(mut err) => {
-            ecx.report(&mut err, true);
+            ecx.report(&mut err, true, None);
             None
         }
     }
@@ -477,7 +478,7 @@ pub fn const_eval_provider<'a, 'tcx>(
         })
     }).map_err(|mut err| {
         if tcx.is_static(def_id).is_some() {
-            ecx.report(&mut err, true);
+            ecx.report(&mut err, true, None);
         }
         ConstEvalErr {
             kind: err.into(),
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
@@ -10,7 +10,7 @@ use rustc::ty::layout::{self, Size, Align, HasDataLayout, LayoutOf, TyLayout};
 use rustc::ty::subst::{Subst, Substs, Kind};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc_data_structures::indexed_vec::Idx;
-use syntax::codemap::{self, DUMMY_SP};
+use syntax::codemap::{self, DUMMY_SP, Span};
 use syntax::ast::Mutability;
 use rustc::mir::interpret::{
     GlobalId, Value, Pointer, PrimVal, PrimValKind,
@@ -1568,7 +1568,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         Ok(())
     }
 
-    pub fn report(&self, e: &mut EvalError, as_err: bool) {
+    pub fn report(&self, e: &mut EvalError, as_err: bool, explicit_span: Option<Span>) {
         if let EvalErrorKind::TypeckError = e.kind {
             return;
         }
@@ -1604,11 +1604,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         }
         if let Some(frame) = self.stack().last() {
             let block = &frame.mir.basic_blocks()[frame.block];
-            let span = if frame.stmt < block.statements.len() {
+            let span = explicit_span.unwrap_or_else(|| if frame.stmt < block.statements.len() {
                 block.statements[frame.stmt].source_info.span
             } else {
                 block.terminator().source_info.span
-            };
+            });
+            trace!("reporting const eval failure at {:?}", span);
             let node_id = self
                 .stack()
                 .iter()
@@ -1630,6 +1631,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             let mut last_span = None;
             for &Frame { instance, span, .. } in self.stack().iter().rev() {
                 // make sure we don't emit frames that are duplicates of the previous
+                if explicit_span == Some(span) {
+                    continue;
+                }
                 if let Some(last) = last_span {
                     if last == span {
                         continue;
diff --git a/src/librustc_mir/transform/instcombine.rs b/src/librustc_mir/transform/instcombine.rs
@@ -23,7 +23,7 @@ use rustc_data_structures::indexed_vec::Idx;
 use std::mem;
 use std::collections::VecDeque;
 use transform::{MirPass, MirSource};
-use syntax::codemap::{Span, DUMMY_SP};
+use syntax::codemap::Span;
 use rustc_data_structures::control_flow_graph::ControlFlowGraph;
 use rustc::ty::subst::Substs;
 
@@ -147,7 +147,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for InstCombineVisitor<'a, 'tcx> {
             TerminatorKind::SwitchInt { discr: value, .. } |
             TerminatorKind::Yield { value, .. } |
             TerminatorKind::Assert { cond: value, .. } => {
-                if let Some((new, ty, span)) = self.optimizations.const_prop.remove(&location) {
+                if let Some((new, ty, span)) = self.optimizations.terminators.remove(&block) {
                     let new = self.tcx.mk_const(ty::Const {
                         val: ConstVal::Value(new),
                         ty,
@@ -190,13 +190,13 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
         }
     }
 
-    fn eval_constant(&mut self, c: &Constant<'tcx>, span: Span) -> Option<Const<'tcx>> {
+    fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<Const<'tcx>> {
         if let Some(&val) = self.optimizations.constants.get(c) {
             return Some(val);
         }
         match c.literal {
             Literal::Value { value } => match value.val {
-                ConstVal::Value(v) => Some((v, value.ty, span)),
+                ConstVal::Value(v) => Some((v, value.ty, c.span)),
                 ConstVal::Unevaluated(did, substs) => {
                     let param_env = self.tcx.param_env(self.source.def_id);
                     let span = self.tcx.def_span(did);
@@ -230,20 +230,19 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
                     instance,
                     promoted: Some(index),
                 };
-                let span = self.tcx.def_span(self.source.def_id);
                 let param_env = self.tcx.param_env(self.source.def_id);
                 let (value, _, ty) = eval_body_with_mir(self.tcx, cid, self.mir, param_env)?;
-                let val = (value, ty, span);
+                let val = (value, ty, c.span);
                 trace!("evaluated {:?} to {:?}", c, val);
                 self.optimizations.constants.insert(c.clone(), val);
                 Some(val)
             }
         }
     }
 
-    fn eval_operand(&mut self, op: &Operand<'tcx>, span: Span) -> Option<Const<'tcx>> {
+    fn eval_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
         match *op {
-            Operand::Constant(ref c) => self.eval_constant(c, span),
+            Operand::Constant(ref c) => self.eval_constant(c),
             Operand::Move(ref place) | Operand::Copy(ref place) => match *place {
                 Place::Local(loc) => self.optimizations.places.get(&loc).cloned(),
                 // FIXME(oli-obk): field and index projections
@@ -253,13 +252,13 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
         }
     }
 
-    fn simplify_operand(&mut self, op: &Operand<'tcx>, span: Span) -> Option<Const<'tcx>> {
+    fn simplify_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
         match *op {
             Operand::Constant(ref c) => match c.literal {
                 Literal::Value { .. } => None,
-                _ => self.eval_operand(op, span),
+                _ => self.eval_operand(op),
             },
-            _ => self.eval_operand(op, span),
+            _ => self.eval_operand(op),
         }
     }
 
@@ -270,7 +269,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
         span: Span,
     ) -> Option<Const<'tcx>> {
         match *rvalue {
-            Rvalue::Use(ref op) => self.simplify_operand(op, span),
+            Rvalue::Use(ref op) => self.simplify_operand(op),
             Rvalue::Repeat(..) |
             Rvalue::Ref(..) |
             Rvalue::Cast(..) |
@@ -300,24 +299,24 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
                 }
                 let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
                 let instance = Instance::new(self.source.def_id, substs);
-                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir).unwrap();
+                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
 
-                let val = self.eval_operand(arg, span)?;
+                let val = self.eval_operand(arg)?;
                 let prim = ecx.value_to_primval(ValTy { value: val.0, ty: val.1 }).ok()?;
                 let kind = ecx.ty_to_primval_kind(val.1).ok()?;
                 match unary_op(op, prim, kind) {
                     Ok(val) => Some((Value::ByVal(val), place_ty, span)),
                     Err(mut err) => {
-                        ecx.report(&mut err, false);
+                        ecx.report(&mut err, false, Some(span));
                         None
                     },
                 }
             }
             Rvalue::CheckedBinaryOp(op, ref left, ref right) |
             Rvalue::BinaryOp(op, ref left, ref right) => {
                 trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
-                let left = self.eval_operand(left, span)?;
-                let right = self.eval_operand(right, span)?;
+                let left = self.eval_operand(left)?;
+                let right = self.eval_operand(right)?;
                 let def_id = if self.tcx.is_closure(self.source.def_id) {
                     self.tcx.closure_base_def_id(self.source.def_id)
                 } else {
@@ -331,7 +330,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
                 }
                 let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
                 let instance = Instance::new(self.source.def_id, substs);
-                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir).unwrap();
+                let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
 
                 let l = ecx.value_to_primval(ValTy { value: left.0, ty: left.1 }).ok()?;
                 let r = ecx.value_to_primval(ValTy { value: right.0, ty: right.1 }).ok()?;
@@ -351,15 +350,15 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
                                     kind: EvalErrorKind::OverflowingMath,
                                     backtrace: None,
                                 };
-                                ecx.report(&mut err, false);
+                                ecx.report(&mut err, false, Some(span));
                                 return None;
                             }
                             Value::ByVal(val)
                         };
                         Some((val, place_ty, span))
                     },
                     Err(mut err) => {
-                        ecx.report(&mut err, false);
+                        ecx.report(&mut err, false, Some(span));
                         None
                     },
                 }
@@ -500,7 +499,7 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
     ) {
         trace!("visit_constant: {:?}", constant);
         self.super_constant(constant, location);
-        self.eval_constant(constant, DUMMY_SP);
+        self.eval_constant(constant);
     }
 
     fn visit_statement(
@@ -554,17 +553,16 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
 
     fn visit_terminator_kind(
         &mut self,
-        _block: BasicBlock,
+        block: BasicBlock,
         kind: &TerminatorKind<'tcx>,
-        location: Location,
+        _location: Location,
     ) {
-        let span = self.mir.source_info(location).span;
         match kind {
             TerminatorKind::SwitchInt { discr: value, .. } |
             TerminatorKind::Yield { value, .. } |
             TerminatorKind::Assert { cond: value, .. } => {
-                if let Some(value) = self.simplify_operand(value, span) {
-                    self.optimizations.const_prop.insert(location, value);
+                if let Some(value) = self.simplify_operand(value) {
+                    self.optimizations.terminators.insert(block, value);
                 }
             }
             // FIXME: do this optimization for function calls
@@ -578,6 +576,8 @@ struct OptimizationList<'tcx> {
     and_stars: FxHashSet<Location>,
     arrays_lengths: FxHashMap<Location, Constant<'tcx>>,
     const_prop: FxHashMap<Location, Const<'tcx>>,
+    /// Terminators that get their Operand(s) turned into constants.
+    terminators: FxHashMap<BasicBlock, Const<'tcx>>,
     places: FxHashMap<Local, Const<'tcx>>,
     constants: FxHashMap<Constant<'tcx>, Const<'tcx>>,
 }
diff --git a/src/test/compile-fail/const-err2.rs b/src/test/compile-fail/const-err2.rs
@@ -19,10 +19,12 @@ fn black_box<T>(_: T) {
 fn main() {
     let a = -std::i8::MIN;
     //~^ ERROR const_err
-    //~| ERROR const_err
     let b = 200u8 + 200u8 + 200u8;
+    //~^ ERROR const_err
     let c = 200u8 * 4;
+    //~^ ERROR const_err
     let d = 42u8 - (42u8 + 1);
+    //~^ ERROR const_err
     let _e = [5u8][1];
     black_box(a);
     black_box(b);
diff --git a/src/test/compile-fail/const-err3.rs b/src/test/compile-fail/const-err3.rs
@@ -18,9 +18,10 @@ fn black_box<T>(_: T) {
 fn main() {
     let b = 200u8 + 200u8 + 200u8;
     //~^ ERROR const_err
-    //~| ERROR const_err
     let c = 200u8 * 4;
+    //~^ ERROR const_err
     let d = 42u8 - (42u8 + 1);
+    //~^ ERROR const_err
     let _e = [5u8][1];
     black_box(b);
     black_box(c);
