Rollup merge of #69185 - RalfJung:const-prop-lints, r=oli-obk

Unify and improve const-prop lints

Add a single helper method for all lints emitted by const-prop, and make that lint different from the CTFE `const_err` lint. Also consistently check overflow on *arithmetic*, not on the assertion, to make behavior the same for debug and release builds.

See [this summary comment](https://github.com/rust-lang/rust/pull/69185#issuecomment-587924754) for details and the latest status.

In terms of lint formatting, I went for what seems to be the better style: have a general message above the code, and then a specific message at the span:
```
error: this arithmetic operation will overflow
  --> $DIR/const-err2.rs:21:18
   |
LL |     let a_i128 = -std::i128::MIN;
   |                  ^^^^^^^^^^^^^^^ attempt to negate with overflow
```
We could also just have the specific message above and no text at the span if that is preferred.

I also converted some of the existing tests to use compiletest revisions, so that the same test can check a bunch of different compile flags.

Fixes https://github.com/rust-lang/rust/issues/69020.
Helps with https://github.com/rust-lang/rust/issues/69021: debug/release are now consistent, but the assoc-const test in that issue still fails (there is a FIXME in the PR for this). The reason seems to be that const-prop notices the assoc const in `T::N << 42` and does not even bother calling `const_prop` on that operation.
Has no effect on https://github.com/rust-lang/rust/issues/61821; the duplication there has entirely different reasons.

71 files changed, 1613 insertions, 1109 deletions

diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
index 2204e104803..0e7625da30a 100644
--- a/src/librustc_lint/lib.rs
+++ b/src/librustc_lint/lib.rs
@@ -305,6 +305,7 @@ fn register_builtins(store: &mut LintStore, no_interleave_lints: bool) {
     store.register_renamed("unstable_name_collision", "unstable_name_collisions");
     store.register_renamed("unused_doc_comment", "unused_doc_comments");
     store.register_renamed("async_idents", "keyword_idents");
+    store.register_renamed("exceeding_bitshifts", "arithmetic_overflow");
     store.register_removed("unknown_features", "replaced by an error");
     store.register_removed("unsigned_negation", "replaced by negate_unsigned feature gate");
     store.register_removed("negate_unsigned", "cast a signed value instead");
diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index 91d134fbb00..9e05133132e 100644
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -4,7 +4,8 @@
 use std::borrow::Cow;
 use std::cell::Cell;
 
-use rustc::mir::interpret::{InterpError, InterpResult, Scalar};
+use rustc::lint;
+use rustc::mir::interpret::{InterpResult, Scalar};
 use rustc::mir::visit::{
     MutVisitor, MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor,
 };
@@ -292,7 +293,6 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for ConstPropMachine {
 struct ConstPropagator<'mir, 'tcx> {
     ecx: InterpCx<'mir, 'tcx, ConstPropMachine>,
     tcx: TyCtxt<'tcx>,
-    source: MirSource<'tcx>,
     can_const_prop: IndexVec<Local, ConstPropMode>,
     param_env: ParamEnv<'tcx>,
     // FIXME(eddyb) avoid cloning these two fields more than once,
@@ -372,7 +372,6 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         ConstPropagator {
             ecx,
             tcx,
-            source,
             param_env,
             can_const_prop,
             // FIXME(eddyb) avoid cloning these two fields more than once,
@@ -501,19 +500,20 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         }
     }
 
-    fn report_panic_as_lint(&self, source_info: SourceInfo, panic: AssertKind<u64>) -> Option<()> {
-        // Somewhat convoluted way to re-use the CTFE error reporting code.
+    fn report_assert_as_lint(
+        &self,
+        lint: &'static lint::Lint,
+        source_info: SourceInfo,
+        message: &'static str,
+        panic: AssertKind<u64>,
+    ) -> Option<()> {
         let lint_root = self.lint_root(source_info)?;
-        let error = InterpError::MachineStop(Box::new(format!("{:?}", panic)));
-        let mut diagnostic = error_to_const_error(&self.ecx, error.into());
-        diagnostic.span = source_info.span; // fix the span
-        diagnostic.report_as_lint(
-            self.tcx.at(source_info.span),
-            "this expression will panic at runtime",
-            lint_root,
-            None,
-        );
-        None
+        self.tcx.struct_span_lint_hir(lint, lint_root, source_info.span, |lint| {
+            let mut err = lint.build(message);
+            err.span_label(source_info.span, format!("{:?}", panic));
+            err.emit()
+        });
+        return None;
     }
 
     fn check_unary_op(
@@ -530,7 +530,12 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             // `AssertKind` only has an `OverflowNeg` variant, so make sure that is
             // appropriate to use.
             assert_eq!(op, UnOp::Neg, "Neg is the only UnOp that can overflow");
-            self.report_panic_as_lint(source_info, AssertKind::OverflowNeg)?;
+            self.report_assert_as_lint(
+                lint::builtin::ARITHMETIC_OVERFLOW,
+                source_info,
+                "this arithmetic operation will overflow",
+                AssertKind::OverflowNeg,
+            )?;
         }
 
         Some(())
@@ -542,27 +547,24 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         left: &Operand<'tcx>,
         right: &Operand<'tcx>,
         source_info: SourceInfo,
-        place_layout: TyLayout<'tcx>,
     ) -> Option<()> {
         let r =
             self.use_ecx(|this| this.ecx.read_immediate(this.ecx.eval_operand(right, None)?))?;
         // Check for exceeding shifts *even if* we cannot evaluate the LHS.
         if op == BinOp::Shr || op == BinOp::Shl {
-            let left_bits = place_layout.size.bits();
+            // We need the type of the LHS. We cannot use `place_layout` as that is the type
+            // of the result, which for checked binops is not the same!
+            let left_ty = left.ty(&self.local_decls, self.tcx);
+            let left_size_bits = self.ecx.layout_of(left_ty).ok()?.size.bits();
             let right_size = r.layout.size;
             let r_bits = r.to_scalar().and_then(|r| r.to_bits(right_size));
-            if r_bits.map_or(false, |b| b >= left_bits as u128) {
-                let lint_root = self.lint_root(source_info)?;
-                self.tcx.struct_span_lint_hir(
-                    ::rustc::lint::builtin::EXCEEDING_BITSHIFTS,
-                    lint_root,
-                    source_info.span,
-                    |lint| {
-                        let dir = if op == BinOp::Shr { "right" } else { "left" };
-                        lint.build(&format!("attempt to shift {} with overflow", dir)).emit()
-                    },
-                );
-                return None;
+            if r_bits.map_or(false, |b| b >= left_size_bits as u128) {
+                self.report_assert_as_lint(
+                    lint::builtin::ARITHMETIC_OVERFLOW,
+                    source_info,
+                    "this arithmetic operation will overflow",
+                    AssertKind::Overflow(op),
+                )?;
             }
         }
 
@@ -572,7 +574,12 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             let (_res, overflow, _ty) = this.ecx.overflowing_binary_op(op, l, r)?;
             Ok(overflow)
         })? {
-            self.report_panic_as_lint(source_info, AssertKind::Overflow(op))?;
+            self.report_assert_as_lint(
+                lint::builtin::ARITHMETIC_OVERFLOW,
+                source_info,
+                "this arithmetic operation will overflow",
+                AssertKind::Overflow(op),
+            )?;
         }
 
         Some(())
@@ -595,8 +602,6 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             return None;
         }
 
-        let overflow_check = self.tcx.sess.overflow_checks();
-
         // Perform any special handling for specific Rvalue types.
         // Generally, checks here fall into one of two categories:
         //   1. Additional checking to provide useful lints to the user
@@ -606,20 +611,25 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         //        - In this case, we'll return `None` from this function to stop evaluation.
         match rvalue {
             // Additional checking: give lints to the user if an overflow would occur.
-            // If `overflow_check` is set, running const-prop on the `Assert` terminators
-            // will already generate the appropriate messages.
-            Rvalue::UnaryOp(op, arg) if !overflow_check => {
+            // We do this here and not in the `Assert` terminator as that terminator is
+            // only sometimes emitted (overflow checks can be disabled), but we want to always
+            // lint.
+            Rvalue::UnaryOp(op, arg) => {
                 trace!("checking UnaryOp(op = {:?}, arg = {:?})", op, arg);
                 self.check_unary_op(*op, arg, source_info)?;
             }
-
-            // Additional checking: check for overflows on integer binary operations and report
-            // them to the user as lints.
-            // If `overflow_check` is set, running const-prop on the `Assert` terminators
-            // will already generate the appropriate messages.
-            Rvalue::BinaryOp(op, left, right) if !overflow_check => {
+            Rvalue::BinaryOp(op, left, right) => {
                 trace!("checking BinaryOp(op = {:?}, left = {:?}, right = {:?})", op, left, right);
-                self.check_binary_op(*op, left, right, source_info, place_layout)?;
+                self.check_binary_op(*op, left, right, source_info)?;
+            }
+            Rvalue::CheckedBinaryOp(op, left, right) => {
+                trace!(
+                    "checking CheckedBinaryOp(op = {:?}, left = {:?}, right = {:?})",
+                    op,
+                    left,
+                    right
+                );
+                self.check_binary_op(*op, left, right, source_info)?;
             }
 
             // Do not try creating references (#67862)
@@ -898,54 +908,39 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
                             }
                             Operand::Constant(_) => {}
                         }
-                        let span = terminator.source_info.span;
-                        let hir_id = self
-                            .tcx
-                            .hir()
-                            .as_local_hir_id(self.source.def_id())
-                            .expect("some part of a failing const eval must be local");
-                        self.tcx.struct_span_lint_hir(
-                            ::rustc::lint::builtin::CONST_ERR,
-                            hir_id,
-                            span,
-                            |lint| {
-                                let msg = match msg {
-                                    AssertKind::Overflow(_)
-                                    | AssertKind::OverflowNeg
-                                    | AssertKind::DivisionByZero
-                                    | AssertKind::RemainderByZero => msg.description().to_owned(),
-                                    AssertKind::BoundsCheck { ref len, ref index } => {
-                                        let len = self
-                                            .eval_operand(len, source_info)
-                                            .expect("len must be const");
-                                        let len = match self.ecx.read_scalar(len) {
-                                            Ok(ScalarMaybeUndef::Scalar(Scalar::Raw {
-                                                data,
-                                                ..
-                                            })) => data,
-                                            other => bug!("const len not primitive: {:?}", other),
-                                        };
-                                        let index = self
-                                            .eval_operand(index, source_info)
-                                            .expect("index must be const");
-                                        let index = match self.ecx.read_scalar(index) {
-                                            Ok(ScalarMaybeUndef::Scalar(Scalar::Raw {
-                                                data,
-                                                ..
-                                            })) => data,
-                                            other => bug!("const index not primitive: {:?}", other),
-                                        };
-                                        format!(
-                                            "index out of bounds: \
-                                            the len is {} but the index is {}",
-                                            len, index,
-                                        )
-                                    }
-                                    // Need proper const propagator for these
-                                    _ => return,
-                                };
-                                lint.build(&msg).emit()
-                            },
+                        let msg = match msg {
+                            AssertKind::DivisionByZero => AssertKind::DivisionByZero,
+                            AssertKind::RemainderByZero => AssertKind::RemainderByZero,
+                            AssertKind::BoundsCheck { ref len, ref index } => {
+                                let len =
+                                    self.eval_operand(len, source_info).expect("len must be const");
+                                let len = self
+                                    .ecx
+                                    .read_scalar(len)
+                                    .unwrap()
+                                    .to_machine_usize(&self.tcx)
+                                    .unwrap();
+                                let index = self
+                                    .eval_operand(index, source_info)
+                                    .expect("index must be const");
+                                let index = self
+                                    .ecx
+                                    .read_scalar(index)
+                                    .unwrap()
+                                    .to_machine_usize(&self.tcx)
+                                    .unwrap();
+                                AssertKind::BoundsCheck { len, index }
+                            }
+                            // Overflow is are already covered by checks on the binary operators.
+                            AssertKind::Overflow(_) | AssertKind::OverflowNeg => return,
+                            // Need proper const propagator for these.
+                            _ => return,
+                        };
+                        self.report_assert_as_lint(
+                            lint::builtin::UNCONDITIONAL_PANIC,
+                            source_info,
+                            "this operation will panic at runtime",
+                            msg,
                         );
                     } else {
                         if self.should_const_prop(value) {
diff --git a/src/librustc_session/lint/builtin.rs b/src/librustc_session/lint/builtin.rs
index 5a360b40d61..603ed4640a0 100644
--- a/src/librustc_session/lint/builtin.rs
+++ b/src/librustc_session/lint/builtin.rs
@@ -41,9 +41,15 @@ declare_lint! {
 }
 
 declare_lint! {
-    pub EXCEEDING_BITSHIFTS,
+    pub ARITHMETIC_OVERFLOW,
     Deny,
-    "shift exceeds the type's number of bits"
+    "arithmetic operation overflows"
+}
+
+declare_lint! {
+    pub UNCONDITIONAL_PANIC,
+    Deny,
+    "operation will cause a panic at runtime"
 }
 
 declare_lint! {
@@ -495,7 +501,8 @@ declare_lint_pass! {
     /// that are used by other parts of the compiler.
     HardwiredLints => [
         ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
-        EXCEEDING_BITSHIFTS,
+        ARITHMETIC_OVERFLOW,
+        UNCONDITIONAL_PANIC,
         UNUSED_IMPORTS,
         UNUSED_EXTERN_CRATES,
         UNUSED_QUALIFICATIONS,
diff --git a/src/test/codegen/issue-56927.rs b/src/test/codegen/issue-56927.rs
index 0544ff86aac..d502673e2f8 100644
--- a/src/test/codegen/issue-56927.rs
+++ b/src/test/codegen/issue-56927.rs
@@ -23,7 +23,7 @@ pub fn test1(s: &mut S) {
 
 // CHECK-LABEL: @test2
 // CHECK: store i32 4, i32* %{{.+}}, align 4
-#[allow(const_err)]
+#[allow(unconditional_panic)]
 #[no_mangle]
 pub fn test2(s: &mut S) {
     s.arr[usize::MAX / 4 + 1] = 4;
diff --git a/src/test/compile-fail/consts/const-err3.rs b/src/test/compile-fail/consts/const-err3.rs
deleted file mode 100644
index fc10824f0c0..00000000000
--- a/src/test/compile-fail/consts/const-err3.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![feature(rustc_attrs)]
-#![deny(const_err)]
-
-fn black_box<T>(_: T) {
-    unimplemented!()
-}
-
-fn main() {
-    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];
-    //~^ ERROR const_err
-    black_box(b);
-    black_box(c);
-    black_box(d);
-}
diff --git a/src/test/incremental/warnings-reemitted.rs b/src/test/incremental/warnings-reemitted.rs
index 5fc89395827..0eac2a1d57f 100644
--- a/src/test/incremental/warnings-reemitted.rs
+++ b/src/test/incremental/warnings-reemitted.rs
@@ -2,8 +2,8 @@
 // compile-flags: -Coverflow-checks=on
 // build-pass (FIXME(62277): could be check-pass?)
 
-#![warn(const_err)]
+#![warn(arithmetic_overflow)]
 
 fn main() {
-    let _ = 255u8 + 1; //~ WARNING attempt to add with overflow
+    let _ = 255u8 + 1; //~ WARNING operation will overflow
 }
diff --git a/src/test/run-fail/mir_indexing_oob_1.rs b/src/test/run-fail/mir_indexing_oob_1.rs
index 0ae0320b124..1cd53e309eb 100644
--- a/src/test/run-fail/mir_indexing_oob_1.rs
+++ b/src/test/run-fail/mir_indexing_oob_1.rs
@@ -2,7 +2,7 @@
 
 const C: [u32; 5] = [0; 5];
 
-#[allow(const_err)]
+#[allow(unconditional_panic)]
 fn test() -> u32 {
     C[10]
 }
diff --git a/src/test/run-fail/mir_indexing_oob_2.rs b/src/test/run-fail/mir_indexing_oob_2.rs
index a7a1177260c..64b260993c9 100644
--- a/src/test/run-fail/mir_indexing_oob_2.rs
+++ b/src/test/run-fail/mir_indexing_oob_2.rs
@@ -2,7 +2,7 @@
 
 const C: &'static [u8; 5] = b"hello";
 
-#[allow(const_err)]
+#[allow(unconditional_panic)]
 fn test() -> u8 {
     C[10]
 }
diff --git a/src/test/run-fail/mir_indexing_oob_3.rs b/src/test/run-fail/mir_indexing_oob_3.rs
index 188460fff78..3688088439b 100644
--- a/src/test/run-fail/mir_indexing_oob_3.rs
+++ b/src/test/run-fail/mir_indexing_oob_3.rs
@@ -2,7 +2,7 @@
 
 const C: &'static [u8; 5] = b"hello";
 
-#[allow(const_err)]
+#[allow(unconditional_panic)]
 fn mir() -> u8 {
     C[10]
 }
diff --git a/src/test/run-fail/overflowing-add.rs b/src/test/run-fail/overflowing-add.rs
index 24602aced9e..5ca91314d95 100644
--- a/src/test/run-fail/overflowing-add.rs
+++ b/src/test/run-fail/overflowing-add.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to add with overflow'
 // compile-flags: -C debug-assertions
 
-#![allow(const_err)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let _x = 200u8 + 200u8 + 200u8;
diff --git a/src/test/run-fail/overflowing-lsh-1.rs b/src/test/run-fail/overflowing-lsh-1.rs
index 37fbf01e487..977cfea0fe0 100644
--- a/src/test/run-fail/overflowing-lsh-1.rs
+++ b/src/test/run-fail/overflowing-lsh-1.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift left with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-lsh-2.rs b/src/test/run-fail/overflowing-lsh-2.rs
index 7b0b37dfed0..3517dacde3a 100644
--- a/src/test/run-fail/overflowing-lsh-2.rs
+++ b/src/test/run-fail/overflowing-lsh-2.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift left with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-lsh-3.rs b/src/test/run-fail/overflowing-lsh-3.rs
index 1768a8e6d31..4a575c3fa7f 100644
--- a/src/test/run-fail/overflowing-lsh-3.rs
+++ b/src/test/run-fail/overflowing-lsh-3.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift left with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-lsh-4.rs b/src/test/run-fail/overflowing-lsh-4.rs
index ec304b4144e..0d3912ce13f 100644
--- a/src/test/run-fail/overflowing-lsh-4.rs
+++ b/src/test/run-fail/overflowing-lsh-4.rs
@@ -4,7 +4,7 @@
 // This function is checking that our automatic truncation does not
 // sidestep the overflow checking.
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-mul.rs b/src/test/run-fail/overflowing-mul.rs
index 48110365a81..2dfc9bb5ae4 100644
--- a/src/test/run-fail/overflowing-mul.rs
+++ b/src/test/run-fail/overflowing-mul.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to multiply with overflow'
 // compile-flags: -C debug-assertions
 
-#![allow(const_err)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let x = 200u8 * 4;
diff --git a/src/test/run-fail/overflowing-neg.rs b/src/test/run-fail/overflowing-neg.rs
index c4afd74241e..f512aa35bed 100644
--- a/src/test/run-fail/overflowing-neg.rs
+++ b/src/test/run-fail/overflowing-neg.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to negate with overflow'
 // compile-flags: -C debug-assertions
 
-#![allow(const_err)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let _x = -std::i8::MIN;
diff --git a/src/test/run-fail/overflowing-rsh-1.rs b/src/test/run-fail/overflowing-rsh-1.rs
index 14514540c06..4592b2b6260 100644
--- a/src/test/run-fail/overflowing-rsh-1.rs
+++ b/src/test/run-fail/overflowing-rsh-1.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift right with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-rsh-2.rs b/src/test/run-fail/overflowing-rsh-2.rs
index 83dcbd13d2a..066267b770d 100644
--- a/src/test/run-fail/overflowing-rsh-2.rs
+++ b/src/test/run-fail/overflowing-rsh-2.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift right with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-rsh-3.rs b/src/test/run-fail/overflowing-rsh-3.rs
index 3521c050659..67e78482866 100644
--- a/src/test/run-fail/overflowing-rsh-3.rs
+++ b/src/test/run-fail/overflowing-rsh-3.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift right with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-rsh-4.rs b/src/test/run-fail/overflowing-rsh-4.rs
index ed1191849e5..1877d5c9685 100644
--- a/src/test/run-fail/overflowing-rsh-4.rs
+++ b/src/test/run-fail/overflowing-rsh-4.rs
@@ -4,7 +4,7 @@
 // This function is checking that our (type-based) automatic
 // truncation does not sidestep the overflow checking.
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-rsh-5.rs b/src/test/run-fail/overflowing-rsh-5.rs
index 58dfc5710ae..20ef324a82a 100644
--- a/src/test/run-fail/overflowing-rsh-5.rs
+++ b/src/test/run-fail/overflowing-rsh-5.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift right with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn main() {
diff --git a/src/test/run-fail/overflowing-rsh-6.rs b/src/test/run-fail/overflowing-rsh-6.rs
index c2fec5e4860..589a98bab04 100644
--- a/src/test/run-fail/overflowing-rsh-6.rs
+++ b/src/test/run-fail/overflowing-rsh-6.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to shift right with overflow'
 // compile-flags: -C debug-assertions
 
-#![warn(exceeding_bitshifts)]
+#![warn(arithmetic_overflow)]
 #![warn(const_err)]
 #![feature(const_indexing)]
 
diff --git a/src/test/run-fail/overflowing-sub.rs b/src/test/run-fail/overflowing-sub.rs
index e3b111dd2bb..fb096c31957 100644
--- a/src/test/run-fail/overflowing-sub.rs
+++ b/src/test/run-fail/overflowing-sub.rs
@@ -1,7 +1,7 @@
 // error-pattern:thread 'main' panicked at 'attempt to subtract with overflow'
 // compile-flags: -C debug-assertions
 
-#![allow(const_err)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let _x = 42u8 - (42u8 + 1);
diff --git a/src/test/run-fail/promoted_div_by_zero.rs b/src/test/run-fail/promoted_div_by_zero.rs
index 3fe51a19c20..dc6719ce025 100644
--- a/src/test/run-fail/promoted_div_by_zero.rs
+++ b/src/test/run-fail/promoted_div_by_zero.rs
@@ -1,4 +1,4 @@
-#![allow(const_err)]
+#![allow(unconditional_panic, const_err)]
 
 // error-pattern: attempt to divide by zero
 
diff --git a/src/test/run-fail/promoted_overflow.rs b/src/test/run-fail/promoted_overflow.rs
index 139bf540959..3c42da4b1d8 100644
--- a/src/test/run-fail/promoted_overflow.rs
+++ b/src/test/run-fail/promoted_overflow.rs
@@ -1,4 +1,4 @@
-#![allow(const_err)]
+#![allow(arithmetic_overflow)]
 
 // error-pattern: overflow
 // compile-flags: -C overflow-checks=yes
diff --git a/src/test/ui/consts/array-literal-index-oob.rs b/src/test/ui/consts/array-literal-index-oob.rs
index af63d1f75a7..492afa9372c 100644
--- a/src/test/ui/consts/array-literal-index-oob.rs
+++ b/src/test/ui/consts/array-literal-index-oob.rs
@@ -1,11 +1,11 @@
 // build-pass
 // ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
 
-#![warn(const_err)]
+#![warn(const_err, unconditional_panic)]
 
 fn main() {
     &{ [1, 2, 3][4] };
-    //~^ WARN index out of bounds
+    //~^ WARN operation will panic
     //~| WARN reaching this expression at runtime will panic or abort
     //~| WARN erroneous constant used [const_err]
 }
diff --git a/src/test/ui/consts/array-literal-index-oob.stderr b/src/test/ui/consts/array-literal-index-oob.stderr
index 59e11697015..6e0e7fedb7b 100644
--- a/src/test/ui/consts/array-literal-index-oob.stderr
+++ b/src/test/ui/consts/array-literal-index-oob.stderr
@@ -1,14 +1,14 @@
-warning: index out of bounds: the len is 3 but the index is 4
+warning: this operation will panic at runtime
   --> $DIR/array-literal-index-oob.rs:7:8
    |
 LL |     &{ [1, 2, 3][4] };
-   |        ^^^^^^^^^^^^
+   |        ^^^^^^^^^^^^ index out of bounds: the len is 3 but the index is 4
    |
 note: the lint level is defined here
-  --> $DIR/array-literal-index-oob.rs:4:9
+  --> $DIR/array-literal-index-oob.rs:4:20
    |
-LL | #![warn(const_err)]
-   |         ^^^^^^^^^
+LL | #![warn(const_err, unconditional_panic)]
+   |                    ^^^^^^^^^^^^^^^^^^^
 
 warning: reaching this expression at runtime will panic or abort
   --> $DIR/array-literal-index-oob.rs:7:8
@@ -17,6 +17,12 @@ LL |     &{ [1, 2, 3][4] };
    |     ---^^^^^^^^^^^^--
    |        |
    |        indexing out of bounds: the len is 3 but the index is 4
+   |
+note: the lint level is defined here
+  --> $DIR/array-literal-index-oob.rs:4:9
+   |
+LL | #![warn(const_err, unconditional_panic)]
+   |         ^^^^^^^^^
 
 warning: erroneous constant used
   --> $DIR/array-literal-index-oob.rs:7:5
diff --git a/src/test/ui/consts/const-err.rs b/src/test/ui/consts/const-err.rs
index b204f705a96..d1c5f4f3f32 100644
--- a/src/test/ui/consts/const-err.rs
+++ b/src/test/ui/consts/const-err.rs
@@ -1,7 +1,7 @@
 // build-fail
 // compile-flags: -Zforce-overflow-checks=on
 
-#![allow(exceeding_bitshifts)]
+#![allow(arithmetic_overflow)]
 #![warn(const_err)]
 
 fn black_box<T>(_: T) {
diff --git a/src/test/ui/consts/const-err2.stderr b/src/test/ui/consts/const-err2.noopt.stderr
index f135bf0b06c..5aeeec4bd14 100644
--- a/src/test/ui/consts/const-err2.stderr
+++ b/src/test/ui/consts/const-err2.noopt.stderr
@@ -1,50 +1,48 @@
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:18:13
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:19:13
    |
 LL |     let a = -std::i8::MIN;
    |             ^^^^^^^^^^^^^ attempt to negate with overflow
    |
-note: the lint level is defined here
-  --> $DIR/const-err2.rs:11:9
-   |
-LL | #![deny(const_err)]
-   |         ^^^^^^^^^
+   = note: `#[deny(arithmetic_overflow)]` on by default
 
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:20:18
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:21:18
    |
 LL |     let a_i128 = -std::i128::MIN;
    |                  ^^^^^^^^^^^^^^^ attempt to negate with overflow
 
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:22:13
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:23:13
    |
 LL |     let b = 200u8 + 200u8 + 200u8;
    |             ^^^^^^^^^^^^^ attempt to add with overflow
 
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:24:18
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:25:18
    |
 LL |     let b_i128 = std::i128::MIN - std::i128::MAX;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
 
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:26:13
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:27:13
    |
 LL |     let c = 200u8 * 4;
    |             ^^^^^^^^^ attempt to multiply with overflow
 
-error: this expression will panic at runtime
-  --> $DIR/const-err2.rs:28:13
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:29:13
    |
 LL |     let d = 42u8 - (42u8 + 1);
    |             ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
 
-error: index out of bounds: the len is 1 but the index is 1
-  --> $DIR/const-err2.rs:30:14
+error: this operation will panic at runtime
+  --> $DIR/const-err2.rs:31:14
    |
 LL |     let _e = [5u8][1];
-   |              ^^^^^^^^
+   |              ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
 
 error: aborting due to 7 previous errors
 
diff --git a/src/test/ui/consts/const-err2.opt.stderr b/src/test/ui/consts/const-err2.opt.stderr
new file mode 100644
index 00000000000..5aeeec4bd14
--- /dev/null
+++ b/src/test/ui/consts/const-err2.opt.stderr
@@ -0,0 +1,48 @@
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:19:13
+   |
+LL |     let a = -std::i8::MIN;
+   |             ^^^^^^^^^^^^^ attempt to negate with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:21:18
+   |
+LL |     let a_i128 = -std::i128::MIN;
+   |                  ^^^^^^^^^^^^^^^ attempt to negate with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:23:13
+   |
+LL |     let b = 200u8 + 200u8 + 200u8;
+   |             ^^^^^^^^^^^^^ attempt to add with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:25:18
+   |
+LL |     let b_i128 = std::i128::MIN - std::i128::MAX;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:27:13
+   |
+LL |     let c = 200u8 * 4;
+   |             ^^^^^^^^^ attempt to multiply with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:29:13
+   |
+LL |     let d = 42u8 - (42u8 + 1);
+   |             ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/const-err2.rs:31:14
+   |
+LL |     let _e = [5u8][1];
+   |              ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: aborting due to 7 previous errors
+
diff --git a/src/test/ui/consts/const-err2.opt_with_overflow_checks.stderr b/src/test/ui/consts/const-err2.opt_with_overflow_checks.stderr
new file mode 100644
index 00000000000..5aeeec4bd14
--- /dev/null
+++ b/src/test/ui/consts/const-err2.opt_with_overflow_checks.stderr
@@ -0,0 +1,48 @@
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:19:13
+   |
+LL |     let a = -std::i8::MIN;
+   |             ^^^^^^^^^^^^^ attempt to negate with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:21:18
+   |
+LL |     let a_i128 = -std::i128::MIN;
+   |                  ^^^^^^^^^^^^^^^ attempt to negate with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:23:13
+   |
+LL |     let b = 200u8 + 200u8 + 200u8;
+   |             ^^^^^^^^^^^^^ attempt to add with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:25:18
+   |
+LL |     let b_i128 = std::i128::MIN - std::i128::MAX;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:27:13
+   |
+LL |     let c = 200u8 * 4;
+   |             ^^^^^^^^^ attempt to multiply with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/const-err2.rs:29:13
+   |
+LL |     let d = 42u8 - (42u8 + 1);
+   |             ^^^^^^^^^^^^^^^^^ attempt to subtract with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/const-err2.rs:31:14
+   |
+LL |     let _e = [5u8][1];
+   |              ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: aborting due to 7 previous errors
+
diff --git a/src/test/ui/consts/const-err2.rs b/src/test/ui/consts/const-err2.rs
index 7c5aaedda35..2c6a987180b 100644
--- a/src/test/ui/consts/const-err2.rs
+++ b/src/test/ui/consts/const-err2.rs
@@ -2,13 +2,14 @@
 // optimized compilation and unoptimized compilation and thus would
 // lead to different lints being emitted
 
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
 // build-fail
-// compile-flags: -O
 
 #![feature(rustc_attrs)]
-#![allow(exceeding_bitshifts)]
-
-#![deny(const_err)]
 
 fn black_box<T>(_: T) {
     unimplemented!()
@@ -16,19 +17,19 @@ fn black_box<T>(_: T) {
 
 fn main() {
     let a = -std::i8::MIN;
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let a_i128 = -std::i128::MIN;
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let b = 200u8 + 200u8 + 200u8;
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let b_i128 = std::i128::MIN - std::i128::MAX;
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let c = 200u8 * 4;
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let d = 42u8 - (42u8 + 1);
-    //~^ ERROR const_err
+    //~^ ERROR arithmetic operation will overflow
     let _e = [5u8][1];
-    //~^ ERROR const_err
+    //~^ ERROR operation will panic
     black_box(a);
     black_box(a_i128);
     black_box(b);
diff --git a/src/test/ui/consts/const-err3.rs b/src/test/ui/consts/const-err3.rs
deleted file mode 100644
index 43aba4a8b01..00000000000
--- a/src/test/ui/consts/const-err3.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// needed because negating int::MIN will behave differently between
-// optimized compilation and unoptimized compilation and thus would
-// lead to different lints being emitted
-
-// build-fail
-// compile-flags: -C overflow-checks=on -O
-
-#![feature(rustc_attrs)]
-#![allow(exceeding_bitshifts)]
-
-#![deny(const_err)]
-
-fn black_box<T>(_: T) {
-    unimplemented!()
-}
-
-fn main() {
-    let a = -std::i8::MIN;
-    //~^ ERROR const_err
-    let a_i128 = -std::i128::MIN;
-    //~^ ERROR const_err
-    let b = 200u8 + 200u8 + 200u8;
-    //~^ ERROR const_err
-    let b_i128 = std::i128::MIN - std::i128::MAX;
-    //~^ ERROR const_err
-    let c = 200u8 * 4;
-    //~^ ERROR const_err
-    let d = 42u8 - (42u8 + 1);
-    //~^ ERROR const_err
-    let _e = [5u8][1];
-    //~^ ERROR const_err
-    black_box(a);
-    black_box(a_i128);
-    black_box(b);
-    black_box(b_i128);
-    black_box(c);
-    black_box(d);
-}
diff --git a/src/test/ui/consts/const-err3.stderr b/src/test/ui/consts/const-err3.stderr
deleted file mode 100644
index 05f64b87fcc..00000000000
--- a/src/test/ui/consts/const-err3.stderr
+++ /dev/null
@@ -1,50 +0,0 @@
-error: attempt to negate with overflow
-  --> $DIR/const-err3.rs:18:13
-   |
-LL |     let a = -std::i8::MIN;
-   |             ^^^^^^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/const-err3.rs:11:9
-   |
-LL | #![deny(const_err)]
-   |         ^^^^^^^^^
-
-error: attempt to negate with overflow
-  --> $DIR/const-err3.rs:20:18
-   |
-LL |     let a_i128 = -std::i128::MIN;
-   |                  ^^^^^^^^^^^^^^^
-
-error: attempt to add with overflow
-  --> $DIR/const-err3.rs:22:13
-   |
-LL |     let b = 200u8 + 200u8 + 200u8;
-   |             ^^^^^^^^^^^^^
-
-error: attempt to subtract with overflow
-  --> $DIR/const-err3.rs:24:18
-   |
-LL |     let b_i128 = std::i128::MIN - std::i128::MAX;
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: attempt to multiply with overflow
-  --> $DIR/const-err3.rs:26:13
-   |
-LL |     let c = 200u8 * 4;
-   |             ^^^^^^^^^
-
-error: attempt to subtract with overflow
-  --> $DIR/const-err3.rs:28:13
-   |
-LL |     let d = 42u8 - (42u8 + 1);
-   |             ^^^^^^^^^^^^^^^^^
-
-error: index out of bounds: the len is 1 but the index is 1
-  --> $DIR/const-err3.rs:30:14
-   |
-LL |     let _e = [5u8][1];
-   |              ^^^^^^^^
-
-error: aborting due to 7 previous errors
-
diff --git a/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.rs b/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.rs
index 6d6bb94d4df..608e6e112a1 100644
--- a/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.rs
+++ b/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.rs
@@ -2,5 +2,5 @@
 
 fn main() {
     let array = [std::env::args().len()];
-    array[1]; //~ ERROR index out of bounds
+    array[1]; //~ ERROR operation will panic
 }
diff --git a/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.stderr b/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
index 9519ccd3c24..4188efd021d 100644
--- a/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
+++ b/src/test/ui/consts/const-eval/index_out_of_bounds_propagated.stderr
@@ -1,10 +1,10 @@
-error: index out of bounds: the len is 1 but the index is 1
+error: this operation will panic at runtime
   --> $DIR/index_out_of_bounds_propagated.rs:5:5
    |
 LL |     array[1];
-   |     ^^^^^^^^
+   |     ^^^^^^^^ index out of bounds: the len is 1 but the index is 1
    |
-   = note: `#[deny(const_err)]` on by default
+   = note: `#[deny(unconditional_panic)]` on by default
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/consts/const-eval/promoted_errors.noopt.stderr b/src/test/ui/consts/const-eval/promoted_errors.noopt.stderr
new file mode 100644
index 00000000000..94c1593240b
--- /dev/null
+++ b/src/test/ui/consts/const-eval/promoted_errors.noopt.stderr
@@ -0,0 +1,78 @@
+warning: this arithmetic operation will overflow
+  --> $DIR/promoted_errors.rs:12:20
+   |
+LL |     println!("{}", 0u32 - 1);
+   |                    ^^^^^^^^ attempt to subtract with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:20
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                    ^^^^^^^^^^^^^^^^^^^
+
+warning: this arithmetic operation will overflow
+  --> $DIR/promoted_errors.rs:14:14
+   |
+LL |     let _x = 0u32 - 1;
+   |              ^^^^^^^^ attempt to subtract with overflow
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ attempt to divide by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:41
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                                         ^^^^^^^^^^^^^^^^^^^
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ dividing by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:9
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |         ^^^^^^^^^
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:20:14
+   |
+LL |     let _x = 1 / (1 - 1);
+   |              ^^^^^^^^^^^ attempt to divide by zero
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ dividing by zero
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:26:14
+   |
+LL |     let _x = 1 / (false as u32);
+   |              ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
diff --git a/src/test/ui/consts/const-eval/promoted_errors.opt.stderr b/src/test/ui/consts/const-eval/promoted_errors.opt.stderr
new file mode 100644
index 00000000000..034dea06568
--- /dev/null
+++ b/src/test/ui/consts/const-eval/promoted_errors.opt.stderr
@@ -0,0 +1,72 @@
+warning: this arithmetic operation will overflow
+  --> $DIR/promoted_errors.rs:14:14
+   |
+LL |     let _x = 0u32 - 1;
+   |              ^^^^^^^^ attempt to subtract with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:20
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                    ^^^^^^^^^^^^^^^^^^^
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ attempt to divide by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:41
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                                         ^^^^^^^^^^^^^^^^^^^
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ dividing by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:9
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |         ^^^^^^^^^
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:20:14
+   |
+LL |     let _x = 1 / (1 - 1);
+   |              ^^^^^^^^^^^ attempt to divide by zero
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ dividing by zero
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:26:14
+   |
+LL |     let _x = 1 / (false as u32);
+   |              ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
diff --git a/src/test/ui/consts/const-eval/promoted_errors.opt_with_overflow_checks.stderr b/src/test/ui/consts/const-eval/promoted_errors.opt_with_overflow_checks.stderr
new file mode 100644
index 00000000000..94c1593240b
--- /dev/null
+++ b/src/test/ui/consts/const-eval/promoted_errors.opt_with_overflow_checks.stderr
@@ -0,0 +1,78 @@
+warning: this arithmetic operation will overflow
+  --> $DIR/promoted_errors.rs:12:20
+   |
+LL |     println!("{}", 0u32 - 1);
+   |                    ^^^^^^^^ attempt to subtract with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:20
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                    ^^^^^^^^^^^^^^^^^^^
+
+warning: this arithmetic operation will overflow
+  --> $DIR/promoted_errors.rs:14:14
+   |
+LL |     let _x = 0u32 - 1;
+   |              ^^^^^^^^ attempt to subtract with overflow
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ attempt to divide by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:41
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |                                         ^^^^^^^^^^^^^^^^^^^
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ dividing by zero
+   |
+note: the lint level is defined here
+  --> $DIR/promoted_errors.rs:9:9
+   |
+LL | #![warn(const_err, arithmetic_overflow, unconditional_panic)]
+   |         ^^^^^^^^^
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:16:20
+   |
+LL |     println!("{}", 1 / (1 - 1));
+   |                    ^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:20:14
+   |
+LL |     let _x = 1 / (1 - 1);
+   |              ^^^^^^^^^^^ attempt to divide by zero
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
+warning: reaching this expression at runtime will panic or abort
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ dividing by zero
+
+warning: erroneous constant used
+  --> $DIR/promoted_errors.rs:22:20
+   |
+LL |     println!("{}", 1 / (false as u32));
+   |                    ^^^^^^^^^^^^^^^^^^ referenced constant has errors
+
+warning: this operation will panic at runtime
+  --> $DIR/promoted_errors.rs:26:14
+   |
+LL |     let _x = 1 / (false as u32);
+   |              ^^^^^^^^^^^^^^^^^^ attempt to divide by zero
+
diff --git a/src/test/ui/consts/const-eval/promoted_errors.rs b/src/test/ui/consts/const-eval/promoted_errors.rs
index 22f863fb15a..3ab6ce28478 100644
--- a/src/test/ui/consts/const-eval/promoted_errors.rs
+++ b/src/test/ui/consts/const-eval/promoted_errors.rs
@@ -1,23 +1,28 @@
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
 // build-pass
 // ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
-// compile-flags: -O
 
-#![warn(const_err)]
+#![warn(const_err, arithmetic_overflow, unconditional_panic)]
 
 fn main() {
     println!("{}", 0u32 - 1);
+    //[opt_with_overflow_checks,noopt]~^ WARN [arithmetic_overflow]
     let _x = 0u32 - 1;
-    //~^ WARN const_err
+    //~^ WARN [arithmetic_overflow]
     println!("{}", 1 / (1 - 1));
-    //~^ WARN attempt to divide by zero [const_err]
-    //~| WARN const_err
+    //~^ WARN [unconditional_panic]
+    //~| WARN panic or abort [const_err]
     //~| WARN erroneous constant used [const_err]
     let _x = 1 / (1 - 1);
-    //~^ WARN const_err
+    //~^ WARN [unconditional_panic]
     println!("{}", 1 / (false as u32));
-    //~^ WARN attempt to divide by zero [const_err]
-    //~| WARN const_err
+    //~^ WARN [unconditional_panic]
+    //~| WARN panic or abort [const_err]
     //~| WARN erroneous constant used [const_err]
     let _x = 1 / (false as u32);
-    //~^ WARN const_err
+    //~^ WARN [unconditional_panic]
 }
diff --git a/src/test/ui/consts/const-eval/promoted_errors.stderr b/src/test/ui/consts/const-eval/promoted_errors.stderr
deleted file mode 100644
index 08ae5c7a32b..00000000000
--- a/src/test/ui/consts/const-eval/promoted_errors.stderr
+++ /dev/null
@@ -1,60 +0,0 @@
-warning: this expression will panic at runtime
-  --> $DIR/promoted_errors.rs:9:14
-   |
-LL |     let _x = 0u32 - 1;
-   |              ^^^^^^^^ attempt to subtract with overflow
-   |
-note: the lint level is defined here
-  --> $DIR/promoted_errors.rs:5:9
-   |
-LL | #![warn(const_err)]
-   |         ^^^^^^^^^
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors.rs:11:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^
-
-warning: reaching this expression at runtime will panic or abort
-  --> $DIR/promoted_errors.rs:11:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^ dividing by zero
-
-warning: erroneous constant used
-  --> $DIR/promoted_errors.rs:11:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^ referenced constant has errors
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors.rs:15:14
-   |
-LL |     let _x = 1 / (1 - 1);
-   |              ^^^^^^^^^^^
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors.rs:17:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^
-
-warning: reaching this expression at runtime will panic or abort
-  --> $DIR/promoted_errors.rs:17:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^ dividing by zero
-
-warning: erroneous constant used
-  --> $DIR/promoted_errors.rs:17:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^ referenced constant has errors
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors.rs:21:14
-   |
-LL |     let _x = 1 / (false as u32);
-   |              ^^^^^^^^^^^^^^^^^^
-
diff --git a/src/test/ui/consts/const-eval/promoted_errors2.rs b/src/test/ui/consts/const-eval/promoted_errors2.rs
deleted file mode 100644
index 62c77f76d90..00000000000
--- a/src/test/ui/consts/const-eval/promoted_errors2.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// build-pass
-// ignore-pass (emit codegen-time warnings and verify that they are indeed warnings and not errors)
-// compile-flags: -C overflow-checks=on -O
-
-#![warn(const_err)]
-
-fn main() {
-    println!("{}", 0u32 - 1);
-    //~^ WARN attempt to subtract with overflow
-    let _x = 0u32 - 1;
-    //~^ WARN attempt to subtract with overflow
-    println!("{}", 1 / (1 - 1));
-    //~^ WARN attempt to divide by zero [const_err]
-    //~| WARN const_err
-    //~| WARN erroneous constant used [const_err]
-    let _x = 1 / (1 - 1);
-    //~^ WARN const_err
-    println!("{}", 1 / (false as u32));
-    //~^ WARN attempt to divide by zero [const_err]
-    //~| WARN const_err
-    //~| WARN erroneous constant used [const_err]
-    let _x = 1 / (false as u32);
-    //~^ WARN const_err
-}
diff --git a/src/test/ui/consts/const-eval/promoted_errors2.stderr b/src/test/ui/consts/const-eval/promoted_errors2.stderr
deleted file mode 100644
index d1a9cb958e1..00000000000
--- a/src/test/ui/consts/const-eval/promoted_errors2.stderr
+++ /dev/null
@@ -1,66 +0,0 @@
-warning: attempt to subtract with overflow
-  --> $DIR/promoted_errors2.rs:8:20
-   |
-LL |     println!("{}", 0u32 - 1);
-   |                    ^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/promoted_errors2.rs:5:9
-   |
-LL | #![warn(const_err)]
-   |         ^^^^^^^^^
-
-warning: attempt to subtract with overflow
-  --> $DIR/promoted_errors2.rs:10:14
-   |
-LL |     let _x = 0u32 - 1;
-   |              ^^^^^^^^
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors2.rs:12:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^
-
-warning: reaching this expression at runtime will panic or abort
-  --> $DIR/promoted_errors2.rs:12:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^ dividing by zero
-
-warning: erroneous constant used
-  --> $DIR/promoted_errors2.rs:12:20
-   |
-LL |     println!("{}", 1 / (1 - 1));
-   |                    ^^^^^^^^^^^ referenced constant has errors
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors2.rs:16:14
-   |
-LL |     let _x = 1 / (1 - 1);
-   |              ^^^^^^^^^^^
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors2.rs:18:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^
-
-warning: reaching this expression at runtime will panic or abort
-  --> $DIR/promoted_errors2.rs:18:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^ dividing by zero
-
-warning: erroneous constant used
-  --> $DIR/promoted_errors2.rs:18:20
-   |
-LL |     println!("{}", 1 / (false as u32));
-   |                    ^^^^^^^^^^^^^^^^^^ referenced constant has errors
-
-warning: attempt to divide by zero
-  --> $DIR/promoted_errors2.rs:22:14
-   |
-LL |     let _x = 1 / (false as u32);
-   |              ^^^^^^^^^^^^^^^^^^
-
diff --git a/src/test/ui/consts/const-prop-ice.rs b/src/test/ui/consts/const-prop-ice.rs
index 8682d2ee901..5bffe020629 100644
--- a/src/test/ui/consts/const-prop-ice.rs
+++ b/src/test/ui/consts/const-prop-ice.rs
@@ -1,5 +1,5 @@
 // build-fail
 
 fn main() {
-    [0; 3][3u64 as usize]; //~ ERROR the len is 3 but the index is 3
+    [0; 3][3u64 as usize]; //~ ERROR this operation will panic at runtime
 }
diff --git a/src/test/ui/consts/const-prop-ice.stderr b/src/test/ui/consts/const-prop-ice.stderr
index 65502a4ff71..7bb4acb235a 100644
--- a/src/test/ui/consts/const-prop-ice.stderr
+++ b/src/test/ui/consts/const-prop-ice.stderr
@@ -1,10 +1,10 @@
-error: index out of bounds: the len is 3 but the index is 3
+error: this operation will panic at runtime
   --> $DIR/const-prop-ice.rs:4:5
    |
 LL |     [0; 3][3u64 as usize];
-   |     ^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 3 but the index is 3
    |
-   = note: `#[deny(const_err)]` on by default
+   = note: `#[deny(unconditional_panic)]` on by default
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/consts/const-prop-ice2.rs b/src/test/ui/consts/const-prop-ice2.rs
index 6a73483026f..d533e394c06 100644
--- a/src/test/ui/consts/const-prop-ice2.rs
+++ b/src/test/ui/consts/const-prop-ice2.rs
@@ -3,5 +3,5 @@
 fn main() {
     enum Enum { One=1 }
     let xs=[0;1 as usize];
-    println!("{}", xs[Enum::One as usize]); //~ ERROR the len is 1 but the index is 1
+    println!("{}", xs[Enum::One as usize]); //~ ERROR this operation will panic at runtime
 }
diff --git a/src/test/ui/consts/const-prop-ice2.stderr b/src/test/ui/consts/const-prop-ice2.stderr
index cbb8fde80f9..73405eca340 100644
--- a/src/test/ui/consts/const-prop-ice2.stderr
+++ b/src/test/ui/consts/const-prop-ice2.stderr
@@ -1,10 +1,10 @@
-error: index out of bounds: the len is 1 but the index is 1
+error: this operation will panic at runtime
   --> $DIR/const-prop-ice2.rs:6:20
    |
 LL |     println!("{}", xs[Enum::One as usize]);
-   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |                    ^^^^^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
    |
-   = note: `#[deny(const_err)]` on by default
+   = note: `#[deny(unconditional_panic)]` on by default
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/consts/issue-64059-2.rs b/src/test/ui/consts/issue-64059-2.rs
deleted file mode 100644
index 38911c3dcf6..00000000000
--- a/src/test/ui/consts/issue-64059-2.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-// compile-flags: -C overflow-checks=on -O
-// run-pass
-
-fn main() {
-    let _ = -(-0.0);
-}
diff --git a/src/test/ui/consts/issue-64059.rs b/src/test/ui/consts/issue-64059.rs
index c4c895fef66..02c8b725032 100644
--- a/src/test/ui/consts/issue-64059.rs
+++ b/src/test/ui/consts/issue-64059.rs
@@ -1,3 +1,8 @@
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
 // run-pass
 
 fn main() {
diff --git a/src/test/ui/consts/issue-69020.noopt.stderr b/src/test/ui/consts/issue-69020.noopt.stderr
new file mode 100644
index 00000000000..c48a106ef46
--- /dev/null
+++ b/src/test/ui/consts/issue-69020.noopt.stderr
@@ -0,0 +1,30 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:21:22
+   |
+LL |     const NEG: i32 = -i32::MIN + T::NEG;
+   |                      ^^^^^^^^^ attempt to negate with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:23:22
+   |
+LL |     const ADD: i32 = (i32::MAX+1) + T::ADD;
+   |                      ^^^^^^^^^^^^ attempt to add with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:25:22
+   |
+LL |     const DIV: i32 = (1/0) + T::DIV;
+   |                      ^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:27:22
+   |
+LL |     const OOB: i32 = [1][1] + T::OOB;
+   |                      ^^^^^^ index out of bounds: the len is 1 but the index is 1
+
+error: aborting due to 4 previous errors
+
diff --git a/src/test/ui/consts/issue-69020.opt.stderr b/src/test/ui/consts/issue-69020.opt.stderr
new file mode 100644
index 00000000000..c48a106ef46
--- /dev/null
+++ b/src/test/ui/consts/issue-69020.opt.stderr
@@ -0,0 +1,30 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:21:22
+   |
+LL |     const NEG: i32 = -i32::MIN + T::NEG;
+   |                      ^^^^^^^^^ attempt to negate with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:23:22
+   |
+LL |     const ADD: i32 = (i32::MAX+1) + T::ADD;
+   |                      ^^^^^^^^^^^^ attempt to add with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:25:22
+   |
+LL |     const DIV: i32 = (1/0) + T::DIV;
+   |                      ^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:27:22
+   |
+LL |     const OOB: i32 = [1][1] + T::OOB;
+   |                      ^^^^^^ index out of bounds: the len is 1 but the index is 1
+
+error: aborting due to 4 previous errors
+
diff --git a/src/test/ui/consts/issue-69020.opt_with_overflow_checks.stderr b/src/test/ui/consts/issue-69020.opt_with_overflow_checks.stderr
new file mode 100644
index 00000000000..c48a106ef46
--- /dev/null
+++ b/src/test/ui/consts/issue-69020.opt_with_overflow_checks.stderr
@@ -0,0 +1,30 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:21:22
+   |
+LL |     const NEG: i32 = -i32::MIN + T::NEG;
+   |                      ^^^^^^^^^ attempt to negate with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-69020.rs:23:22
+   |
+LL |     const ADD: i32 = (i32::MAX+1) + T::ADD;
+   |                      ^^^^^^^^^^^^ attempt to add with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:25:22
+   |
+LL |     const DIV: i32 = (1/0) + T::DIV;
+   |                      ^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-69020.rs:27:22
+   |
+LL |     const OOB: i32 = [1][1] + T::OOB;
+   |                      ^^^^^^ index out of bounds: the len is 1 but the index is 1
+
+error: aborting due to 4 previous errors
+
diff --git a/src/test/ui/consts/issue-69020.rs b/src/test/ui/consts/issue-69020.rs
new file mode 100644
index 00000000000..e079feb04d4
--- /dev/null
+++ b/src/test/ui/consts/issue-69020.rs
@@ -0,0 +1,29 @@
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
+#![crate_type="lib"]
+
+use std::i32;
+
+pub trait Foo {
+    const NEG: i32;
+    const ADD: i32;
+    const DIV: i32;
+    const OOB: i32;
+}
+
+// These constants cannot be evaluated already (they depend on `T::N`), so
+// they can just be linted like normal run-time code.  But codegen works
+// a bit different in const context, so this test makes sure that we still catch overflow.
+impl<T: Foo> Foo for Vec<T> {
+    const NEG: i32 = -i32::MIN + T::NEG;
+    //~^ ERROR arithmetic operation will overflow
+    const ADD: i32 = (i32::MAX+1) + T::ADD;
+    //~^ ERROR arithmetic operation will overflow
+    const DIV: i32 = (1/0) + T::DIV;
+    //~^ ERROR operation will panic
+    const OOB: i32 = [1][1] + T::OOB;
+    //~^ ERROR operation will panic
+}
diff --git a/src/test/ui/huge-array-simple-32.rs b/src/test/ui/huge-array-simple-32.rs
index 3e574dfa07b..2290e3d5e76 100644
--- a/src/test/ui/huge-array-simple-32.rs
+++ b/src/test/ui/huge-array-simple-32.rs
@@ -4,7 +4,7 @@
 // FIXME https://github.com/rust-lang/rust/issues/59774
 // normalize-stderr-test "thread.*panicked.*Metadata module not compiled.*\n" -> ""
 // normalize-stderr-test "note:.*RUST_BACKTRACE=1.*\n" -> ""
-#![allow(exceeding_bitshifts)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let _fat: [u8; (1<<31)+(1<<15)] = //~ ERROR too big for the current architecture
diff --git a/src/test/ui/huge-array-simple-64.rs b/src/test/ui/huge-array-simple-64.rs
index d4c93301283..02c961fc5fa 100644
--- a/src/test/ui/huge-array-simple-64.rs
+++ b/src/test/ui/huge-array-simple-64.rs
@@ -4,7 +4,7 @@
 // FIXME https://github.com/rust-lang/rust/issues/59774
 // normalize-stderr-test "thread.*panicked.*Metadata module not compiled.*\n" -> ""
 // normalize-stderr-test "note:.*RUST_BACKTRACE=1.*\n" -> ""
-#![allow(exceeding_bitshifts)]
+#![allow(arithmetic_overflow)]
 
 fn main() {
     let _fat: [u8; (1<<61)+(1<<31)] = //~ ERROR too big for the current architecture
diff --git a/src/test/ui/issues/issue-54348.rs b/src/test/ui/issues/issue-54348.rs
index fd9a9e024aa..5c38d7c42f6 100644
--- a/src/test/ui/issues/issue-54348.rs
+++ b/src/test/ui/issues/issue-54348.rs
@@ -2,6 +2,6 @@
 
 fn main() {
     [1][0u64 as usize];
-    [1][1.5 as usize]; //~ ERROR index out of bounds
-    [1][1u64 as usize]; //~ ERROR index out of bounds
+    [1][1.5 as usize]; //~ ERROR operation will panic
+    [1][1u64 as usize]; //~ ERROR operation will panic
 }
diff --git a/src/test/ui/issues/issue-54348.stderr b/src/test/ui/issues/issue-54348.stderr
index 7619cd7437e..6b67125e36c 100644
--- a/src/test/ui/issues/issue-54348.stderr
+++ b/src/test/ui/issues/issue-54348.stderr
@@ -1,16 +1,16 @@
-error: index out of bounds: the len is 1 but the index is 1
+error: this operation will panic at runtime
   --> $DIR/issue-54348.rs:5:5
    |
 LL |     [1][1.5 as usize];
-   |     ^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
    |
-   = note: `#[deny(const_err)]` on by default
+   = note: `#[deny(unconditional_panic)]` on by default
 
-error: index out of bounds: the len is 1 but the index is 1
+error: this operation will panic at runtime
   --> $DIR/issue-54348.rs:6:5
    |
 LL |     [1][1u64 as usize];
-   |     ^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^ index out of bounds: the len is 1 but the index is 1
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/issues/issue-8460-const.noopt.stderr b/src/test/ui/issues/issue-8460-const.noopt.stderr
new file mode 100644
index 00000000000..3556ec08247
--- /dev/null
+++ b/src/test/ui/issues/issue-8460-const.noopt.stderr
@@ -0,0 +1,150 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:14:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to divide with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:16:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:18:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:20:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:22:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:24:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:26:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:28:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:30:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:32:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:34:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:36:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to divide by zero
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:38:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:40:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:42:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:44:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:46:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:48:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:50:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:52:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:54:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:56:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:58:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:60:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: aborting due to 24 previous errors
+
diff --git a/src/test/ui/issues/issue-8460-const.opt.stderr b/src/test/ui/issues/issue-8460-const.opt.stderr
new file mode 100644
index 00000000000..3556ec08247
--- /dev/null
+++ b/src/test/ui/issues/issue-8460-const.opt.stderr
@@ -0,0 +1,150 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:14:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to divide with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:16:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:18:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:20:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:22:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:24:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:26:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:28:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:30:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:32:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:34:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:36:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to divide by zero
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:38:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:40:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:42:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:44:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:46:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:48:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:50:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:52:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:54:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:56:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:58:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:60:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: aborting due to 24 previous errors
+
diff --git a/src/test/ui/issues/issue-8460-const.opt_with_overflow_checks.stderr b/src/test/ui/issues/issue-8460-const.opt_with_overflow_checks.stderr
new file mode 100644
index 00000000000..3556ec08247
--- /dev/null
+++ b/src/test/ui/issues/issue-8460-const.opt_with_overflow_checks.stderr
@@ -0,0 +1,150 @@
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:14:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to divide with overflow
+   |
+   = note: `#[deny(arithmetic_overflow)]` on by default
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:16:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:18:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:20:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:22:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:24:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to divide with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:26:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to divide by zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:28:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:30:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:32:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:34:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to divide by zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:36:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to divide by zero
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:38:36
+   |
+LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:40:36
+   |
+LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:42:36
+   |
+LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:44:36
+   |
+LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:46:36
+   |
+LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/issue-8460-const.rs:48:36
+   |
+LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
+   |                                    ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:50:36
+   |
+LL |     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
+   |                                    ^^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:52:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
+   |                                    ^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:54:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:56:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:58:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
+   |                                    ^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: this operation will panic at runtime
+  --> $DIR/issue-8460-const.rs:60:36
+   |
+LL |     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
+   |                                    ^^^^^^^^^ attempt to calculate the remainder with a divisor of zero
+
+error: aborting due to 24 previous errors
+
diff --git a/src/test/ui/issues/issue-8460-const.rs b/src/test/ui/issues/issue-8460-const.rs
index 5866cef2d2c..53005e46d2f 100644
--- a/src/test/ui/issues/issue-8460-const.rs
+++ b/src/test/ui/issues/issue-8460-const.rs
@@ -1,5 +1,9 @@
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
 // build-fail
-// compile-flags: -O
 
 #![deny(const_err)]
 
@@ -8,63 +12,51 @@ use std::thread;
 
 fn main() {
     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    //~| ERROR this expression will panic at runtime
+    //~^ ERROR arithmetic operation will overflow
     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
+    //~^ ERROR operation will panic
 }
diff --git a/src/test/ui/issues/issue-8460-const.stderr b/src/test/ui/issues/issue-8460-const.stderr
deleted file mode 100644
index d7373948cb9..00000000000
--- a/src/test/ui/issues/issue-8460-const.stderr
+++ /dev/null
@@ -1,224 +0,0 @@
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:10:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/issue-8460-const.rs:4:9
-   |
-LL | #![deny(const_err)]
-   |         ^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:10:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:13:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:13:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:16:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:16:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:19:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:19:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:22:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:22:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const.rs:25:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:25:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^ attempt to divide with overflow
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:28:36
-   |
-LL |     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
-   |                                    ^^^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:30:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
-   |                                    ^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:32:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:34:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:36:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const.rs:38:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
-   |                                    ^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:40:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:40:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:43:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:43:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:46:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:46:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:49:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:49:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:52:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:52:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const.rs:55:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^
-
-error: this expression will panic at runtime
-  --> $DIR/issue-8460-const.rs:55:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^ attempt to calculate the remainder with overflow
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:58:36
-   |
-LL |     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
-   |                                    ^^^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:60:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
-   |                                    ^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:62:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:64:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:66:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const.rs:68:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
-   |                                    ^^^^^^^^^
-
-error: aborting due to 36 previous errors
-
diff --git a/src/test/ui/issues/issue-8460-const2.rs b/src/test/ui/issues/issue-8460-const2.rs
deleted file mode 100644
index afea859bb65..00000000000
--- a/src/test/ui/issues/issue-8460-const2.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// build-fail
-// compile-flags: -C overflow-checks=on -O
-
-#![deny(const_err)]
-
-use std::{isize, i8, i16, i32, i64, i128};
-use std::thread;
-
-fn main() {
-    assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
-    //~^ ERROR attempt to divide with overflow
-    assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
-    //~^ ERROR attempt to divide by zero
-    assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with overflow
-    assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-    assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-    assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-    assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-    assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-    assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
-    //~^ ERROR attempt to calculate the remainder with a divisor of zero
-}
diff --git a/src/test/ui/issues/issue-8460-const2.stderr b/src/test/ui/issues/issue-8460-const2.stderr
deleted file mode 100644
index e25d560fe0c..00000000000
--- a/src/test/ui/issues/issue-8460-const2.stderr
+++ /dev/null
@@ -1,152 +0,0 @@
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:10:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/issue-8460-const2.rs:4:9
-   |
-LL | #![deny(const_err)]
-   |         ^^^^^^^^^
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:12:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:14:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:16:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:18:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to divide with overflow
-  --> $DIR/issue-8460-const2.rs:20:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:22:36
-   |
-LL |     assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
-   |                                    ^^^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:24:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
-   |                                    ^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:26:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:28:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:30:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to divide by zero
-  --> $DIR/issue-8460-const2.rs:32:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
-   |                                    ^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:34:36
-   |
-LL |     assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:36:36
-   |
-LL |     assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:38:36
-   |
-LL |     assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:40:36
-   |
-LL |     assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:42:36
-   |
-LL |     assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with overflow
-  --> $DIR/issue-8460-const2.rs:44:36
-   |
-LL |     assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
-   |                                    ^^^^^^^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:46:36
-   |
-LL |     assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
-   |                                    ^^^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:48:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
-   |                                    ^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:50:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:52:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:54:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
-   |                                    ^^^^^^^^
-
-error: attempt to calculate the remainder with a divisor of zero
-  --> $DIR/issue-8460-const2.rs:56:36
-   |
-LL |     assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
-   |                                    ^^^^^^^^^
-
-error: aborting due to 24 previous errors
-
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts.noopt.stderr b/src/test/ui/lint/lint-exceeding-bitshifts.noopt.stderr
new file mode 100644
index 00000000000..ce9b02b6d82
--- /dev/null
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.noopt.stderr
@@ -0,0 +1,146 @@
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:22:13
+   |
+LL |     let _ = x << 42;
+   |             ^^^^^^^ attempt to shift left with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/lint-exceeding-bitshifts.rs:9:9
+   |
+LL | #![deny(arithmetic_overflow, const_err)]
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:27:15
+   |
+LL |       let n = 1u8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:29:15
+   |
+LL |       let n = 1u16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:31:15
+   |
+LL |       let n = 1u32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:33:15
+   |
+LL |       let n = 1u64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:35:15
+   |
+LL |       let n = 1i8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:37:15
+   |
+LL |       let n = 1i16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:39:15
+   |
+LL |       let n = 1i32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:41:15
+   |
+LL |       let n = 1i64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:44:15
+   |
+LL |       let n = 1u8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:46:15
+   |
+LL |       let n = 1u16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:48:15
+   |
+LL |       let n = 1u32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:50:15
+   |
+LL |       let n = 1u64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:52:15
+   |
+LL |       let n = 1i8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:54:15
+   |
+LL |       let n = 1i16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:56:15
+   |
+LL |       let n = 1i32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:58:15
+   |
+LL |       let n = 1i64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:62:15
+   |
+LL |       let n = n << 8;
+   |               ^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:64:15
+   |
+LL |       let n = 1u8 << -8;
+   |               ^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:69:15
+   |
+LL |       let n = 1u8 << (4+4);
+   |               ^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:71:15
+   |
+LL |       let n = 1i64 >> [64][0];
+   |               ^^^^^^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:77:15
+   |
+LL |       let n = 1_isize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:78:15
+   |
+LL |       let n = 1_usize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: aborting due to 23 previous errors
+
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts.opt.stderr b/src/test/ui/lint/lint-exceeding-bitshifts.opt.stderr
new file mode 100644
index 00000000000..ce9b02b6d82
--- /dev/null
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.opt.stderr
@@ -0,0 +1,146 @@
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:22:13
+   |
+LL |     let _ = x << 42;
+   |             ^^^^^^^ attempt to shift left with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/lint-exceeding-bitshifts.rs:9:9
+   |
+LL | #![deny(arithmetic_overflow, const_err)]
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:27:15
+   |
+LL |       let n = 1u8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:29:15
+   |
+LL |       let n = 1u16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:31:15
+   |
+LL |       let n = 1u32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:33:15
+   |
+LL |       let n = 1u64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:35:15
+   |
+LL |       let n = 1i8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:37:15
+   |
+LL |       let n = 1i16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:39:15
+   |
+LL |       let n = 1i32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:41:15
+   |
+LL |       let n = 1i64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:44:15
+   |
+LL |       let n = 1u8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:46:15
+   |
+LL |       let n = 1u16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:48:15
+   |
+LL |       let n = 1u32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:50:15
+   |
+LL |       let n = 1u64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:52:15
+   |
+LL |       let n = 1i8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:54:15
+   |
+LL |       let n = 1i16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:56:15
+   |
+LL |       let n = 1i32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:58:15
+   |
+LL |       let n = 1i64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:62:15
+   |
+LL |       let n = n << 8;
+   |               ^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:64:15
+   |
+LL |       let n = 1u8 << -8;
+   |               ^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:69:15
+   |
+LL |       let n = 1u8 << (4+4);
+   |               ^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:71:15
+   |
+LL |       let n = 1i64 >> [64][0];
+   |               ^^^^^^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:77:15
+   |
+LL |       let n = 1_isize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:78:15
+   |
+LL |       let n = 1_usize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: aborting due to 23 previous errors
+
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts.opt_with_overflow_checks.stderr b/src/test/ui/lint/lint-exceeding-bitshifts.opt_with_overflow_checks.stderr
new file mode 100644
index 00000000000..ce9b02b6d82
--- /dev/null
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.opt_with_overflow_checks.stderr
@@ -0,0 +1,146 @@
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:22:13
+   |
+LL |     let _ = x << 42;
+   |             ^^^^^^^ attempt to shift left with overflow
+   |
+note: the lint level is defined here
+  --> $DIR/lint-exceeding-bitshifts.rs:9:9
+   |
+LL | #![deny(arithmetic_overflow, const_err)]
+   |         ^^^^^^^^^^^^^^^^^^^
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:27:15
+   |
+LL |       let n = 1u8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:29:15
+   |
+LL |       let n = 1u16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:31:15
+   |
+LL |       let n = 1u32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:33:15
+   |
+LL |       let n = 1u64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:35:15
+   |
+LL |       let n = 1i8 << 8;
+   |               ^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:37:15
+   |
+LL |       let n = 1i16 << 16;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:39:15
+   |
+LL |       let n = 1i32 << 32;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:41:15
+   |
+LL |       let n = 1i64 << 64;
+   |               ^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:44:15
+   |
+LL |       let n = 1u8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:46:15
+   |
+LL |       let n = 1u16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:48:15
+   |
+LL |       let n = 1u32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:50:15
+   |
+LL |       let n = 1u64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:52:15
+   |
+LL |       let n = 1i8 >> 8;
+   |               ^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:54:15
+   |
+LL |       let n = 1i16 >> 16;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:56:15
+   |
+LL |       let n = 1i32 >> 32;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:58:15
+   |
+LL |       let n = 1i64 >> 64;
+   |               ^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:62:15
+   |
+LL |       let n = n << 8;
+   |               ^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:64:15
+   |
+LL |       let n = 1u8 << -8;
+   |               ^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:69:15
+   |
+LL |       let n = 1u8 << (4+4);
+   |               ^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:71:15
+   |
+LL |       let n = 1i64 >> [64][0];
+   |               ^^^^^^^^^^^^^^^ attempt to shift right with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:77:15
+   |
+LL |       let n = 1_isize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: this arithmetic operation will overflow
+  --> $DIR/lint-exceeding-bitshifts.rs:78:15
+   |
+LL |       let n = 1_usize << BITS;
+   |               ^^^^^^^^^^^^^^^ attempt to shift left with overflow
+
+error: aborting due to 23 previous errors
+
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts.rs b/src/test/ui/lint/lint-exceeding-bitshifts.rs
index 121e5b796bb..7deee5320a8 100644
--- a/src/test/ui/lint/lint-exceeding-bitshifts.rs
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.rs
@@ -1,50 +1,79 @@
+// revisions: noopt opt opt_with_overflow_checks
+//[noopt]compile-flags: -C opt-level=0
+//[opt]compile-flags: -O
+//[opt_with_overflow_checks]compile-flags: -C overflow-checks=on -O
+
 // build-fail
-// compile-flags: -O
 
-#![deny(exceeding_bitshifts, const_err)]
+#![crate_type="lib"]
+#![deny(arithmetic_overflow, const_err)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
-fn main() {
+pub trait Foo {
+    const N: i32;
+}
+
+impl<T: Foo> Foo for Vec<T> {
+    const N: i32 = T::N << 42; // FIXME this should warn
+}
+
+pub fn foo(x: i32) {
+    let _ = x << 42; //~ ERROR: arithmetic operation will overflow
+}
+
+pub fn main() {
       let n = 1u8 << 7;
-      let n = 1u8 << 8;   //~ ERROR: attempt to shift left with overflow
+      let n = 1u8 << 8;   //~ ERROR: arithmetic operation will overflow
       let n = 1u16 << 15;
-      let n = 1u16 << 16; //~ ERROR: attempt to shift left with overflow
+      let n = 1u16 << 16; //~ ERROR: arithmetic operation will overflow
       let n = 1u32 << 31;
-      let n = 1u32 << 32; //~ ERROR: attempt to shift left with overflow
+      let n = 1u32 << 32; //~ ERROR: arithmetic operation will overflow
       let n = 1u64 << 63;
-      let n = 1u64 << 64; //~ ERROR: attempt to shift left with overflow
+      let n = 1u64 << 64; //~ ERROR: arithmetic operation will overflow
       let n = 1i8 << 7;
-      let n = 1i8 << 8;   //~ ERROR: attempt to shift left with overflow
+      let n = 1i8 << 8;   //~ ERROR: arithmetic operation will overflow
       let n = 1i16 << 15;
-      let n = 1i16 << 16; //~ ERROR: attempt to shift left with overflow
+      let n = 1i16 << 16; //~ ERROR: arithmetic operation will overflow
       let n = 1i32 << 31;
-      let n = 1i32 << 32; //~ ERROR: attempt to shift left with overflow
+      let n = 1i32 << 32; //~ ERROR: arithmetic operation will overflow
       let n = 1i64 << 63;
-      let n = 1i64 << 64; //~ ERROR: attempt to shift left with overflow
+      let n = 1i64 << 64; //~ ERROR: arithmetic operation will overflow
 
       let n = 1u8 >> 7;
-      let n = 1u8 >> 8;   //~ ERROR: attempt to shift right with overflow
+      let n = 1u8 >> 8;   //~ ERROR: arithmetic operation will overflow
       let n = 1u16 >> 15;
-      let n = 1u16 >> 16; //~ ERROR: attempt to shift right with overflow
+      let n = 1u16 >> 16; //~ ERROR: arithmetic operation will overflow
       let n = 1u32 >> 31;
-      let n = 1u32 >> 32; //~ ERROR: attempt to shift right with overflow
+      let n = 1u32 >> 32; //~ ERROR: arithmetic operation will overflow
       let n = 1u64 >> 63;
-      let n = 1u64 >> 64; //~ ERROR: attempt to shift right with overflow
+      let n = 1u64 >> 64; //~ ERROR: arithmetic operation will overflow
       let n = 1i8 >> 7;
-      let n = 1i8 >> 8;   //~ ERROR: attempt to shift right with overflow
+      let n = 1i8 >> 8;   //~ ERROR: arithmetic operation will overflow
       let n = 1i16 >> 15;
-      let n = 1i16 >> 16; //~ ERROR: attempt to shift right with overflow
+      let n = 1i16 >> 16; //~ ERROR: arithmetic operation will overflow
       let n = 1i32 >> 31;
-      let n = 1i32 >> 32; //~ ERROR: attempt to shift right with overflow
+      let n = 1i32 >> 32; //~ ERROR: arithmetic operation will overflow
       let n = 1i64 >> 63;
-      let n = 1i64 >> 64; //~ ERROR: attempt to shift right with overflow
+      let n = 1i64 >> 64; //~ ERROR: arithmetic operation will overflow
 
       let n = 1u8;
       let n = n << 7;
-      let n = n << 8; //~ ERROR: attempt to shift left with overflow
+      let n = n << 8; //~ ERROR: arithmetic operation will overflow
 
-      let n = 1u8 << -8; //~ ERROR: attempt to shift left with overflow
+      let n = 1u8 << -8; //~ ERROR: arithmetic operation will overflow
 
       let n = 1i8<<(1isize+-1);
+
+      let n = 1u8 << (4+3);
+      let n = 1u8 << (4+4); //~ ERROR: arithmetic operation will overflow
+      let n = 1i64 >> [63][0];
+      let n = 1i64 >> [64][0]; //~ ERROR: arithmetic operation will overflow
+
+      #[cfg(target_pointer_width = "32")]
+      const BITS: usize = 32;
+      #[cfg(target_pointer_width = "64")]
+      const BITS: usize = 64;
+      let n = 1_isize << BITS; //~ ERROR: arithmetic operation will overflow
+      let n = 1_usize << BITS; //~ ERROR: arithmetic operation will overflow
 }
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts.stderr b/src/test/ui/lint/lint-exceeding-bitshifts.stderr
deleted file mode 100644
index 658577213b3..00000000000
--- a/src/test/ui/lint/lint-exceeding-bitshifts.stderr
+++ /dev/null
@@ -1,116 +0,0 @@
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:10:15
-   |
-LL |       let n = 1u8 << 8;
-   |               ^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/lint-exceeding-bitshifts.rs:4:9
-   |
-LL | #![deny(exceeding_bitshifts, const_err)]
-   |         ^^^^^^^^^^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:12:15
-   |
-LL |       let n = 1u16 << 16;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:14:15
-   |
-LL |       let n = 1u32 << 32;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:16:15
-   |
-LL |       let n = 1u64 << 64;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:18:15
-   |
-LL |       let n = 1i8 << 8;
-   |               ^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:20:15
-   |
-LL |       let n = 1i16 << 16;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:22:15
-   |
-LL |       let n = 1i32 << 32;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:24:15
-   |
-LL |       let n = 1i64 << 64;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:27:15
-   |
-LL |       let n = 1u8 >> 8;
-   |               ^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:29:15
-   |
-LL |       let n = 1u16 >> 16;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:31:15
-   |
-LL |       let n = 1u32 >> 32;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:33:15
-   |
-LL |       let n = 1u64 >> 64;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:35:15
-   |
-LL |       let n = 1i8 >> 8;
-   |               ^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:37:15
-   |
-LL |       let n = 1i16 >> 16;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:39:15
-   |
-LL |       let n = 1i32 >> 32;
-   |               ^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:41:15
-   |
-LL |       let n = 1i64 >> 64;
-   |               ^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:45:15
-   |
-LL |       let n = n << 8;
-   |               ^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts.rs:47:15
-   |
-LL |       let n = 1u8 << -8;
-   |               ^^^^^^^^^
-
-error: aborting due to 18 previous errors
-
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts2.rs b/src/test/ui/lint/lint-exceeding-bitshifts2.rs
deleted file mode 100644
index 2a7cbc10f77..00000000000
--- a/src/test/ui/lint/lint-exceeding-bitshifts2.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// build-fail
-// compile-flags: -O
-
-#![deny(exceeding_bitshifts, const_err)]
-#![allow(unused_variables)]
-#![allow(dead_code)]
-
-fn main() {
-      let n = 1u8 << (4+3);
-      let n = 1u8 << (4+4); //~ ERROR: attempt to shift left with overflow
-      let n = 1i64 >> [63][0];
-      let n = 1i64 >> [64][0]; //~ ERROR: attempt to shift right with overflow
-
-      #[cfg(target_pointer_width = "32")]
-      const BITS: usize = 32;
-      #[cfg(target_pointer_width = "64")]
-      const BITS: usize = 64;
-      let n = 1_isize << BITS; //~ ERROR: attempt to shift left with overflow
-      let n = 1_usize << BITS; //~ ERROR: attempt to shift left with overflow
-}
diff --git a/src/test/ui/lint/lint-exceeding-bitshifts2.stderr b/src/test/ui/lint/lint-exceeding-bitshifts2.stderr
deleted file mode 100644
index ac9f3b1e56b..00000000000
--- a/src/test/ui/lint/lint-exceeding-bitshifts2.stderr
+++ /dev/null
@@ -1,32 +0,0 @@
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts2.rs:10:15
-   |
-LL |       let n = 1u8 << (4+4);
-   |               ^^^^^^^^^^^^
-   |
-note: the lint level is defined here
-  --> $DIR/lint-exceeding-bitshifts2.rs:4:9
-   |
-LL | #![deny(exceeding_bitshifts, const_err)]
-   |         ^^^^^^^^^^^^^^^^^^^
-
-error: attempt to shift right with overflow
-  --> $DIR/lint-exceeding-bitshifts2.rs:12:15
-   |
-LL |       let n = 1i64 >> [64][0];
-   |               ^^^^^^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts2.rs:18:15
-   |
-LL |       let n = 1_isize << BITS;
-   |               ^^^^^^^^^^^^^^^
-
-error: attempt to shift left with overflow
-  --> $DIR/lint-exceeding-bitshifts2.rs:19:15
-   |
-LL |       let n = 1_usize << BITS;
-   |               ^^^^^^^^^^^^^^^
-
-error: aborting due to 4 previous errors
-