Range bound error in match has bad error message when integer literal wraps

[Lokathor]

For a match where I'm matching on a u8, I put 251..=256 on accident, and then rather than saying that 256 is out of range for u8, it decided to wrap 256 to 0 and then error that 251 is lower than the end of the range:

error[E0030]: lower range bound must be less than or equal to upper                        
  --> src\lib.rs:86:7
   |
86 |       251..=256 => StarClass::BlueGiant,
   |       ^^^ lower bound larger than upper bound

Clearly this is not a good situation.

[hirschenberger]

I'd like to fix this

@rustbot claim

[JohnTitor]

Triage: I'm going to release assignment due to inactivity.
@hirschenberger If you're still interested in this, feel free to re-claim.
@rustbot release-assignment

[estebank]

Explanation on how to solve this in #81903 (comment):

the error is being emitted here

rust/compiler/rustc_mir_build/src/thir/pattern/mod.rs

Lines 455 to 464 in 50e1ae1

	(RangeEnd::Excluded, _) => {
	struct_span_err!(
	self.tcx.sess,
	span,
	E0579,
	"lower range bound must be less than upper"
	)
	.emit();
	PatKind::Wild
	}

You would also need access to the AST to figure out that the issue is an overflow, unless the const value of variant Scalar actually has the right value (255 instead of 0). If it does, it just requires you to see that the start is 0 and the end is the maximally representable integer in the type being used and add a note to the error explaining what is happening. In the former case, you will need to pass along the expressions available here into the fn emitting the error:

rust/compiler/rustc_mir_build/src/thir/pattern/mod.rs

Lines 521 to 529 in 50e1ae1

	hir::PatKind::Range(ref lo_expr, ref hi_expr, end) => {
	let (lo_expr, hi_expr) = (lo_expr.as_deref(), hi_expr.as_deref());
	let lo_span = lo_expr.map_or(pat.span, |e| e.span);
	let lo = lo_expr.map(|e| self.lower_range_expr(e));
	let hi = hi_expr.map(|e| self.lower_range_expr(e));
	let (lp, hp) = (lo.as_ref().map(|x| &x.0), hi.as_ref().map(|x| &x.0));
	let mut kind = match self.normalize_range_pattern_ends(ty, lp, hp) {
	Some((lc, hc)) => self.lower_pattern_range(ty, lc, hc, end, lo_span),