E0626 rust type_error ai_generated true

error[E0626]: borrow may still be in use when pattern guard evaluates

ID: rust/e0626-borrow-in-pattern-guard

Also available as: JSON · Markdown · 中文
82%Fix Rate
86%Confidence
1Evidence
2023-11-12First Seen

Version Compatibility

VersionStatusIntroducedDeprecatedNotes
rustc 1.73.0 active — — —
rustc 1.75.0 active — — —
rustc 1.78.0 active — — —

Root Cause

A borrow in a `match` arm's guard condition may still be active when the guard evaluates, because the compiler cannot guarantee the borrow is released before the guard runs, leading to potential aliasing violations.

generic

中文

`match` 分支的守卫条件中的借用可能在守卫求值时仍处于活动状态，因为编译器无法保证借用能在守卫运行前释放，可能导致别名冲突。

Official Documentation

https://doc.rust-lang.org/error_codes/E0626.html

Workarounds

  1. 85% success Refactor the guard condition to use a separate `if let` or a function that takes ownership or a reference with a shorter lifetime. 
    Refactor the guard condition to use a separate `if let` or a function that takes ownership or a reference with a shorter lifetime.
  2. 80% success Bind the value with a reference pattern and then use a separate condition outside the match, e.g., using `matches!` macro. 
    Bind the value with a reference pattern and then use a separate condition outside the match, e.g., using `matches!` macro.
  3. 75% success Use a `match` with a guard that does not borrow, e.g., by copying a boolean flag or using a method that returns a value without borrowing. 
    Use a `match` with a guard that does not borrow, e.g., by copying a boolean flag or using a method that returns a value without borrowing.

中文步骤

  1. Refactor the guard condition to use a separate `if let` or a function that takes ownership or a reference with a shorter lifetime.
  2. Bind the value with a reference pattern and then use a separate condition outside the match, e.g., using `matches!` macro.
  3. Use a `match` with a guard that does not borrow, e.g., by copying a boolean flag or using a method that returns a value without borrowing.

Dead Ends

Common approaches that don't work:

  1. 55% fail

    Cloning creates a new value but the borrow of the original may still be active in the guard's scope; the compiler still sees the borrow.

  2. 65% fail

    Unsafe code can bypass borrow checking but introduces memory safety risks; the compiler still emits the error in safe code.