Wrong error on wrapping arithmetic with -Zmir-opt-level=2

[bytwise]

I tried this code with -Z mir-opt-level=2:

fn main() {
    println!("{}", 1_u32.wrapping_sub(2_u32));
}

It compiles and runs without mir-opt, but with -Z mir-opt-level=2 or above I get:

error: this arithmetic operation will overflow
   --> src/main.rs:2:13
    |
2   |       println!("{}", 1_u32.wrapping_sub(2_u32));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `1_u32 - 2_u32`, which would overflow
    |

Meta

rustc --version --verbose:

rustc 1.52.0-nightly (0148b971c 2021-02-18)
binary: rustc
commit-hash: 0148b971c921a0831fbf3357e5936eec724e3566
commit-date: 2021-02-18
host: x86_64-apple-darwin
release: 1.52.0-nightly
LLVM version: 11.0.1

[osa1]

Wrapping arithmetic operators are lowered here:

rust/compiler/rustc_mir/src/transform/lower_intrinsics.rs

Lines 43 to 67 in cbca568

	sym::wrapping_add | sym::wrapping_sub | sym::wrapping_mul => {
	if let Some((destination, target)) = *destination {
	let lhs;
	let rhs;
	{
	let mut args = args.drain(..);
	lhs = args.next().unwrap();
	rhs = args.next().unwrap();
	}
	let bin_op = match intrinsic_name {
	sym::wrapping_add => BinOp::Add,
	sym::wrapping_sub => BinOp::Sub,
	sym::wrapping_mul => BinOp::Mul,
	_ => bug!("unexpected intrinsic"),
	};
	block.statements.push(Statement {
	source_info: terminator.source_info,
	kind: StatementKind::Assign(box (
	destination,
	Rvalue::BinaryOp(bin_op, lhs, rhs),
	)),
	});
	terminator.kind = TerminatorKind::Goto { target };
	}
	}

Looking at the type of MIR binary operators:

rust/compiler/rustc_middle/src/mir/mod.rs

Lines 2116 to 2152 in cbca568

	#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
	pub enum BinOp {
	/// The `+` operator (addition)
	Add,
	/// The `-` operator (subtraction)
	Sub,
	/// The `*` operator (multiplication)
	Mul,
	/// The `/` operator (division)
	Div,
	/// The `%` operator (modulus)
	Rem,
	/// The `^` operator (bitwise xor)
	BitXor,
	/// The `&` operator (bitwise and)
	BitAnd,
	/// The `|` operator (bitwise or)
	BitOr,
	/// The `<<` operator (shift left)
	Shl,
	/// The `>>` operator (shift right)
	Shr,
	/// The `==` operator (equality)
	Eq,
	/// The `<` operator (less than)
	Lt,
	/// The `<=` operator (less than or equal to)
	Le,
	/// The `!=` operator (not equal to)
	Ne,
	/// The `>=` operator (greater than or equal to)
	Ge,
	/// The `>` operator (greater than)
	Gt,
	/// The `ptr.offset` operator
	Offset,
	}

This type doesn't have distinct operators for wrapping and checked operations, so in check_binary_op:

rust/compiler/rustc_mir/src/transform/const_prop.rs

Lines 569 to 627 in cbca568

	fn check_binary_op(
	&mut self,
	op: BinOp,
	left: &Operand<'tcx>,
	right: &Operand<'tcx>,
	source_info: SourceInfo,
	) -> Option<()> {
	let r = self.use_ecx(|this| this.ecx.read_immediate(&this.ecx.eval_operand(right, None)?));
	let l = self.use_ecx(|this| this.ecx.read_immediate(&this.ecx.eval_operand(left, None)?));
	// Check for exceeding shifts *even if* we cannot evaluate the LHS.
	if op == BinOp::Shr || op == BinOp::Shl {
	let r = r?;
	// 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 = self.ecx.layout_of(left_ty).ok()?.size;
	let right_size = r.layout.size;
	let r_bits = r.to_scalar().ok();
	// This is basically `force_bits`.
	let r_bits = r_bits.and_then(|r| r.to_bits_or_ptr(right_size, &self.tcx).ok());
	if r_bits.map_or(false, |b| b >= left_size.bits() as u128) {
	debug!("check_binary_op: reporting assert for {:?}", source_info);
	self.report_assert_as_lint(
	lint::builtin::ARITHMETIC_OVERFLOW,
	source_info,
	"this arithmetic operation will overflow",
	AssertKind::Overflow(
	op,
	match l {
	Some(l) => l.to_const_int(),
	// Invent a dummy value, the diagnostic ignores it anyway
	None => ConstInt::new(
	ScalarInt::try_from_uint(1_u8, left_size).unwrap(),
	left_ty.is_signed(),
	left_ty.is_ptr_sized_integral(),
	),
	},
	r.to_const_int(),
	),
	)?;
	}
	}
	if let (Some(l), Some(r)) = (&l, &r) {
	// The remaining operators are handled through `overflowing_binary_op`.
	if self.use_ecx(|this| {
	let (_res, overflow, _ty) = this.ecx.overflowing_binary_op(op, l, r)?;
	Ok(overflow)
	})? {
	self.report_assert_as_lint(
	lint::builtin::ARITHMETIC_OVERFLOW,
	source_info,
	"this arithmetic operation will overflow",
	AssertKind::Overflow(op, l.to_const_int(), r.to_const_int()),
	)?;
	}
	}
	Some(())
	}

(which is where we evaluate the binary op and report an overflow)

As far as I can see there is no way to tell whether overflowing is OK or not.

Should we split MIR binary operators into overflowing and checked variants?