mirror of
https://github.com/rust-lang/rust.git
synced 2026-05-07 17:18:32 +03:00
bors
e0cb264b81
Stabilize `if let` guards (`feature(if_let_guard)`) ## Summary This proposes the stabilization of `if let` guards (tracking issue: rust-lang/rust#51114, RFC: rust-lang/rfcs#2294). This feature allows `if let` expressions to be used directly within match arm guards, enabling conditional pattern matching within guard clauses. ## What is being stabilized The ability to use `if let` expressions within match arm guards. Example: ```rust enum Command { Run(String), Stop, Pause, } fn process_command(cmd: Command, state: &mut String) { match cmd { Command::Run(name) if let Some(first_char) = name.chars().next() && first_char.is_ascii_alphabetic() => { // Both `name` and `first_char` are available here println!("Running command: {} (starts with '{}')", name, first_char); state.push_str(&format!("Running {}", name)); } Command::Run(name) => { println!("Cannot run command '{}'. Invalid name.", name); } Command::Stop if state.contains("running") => { println!("Stopping current process."); state.clear(); } _ => { println!("Unhandled command or state."); } } } ``` ## Motivation The primary motivation for `if let` guards is to reduce nesting and improve readability when conditional logic depends on pattern matching. Without this feature, such logic requires nested `if let` statements within match arms: ```rust // Without if let guards match value { Some(x) => { if let Ok(y) = compute(x) { // Both `x` and `y` are available here println!("{}, {}", x, y); } } _ => {} } // With if let guards match value { Some(x) if let Ok(y) = compute(x) => { // Both `x` and `y` are available here println!("{}, {}", x, y); } _ => {} } ``` ## Implementation and Testing The feature has been implemented and tested comprehensively across different scenarios: ### Core Functionality Tests **Scoping and variable binding:** - [`scope.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/scope.rs) - Verifies that bindings created in `if let` guards are properly scoped and available in match arms - [`shadowing.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/shadowing.rs) - Tests that variable shadowing works correctly within guards - [`scoping-consistency.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/scoping-consistency.rs) - Ensures temporaries in guards remain valid for the duration of their match arms **Type system integration:** - [`type-inference.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/type-inference.rs) - Confirms type inference works correctly in `if let` guards - [`typeck.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/typeck.rs) - Verifies type mismatches are caught appropriately **Pattern matching semantics:** - [`exhaustive.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/exhaustive.rs) - Validates that `if let` guards are correctly handled in exhaustiveness analysis - [`move-guard-if-let.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let.rs) and [`move-guard-if-let-chain.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/move-guard-if-let-chain.rs) - Test that conditional moves in guards are tracked correctly by the borrow checker ### Error Handling and Diagnostics - [`warns.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/warns.rs) - Tests warnings for irrefutable patterns and unreachable code in guards - [`parens.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/parens.rs) - Ensures parentheses around `let` expressions are properly rejected - [`macro-expanded.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/macro-expanded.rs) - Verifies macro expansions that produce invalid constructs are caught - [`guard-mutability-2.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/guard-mutability-2.rs) - Tests mutability and ownership violations in guards - [`ast-validate-guards.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2497-if-let-chains/ast-validate-guards.rs) - Validates AST-level syntax restrictions ### Drop Order and Temporaries **Key insight:** Unlike `let_chains` in regular `if` expressions, `if let` guards do not have drop order inconsistencies because: 1. Match guards are clearly scoped to their arms 2. There is no "else block" equivalent that could cause temporal confusion - [`drop-order.rs`](https://github.com/rust-lang/rust/blob/5796073c134eaac30475f9a19462c4e716c9119c/tests/ui/rfcs/rfc-2294-if-let-guard/drop-order.rs) - Check drop order of temporaries create in match guards - [`compare-drop-order.rs`](https://github.com/rust-lang/rust/blob/aef3f5fdf052fbbc16e174aef5da6d50832ca316/tests/ui/rfcs/rfc-2294-if-let-guard/compare-drop-order.rs) - Compares drop order between `if let` guards and nested `if let` in match arms, confirming they behave identically across all editions - rust-lang/rust#140981 - A complicated drop order test involved `let chain` was made by @est31 - [`drop-order-comparisons-let-chains.rs`](https://github.com/rust-lang/rust/blob/902b4d28783e03e231d8513082cc30c4fcce5d95/tests/ui/drop/drop-order-comparisons-let-chains.rs) - Compares drop order between `let chains` in `if let guard` and regular `if` expressions - [`if-let-guards.rs`](https://github.com/rust-lang/rust/blob/5650d716e0589e2e145ce9027f35bd534e5f862a/tests/ui/drop/if-let-guards.rs) - Test correctness of drop order for bindings and temporaries - [`if-let-guards-2`](https://github.com/rust-lang/rust/blob/3a6c8c8f3d7ae654fdb6ce1255182bda21680655/tests/ui/drop/if-let-guards-2.rs) - The same test as above but more comprehensive and tests more interactions between different features and their drop order, checking that drop order is correct, created by @traviscross ## Edition Compatibility This feature stabilizes on all editions, unlike `let chains` which was limited to edition 2024. This is safe because: 1. `if let` guards don't suffer from the drop order issues that affected `let chains` in regular `if` expressions 2. The scoping is unambiguous - guards are clearly tied to their match arms 3. Extensive testing confirms identical behavior across all editions ## Interactions with Future Features The lang team has reviewed potential interactions with planned "guard patterns" and determined that stabilizing `if let` guards now does not create obstacles for future work. The scoping and evaluation semantics established here align with what guard patterns will need. ## Unresolved Issues - [x] - rust-lang/rust#140981 - [x] - added tests description by @jieyouxu request - [x] - Concers from @scottmcm about stabilizing this across all editions - [x] - check if drop order in all edition when using `let chains` inside `if let` guard is the same - [x] - interactions with guard patters - [x] - pattern bindings drops before guard bindings https://github.com/rust-lang/rust/pull/143376 - [x] - documentaion (https://github.com/rust-lang/reference/pull/1957) - [ ] (non-blocking) add tests for [this](https://github.com/rust-lang/rust/issues/145237) and [this](https://github.com/rust-lang/rust/pull/141295#issuecomment-3173059821) --- **Related:** - Tracking Issue: rust-lang/rust#51114 - RFC: rust-lang/rfcs#2294 - Documentation PR: https://github.com/rust-lang/reference/pull/1957
96 lines
2.7 KiB
Rust
96 lines
2.7 KiB
Rust
//! The "main crate" of the Rust compiler. This crate contains common
|
|
//! type definitions that are used by the other crates in the rustc
|
|
//! "family". The following are some prominent examples.
|
|
//!
|
|
//! - **HIR.** The "high-level (H) intermediate representation (IR)" is
|
|
//! defined in the [`hir`] module.
|
|
//! - **THIR.** The "typed high-level (H) intermediate representation (IR)"
|
|
//! is defined in the [`thir`] module.
|
|
//! - **MIR.** The "mid-level (M) intermediate representation (IR)" is
|
|
//! defined in the [`mir`] module. This module contains only the
|
|
//! *definition* of the MIR; the passes that transform and operate
|
|
//! on MIR are found in `rustc_const_eval` crate.
|
|
//! - **Types.** The internal representation of types used in rustc is
|
|
//! defined in the [`ty`] module. This includes the
|
|
//! [**type context**][ty::TyCtxt] (or `tcx`), which is the central
|
|
//! context during most of compilation, containing the interners and
|
|
//! other things.
|
|
//!
|
|
//! For more information about how rustc works, see the [rustc dev guide].
|
|
//!
|
|
//! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/
|
|
//!
|
|
//! # Note
|
|
//!
|
|
//! This API is completely unstable and subject to change.
|
|
|
|
// tidy-alphabetical-start
|
|
#![allow(internal_features)]
|
|
#![allow(rustc::direct_use_of_rustc_type_ir)]
|
|
#![cfg_attr(bootstrap, feature(assert_matches))]
|
|
#![cfg_attr(bootstrap, feature(if_let_guard))]
|
|
#![cfg_attr(doc, feature(intra_doc_pointers))]
|
|
#![feature(allocator_api)]
|
|
#![feature(associated_type_defaults)]
|
|
#![feature(box_as_ptr)]
|
|
#![feature(box_patterns)]
|
|
#![feature(closure_track_caller)]
|
|
#![feature(const_default)]
|
|
#![feature(const_trait_impl)]
|
|
#![feature(core_intrinsics)]
|
|
#![feature(debug_closure_helpers)]
|
|
#![feature(decl_macro)]
|
|
#![feature(discriminant_kind)]
|
|
#![feature(extern_types)]
|
|
#![feature(file_buffered)]
|
|
#![feature(gen_blocks)]
|
|
#![feature(min_specialization)]
|
|
#![feature(negative_impls)]
|
|
#![feature(never_type)]
|
|
#![feature(ptr_alignment_type)]
|
|
#![feature(range_bounds_is_empty)]
|
|
#![feature(rustc_attrs)]
|
|
#![feature(sized_hierarchy)]
|
|
#![feature(trait_alias)]
|
|
#![feature(try_blocks)]
|
|
#![feature(try_trait_v2)]
|
|
#![feature(try_trait_v2_residual)]
|
|
#![feature(try_trait_v2_yeet)]
|
|
#![feature(type_alias_impl_trait)]
|
|
#![feature(yeet_expr)]
|
|
#![recursion_limit = "256"]
|
|
// tidy-alphabetical-end
|
|
|
|
#[cfg(test)]
|
|
mod tests;
|
|
|
|
#[macro_use]
|
|
mod macros;
|
|
|
|
#[macro_use]
|
|
pub mod arena;
|
|
pub mod error;
|
|
pub mod hir;
|
|
pub mod hooks;
|
|
pub mod ich;
|
|
pub mod infer;
|
|
pub mod lint;
|
|
pub mod metadata;
|
|
pub mod middle;
|
|
pub mod mir;
|
|
pub mod thir;
|
|
pub mod traits;
|
|
pub mod ty;
|
|
pub mod util;
|
|
pub mod verify_ich;
|
|
|
|
#[macro_use]
|
|
pub mod query;
|
|
#[macro_use]
|
|
pub mod queries;
|
|
#[macro_use]
|
|
pub mod dep_graph;
|
|
|
|
// Allows macros to refer to this crate as `::rustc_middle`
|
|
extern crate self as rustc_middle;
|