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.
2020-02-20 20:18:50 +01:00 · 2020-02-20 20:18:50 +01:00 · d237e0fc6c
commit d237e0fc6c
parent b680a5e7c2 88d14bfbc9
71 changed files with 1614 additions and 1110 deletions
--- 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");
--- 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) {
--- 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,
--- 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;
--- a/src/test/compile-fail/consts/const-err3.rs
+++ b/src/test/compile-fail/consts/const-err3.rs
@ -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);
-}
--- 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
 }
--- 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]
 }
--- 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]
 }
--- 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]
 }
--- 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;
--- 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() {
--- 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() {
--- 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() {
--- 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() {
--- 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;
--- 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;
--- 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() {
--- 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() {
--- 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() {
--- 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() {
--- 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() {
--- 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)]

--- 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);
--- 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

--- 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
--- 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]
 }
--- 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
--- 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) {
--- a/src/test/ui/consts/const-err2.noopt.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

--- a/src/test/ui/consts/const-err2.opt.stderr
+++ 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
+
--- a/src/test/ui/consts/const-err2.opt_with_overflow_checks.stderr
+++ 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
+
--- 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);
--- a/src/test/ui/consts/const-err3.rs
+++ b/src/test/ui/consts/const-err3.rs
@ -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);
-}
--- a/src/test/ui/consts/const-err3.stderr
+++ b/src/test/ui/consts/const-err3.stderr
@ -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
-
--- 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
 }
--- 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

--- a/src/test/ui/consts/const-eval/promoted_errors.noopt.stderr
+++ 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
+
--- a/src/test/ui/consts/const-eval/promoted_errors.opt.stderr
+++ 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
+
--- 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
@ -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
+
--- 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]
 }
--- a/src/test/ui/consts/const-eval/promoted_errors.stderr
+++ b/src/test/ui/consts/const-eval/promoted_errors.stderr
@ -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);
-   |              ^^^^^^^^^^^^^^^^^^
-
--- a/src/test/ui/consts/const-eval/promoted_errors2.rs
+++ b/src/test/ui/consts/const-eval/promoted_errors2.rs
@ -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
-}
--- a/src/test/ui/consts/const-eval/promoted_errors2.stderr
+++ b/src/test/ui/consts/const-eval/promoted_errors2.stderr
@ -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);
-   |              ^^^^^^^^^^^^^^^^^^
-
--- 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
 }
--- 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

--- 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
 }
--- 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

--- a/src/test/ui/consts/issue-64059-2.rs
+++ b/src/test/ui/consts/issue-64059-2.rs
@ -1,6 +0,0 @@
-// compile-flags: -C overflow-checks=on -O
-// run-pass
-
-fn main() {
-    let _ = -(-0.0);
-}
--- 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() {
--- a/src/test/ui/consts/issue-69020.noopt.stderr
+++ 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
+
--- a/src/test/ui/consts/issue-69020.opt.stderr
+++ 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
+
--- a/src/test/ui/consts/issue-69020.opt_with_overflow_checks.stderr
+++ 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
+
--- a/src/test/ui/consts/issue-69020.rs
+++ 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
+}
--- 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
--- 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
--- 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
 }
--- 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

--- a/src/test/ui/issues/issue-8460-const.noopt.stderr
+++ 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
+
--- a/src/test/ui/issues/issue-8460-const.opt.stderr
+++ 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
+
--- 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
@ -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
+
--- 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
 }
--- a/src/test/ui/issues/issue-8460-const.stderr
+++ b/src/test/ui/issues/issue-8460-const.stderr
@ -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
-
--- a/src/test/ui/issues/issue-8460-const2.rs
+++ b/src/test/ui/issues/issue-8460-const2.rs
@ -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
-}
--- a/src/test/ui/issues/issue-8460-const2.stderr
+++ b/src/test/ui/issues/issue-8460-const2.stderr
@ -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
-
--- a/src/test/ui/lint/lint-exceeding-bitshifts.noopt.stderr
+++ 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
+
--- a/src/test/ui/lint/lint-exceeding-bitshifts.opt.stderr
+++ 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
+
--- 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
@ -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
+
--- a/src/test/ui/lint/lint-exceeding-bitshifts.rs
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.rs
@ -1,50 +1,79 @@
-// build-fail
-// compile-flags: -O
+// 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

-#![deny(exceeding_bitshifts, const_err)]
+// build-fail
+
+#![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
 }
--- a/src/test/ui/lint/lint-exceeding-bitshifts.stderr
+++ b/src/test/ui/lint/lint-exceeding-bitshifts.stderr
@ -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
-
--- a/src/test/ui/lint/lint-exceeding-bitshifts2.rs
+++ b/src/test/ui/lint/lint-exceeding-bitshifts2.rs
@ -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
-}
--- a/src/test/ui/lint/lint-exceeding-bitshifts2.stderr
+++ b/src/test/ui/lint/lint-exceeding-bitshifts2.stderr
@ -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
-