"cannot assign in match guard" error message only triggers if the pattern doesn't bind anything

[meithecatte]

Code

fn meow(mut x: Option<u32>) {
    match x {
        Some(y) if { x = None; false } => loop {},
        _ => loop {},
    }
}

Current output

error[E0506]: cannot assign to `x` because it is borrowed
 --> meow.rs:3:22
  |
3 |         Some(y) if { x = None; false } => loop {},
  |              -       ^^^^^^^^        - borrow later used here
  |              |       |
  |              |       `x` is assigned to here but it was already borrowed
  |              `x` is borrowed here

Desired output

error[E0510]: cannot assign `x` in match guard
 --> meow.rs:3:22
  |
2 |     match x {
  |           - value is immutable in match guard
3 |         Some(y) if { x = None; false } => loop {},
  |                      ^^^^^^^^ cannot assign

Rationale and extra context

No response

Other cases

// with Some(_) instead of Some(y) as the pattern, E0510 is emitted already
fn meow(mut x: Option<u32>) {
    match x {
        Some(_) if { x = None; false } => loop {},
        _ => loop {},
    }
}

Rust Version

rustc 1.87.0-nightly (85abb2763 2025-02-25)
binary: rustc
commit-hash: 85abb276361c424d64743c0965242dd0e7b866d1
commit-date: 2025-02-25
host: x86_64-unknown-linux-gnu
release: 1.87.0-nightly
LLVM version: 20.1.0

Anything else?

No response

[makai410]

It's a shared shallow borrow here at Some(_), differing from Some(y) which is a shared borrow. See

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

Lines 248 to 280 in daf5985

	pub enum FakeBorrowKind {
	/// A shared shallow borrow. The immediately borrowed place must be immutable, but projections
	/// from it don't need to be. For example, a shallow borrow of `a.b` doesn't conflict with a
	/// mutable borrow of `a.b.c`.
	///
	/// This is used when lowering matches: when matching on a place we want to ensure that place
	/// have the same value from the start of the match until an arm is selected. This prevents this
	/// code from compiling:
	/// ```compile_fail,E0510
	/// let mut x = &Some(0);
	/// match *x {
	/// None => (),
	/// Some(_) if { x = &None; false } => (),
	/// Some(_) => (),
	/// }
	/// ```
	/// This can't be a shared borrow because mutably borrowing `(*x as Some).0` should not checking
	/// the discriminant or accessing other variants, because the mutating `(*x as Some).0` can't
	/// affect the discriminant of `x`. E.g. the following is allowed:
	/// ```rust
	/// let mut x = Some(0);
	/// match x {
	/// Some(_)
	/// if {
	/// if let Some(ref mut y) = x {
	/// *y += 1;
	/// };
	/// true
	/// } => {}
	/// _ => {}
	/// }
	/// ```
	Shallow,

It seems that it's by design according to the implement, as far as I can tell.

rust/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

Lines 3716 to 3771 in daf5985

	pub(crate) fn report_illegal_mutation_of_borrowed(
	&mut self,
	location: Location,
	(place, span): (Place<'tcx>, Span),
	loan: &BorrowData<'tcx>,
	) {
	let loan_spans = self.retrieve_borrow_spans(loan);
	let loan_span = loan_spans.args_or_use();
	let descr_place = self.describe_any_place(place.as_ref());
	if let BorrowKind::Fake(_) = loan.kind {
	if let Some(section) = self.classify_immutable_section(loan.assigned_place) {
	let mut err = self.cannot_mutate_in_immutable_section(
	span,
	loan_span,
	&descr_place,
	section,
	"assign",
	);
	loan_spans.var_subdiag(&mut err, Some(loan.kind), |kind, var_span| {
	use crate::session_diagnostics::CaptureVarCause::*;
	match kind {
	hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },
	hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
	BorrowUseInClosure { var_span }
	}
	}
	});
	self.buffer_error(err);
	return;
	}
	}
	let mut err = self.cannot_assign_to_borrowed(span, loan_span, &descr_place);
	self.note_due_to_edition_2024_opaque_capture_rules(loan, &mut err);
	loan_spans.var_subdiag(&mut err, Some(loan.kind), |kind, var_span| {
	use crate::session_diagnostics::CaptureVarCause::*;
	match kind {
	hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },
	hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
	BorrowUseInClosure { var_span }
	}
	}
	});
	self.explain_why_borrow_contains_point(location, loan, None)
	.add_explanation_to_diagnostic(&self, &mut err, "", None, None);
	self.explain_deref_coercion(loan, &mut err);
	self.buffer_error(err);
	}

[meithecatte]

The "borrow later used here" part of the error message points to a closing brace that doesn't actually use the borrow. That is confusing and definitely an oversight.

[makai410]

I see... It presumes shared borrow definitely would be used without further checking. I agree that is an oversight.