From ab8c50f9648065d3f4d2423cfa39a9750d04823d Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Tue, 10 May 2022 17:58:18 -0700 Subject: [PATCH 1/7] Add drop tracking version of yielding-in-match-guard.rs --- .../drop-tracking-yielding-in-match-guards.rs | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs new file mode 100644 index 0000000000000..e6206249d91ea --- /dev/null +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -0,0 +1,25 @@ +// build-pass +// edition:2018 +// compile-flags: -Zdrop-tracking + +// This test is derived from +// https://github.com/rust-lang/rust/issues/72651#issuecomment-668720468 + +// This test demonstrates that, in `async fn g()`, +// indeed a temporary borrow `y` from `x` is live +// while `f().await` is being evaluated. +// Thus, `&'_ u8` should be included in type signature +// of the underlying generator. + +async fn f() -> u8 { 1 } + +async fn i(x: u8) { + match x { + y if f().await == y + 1 => (), + _ => (), + } +} + +fn main() { + let _ = i(8); +} From 577bf0f3542d7cd49967d24811dd58b94ab7ae19 Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Fri, 13 May 2022 13:38:36 -0700 Subject: [PATCH 2/7] Further reduce test case Thanks to @tmiasko for this one! --- .../drop-tracking-yielding-in-match-guards.rs | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs index e6206249d91ea..c818963e46679 100644 --- a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -11,15 +11,11 @@ // Thus, `&'_ u8` should be included in type signature // of the underlying generator. -async fn f() -> u8 { 1 } - -async fn i(x: u8) { - match x { - y if f().await == y + 1 => (), - _ => (), - } -} +#![feature(generators)] fn main() { - let _ = i(8); + let _ = static |x: u8| match x { + y if { yield } == y + 1 => (), + _ => (), + }; } From d5b72058fe24834807c13991b580c712330ec806 Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Fri, 13 May 2022 14:24:41 -0700 Subject: [PATCH 3/7] Count copies of locals as borrowed temporaries --- .../drop_ranges/record_consumed_borrow.rs | 8 +++++++- .../drop-tracking-yielding-in-match-guards.rs | 14 +++++++++++++- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs b/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs index e89a896199615..ec83acf08b755 100644 --- a/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs +++ b/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs @@ -171,7 +171,13 @@ impl<'tcx> expr_use_visitor::Delegate<'tcx> for ExprUseDelegate<'tcx> { .insert(TrackedValue::from_place_with_projections_allowed(place_with_id)); // For copied we treat this mostly like a borrow except that we don't add the place - // to borrowed_temporaries because the copy is consumed. + // to borrowed_temporaries if it is not a local because the copy is consumed. + match place_with_id.place.base { + PlaceBase::Rvalue | PlaceBase::StaticItem | PlaceBase::Upvar(_) => (), + PlaceBase::Local(_) => { + self.places.borrowed_temporaries.insert(place_with_id.hir_id); + } + } } fn mutate( diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs index c818963e46679..9efe64a62e776 100644 --- a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -14,8 +14,20 @@ #![feature(generators)] fn main() { - let _ = static |x: u8| match x { + let _a = static |x: u8| match x { y if { yield } == y + 1 => (), _ => (), }; + + static STATIC: u8 = 42; + let _b = static |x: u8| match x { + y if { yield } == STATIC + 1 => (), + _ => (), + }; + + let upvar = 42u8; + let _c = static |x: u8| match x { + y if { yield } == upvar + 1 => (), + _ => (), + }; } From 7db4c0277de996531c2e794ba16bb6746af65fef Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Tue, 17 May 2022 15:04:05 -0700 Subject: [PATCH 4/7] Revert "Count copies of locals as borrowed temporaries" This reverts commit 0d270b5e9f48268735f9a05462df65c9d1039855. --- .../drop_ranges/record_consumed_borrow.rs | 8 +------- .../drop-tracking-yielding-in-match-guards.rs | 14 +------------- 2 files changed, 2 insertions(+), 20 deletions(-) diff --git a/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs b/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs index ec83acf08b755..e89a896199615 100644 --- a/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs +++ b/compiler/rustc_typeck/src/check/generator_interior/drop_ranges/record_consumed_borrow.rs @@ -171,13 +171,7 @@ impl<'tcx> expr_use_visitor::Delegate<'tcx> for ExprUseDelegate<'tcx> { .insert(TrackedValue::from_place_with_projections_allowed(place_with_id)); // For copied we treat this mostly like a borrow except that we don't add the place - // to borrowed_temporaries if it is not a local because the copy is consumed. - match place_with_id.place.base { - PlaceBase::Rvalue | PlaceBase::StaticItem | PlaceBase::Upvar(_) => (), - PlaceBase::Local(_) => { - self.places.borrowed_temporaries.insert(place_with_id.hir_id); - } - } + // to borrowed_temporaries because the copy is consumed. } fn mutate( diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs index 9efe64a62e776..c818963e46679 100644 --- a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -14,20 +14,8 @@ #![feature(generators)] fn main() { - let _a = static |x: u8| match x { + let _ = static |x: u8| match x { y if { yield } == y + 1 => (), _ => (), }; - - static STATIC: u8 = 42; - let _b = static |x: u8| match x { - y if { yield } == STATIC + 1 => (), - _ => (), - }; - - let upvar = 42u8; - let _c = static |x: u8| match x { - y if { yield } == upvar + 1 => (), - _ => (), - }; } From d08efdec1c0e3c8135a547b2853af49a7f107f7e Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Tue, 17 May 2022 15:36:39 -0700 Subject: [PATCH 5/7] Borrow guard patterns for the body of the guard --- compiler/rustc_hir/src/hir.rs | 14 +++++++ .../src/check/generator_interior.rs | 39 ++++++++++++------- compiler/rustc_typeck/src/expr_use_visitor.rs | 21 ++++++++-- .../drop-tracking-yielding-in-match-guards.rs | 9 ----- 4 files changed, 57 insertions(+), 26 deletions(-) diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 81d544c7b96dc..5bd6632640f3b 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1323,6 +1323,20 @@ pub enum Guard<'hir> { IfLet(&'hir Let<'hir>), } +impl<'hir> Guard<'hir> { + /// Returns the body of the guard + /// + /// In other words, returns the e in either of the following: + /// + /// - `if e` + /// - `if let x = e` + pub fn body(&self) -> &'hir Expr<'hir> { + match self { + Guard::If(e) | Guard::IfLet(_, e) => e, + } + } +} + #[derive(Debug, HashStable_Generic)] pub struct ExprField<'hir> { #[stable_hasher(ignore)] diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs index 92a2584a6de4d..d530504489a5e 100644 --- a/compiler/rustc_typeck/src/check/generator_interior.rs +++ b/compiler/rustc_typeck/src/check/generator_interior.rs @@ -285,14 +285,13 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { self.visit_pat(pat); if let Some(ref g) = guard { self.guard_bindings.push(<_>::default()); - ArmPatCollector { - guard_bindings_set: &mut self.guard_bindings_set, - guard_bindings: self - .guard_bindings - .last_mut() - .expect("should have pushed at least one earlier"), + { + ArmPatCollector { + interior_visitor: self, + scope: Scope { id: g.body().hir_id.local_id, data: ScopeData::Node }, + } + .visit_pat(pat); } - .visit_pat(pat); match g { Guard::If(ref e) => { @@ -459,17 +458,31 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { } } -struct ArmPatCollector<'a> { - guard_bindings_set: &'a mut HirIdSet, - guard_bindings: &'a mut SmallVec<[HirId; 4]>, +struct ArmPatCollector<'a, 'b, 'tcx> { + interior_visitor: &'a mut InteriorVisitor<'b, 'tcx>, + scope: Scope, } -impl<'a, 'tcx> Visitor<'tcx> for ArmPatCollector<'a> { +impl<'a, 'b, 'tcx> Visitor<'tcx> for ArmPatCollector<'a, 'b, 'tcx> { fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { intravisit::walk_pat(self, pat); if let PatKind::Binding(_, id, ..) = pat.kind { - self.guard_bindings.push(id); - self.guard_bindings_set.insert(id); + self.interior_visitor + .guard_bindings + .last_mut() + .expect("should have pushed at least one earlier") + .push(id); + self.interior_visitor.guard_bindings_set.insert(id); + + let ty = self.interior_visitor.fcx.typeck_results.borrow().node_type(id); + let ty = self.interior_visitor.fcx.tcx.mk_ref( + // Use `ReErased` as `resolve_interior` is going to replace all the regions anyway. + self.interior_visitor.fcx.tcx.mk_region(ty::ReErased), + ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, + ); + // FIXME: use the right span + let span = rustc_span::DUMMY_SP; + self.interior_visitor.record(ty, id, Some(self.scope), None, span, true); } } } diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs index 6de6b6ee4798d..ad44adb68c69c 100644 --- a/compiler/rustc_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_typeck/src/expr_use_visitor.rs @@ -17,6 +17,7 @@ use rustc_middle::hir::place::ProjectionKind; use rustc_middle::mir::FakeReadCause; use rustc_middle::ty::{self, adjustment, AdtKind, Ty, TyCtxt}; use rustc_target::abi::VariantIdx; +use ty::BorrowKind::ImmBorrow; use crate::mem_categorization as mc; @@ -621,7 +622,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { FakeReadCause::ForMatchedPlace(closure_def_id), discr_place.hir_id, ); - self.walk_pat(discr_place, arm.pat); + self.walk_pat(discr_place, arm.pat, arm.guard.is_some()); if let Some(hir::Guard::If(e)) = arm.guard { self.consume_expr(e) @@ -645,12 +646,17 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { FakeReadCause::ForLet(closure_def_id), discr_place.hir_id, ); - self.walk_pat(discr_place, pat); + self.walk_pat(discr_place, pat, false); } /// The core driver for walking a pattern - fn walk_pat(&mut self, discr_place: &PlaceWithHirId<'tcx>, pat: &hir::Pat<'_>) { - debug!("walk_pat(discr_place={:?}, pat={:?})", discr_place, pat); + fn walk_pat( + &mut self, + discr_place: &PlaceWithHirId<'tcx>, + pat: &hir::Pat<'_>, + has_guard: bool, + ) { + debug!("walk_pat(discr_place={:?}, pat={:?}, has_guard={:?})", discr_place, pat, has_guard); let tcx = self.tcx(); let ExprUseVisitor { ref mc, body_owner: _, ref mut delegate } = *self; @@ -671,6 +677,13 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { delegate.bind(binding_place, binding_place.hir_id); } + // Subtle: MIR desugaring introduces immutable borrows for each pattern + // binding when lowering pattern guards to ensure that the guard does not + // modify the scrutinee. + if has_guard { + delegate.borrow(place, discr_place.hir_id, ImmBorrow); + } + // It is also a borrow or copy/move of the value being matched. // In a cases of pattern like `let pat = upvar`, don't use the span // of the pattern, as this just looks confusing, instead use the span diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs index c818963e46679..646365e435901 100644 --- a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -2,15 +2,6 @@ // edition:2018 // compile-flags: -Zdrop-tracking -// This test is derived from -// https://github.com/rust-lang/rust/issues/72651#issuecomment-668720468 - -// This test demonstrates that, in `async fn g()`, -// indeed a temporary borrow `y` from `x` is live -// while `f().await` is being evaluated. -// Thus, `&'_ u8` should be included in type signature -// of the underlying generator. - #![feature(generators)] fn main() { From fce4c7998b5e013f54f8c3e30dd90b4950d3aeb3 Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Tue, 17 May 2022 16:00:53 -0700 Subject: [PATCH 6/7] Remove old match guard pattern tracking code This is subsumed by the new changes that count pattern variables as bound for the whole guard expression. --- .../src/check/generator_interior.rs | 135 +++++------------- 1 file changed, 38 insertions(+), 97 deletions(-) diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs index d530504489a5e..60d19405bcfaf 100644 --- a/compiler/rustc_typeck/src/check/generator_interior.rs +++ b/compiler/rustc_typeck/src/check/generator_interior.rs @@ -17,7 +17,6 @@ use rustc_middle::middle::region::{self, Scope, ScopeData, YieldData}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::symbol::sym; use rustc_span::Span; -use smallvec::SmallVec; use tracing::debug; mod drop_ranges; @@ -29,13 +28,6 @@ struct InteriorVisitor<'a, 'tcx> { expr_count: usize, kind: hir::GeneratorKind, prev_unresolved_span: Option, - /// Match arm guards have temporary borrows from the pattern bindings. - /// In case there is a yield point in a guard with a reference to such bindings, - /// such borrows can span across this yield point. - /// As such, we need to track these borrows and record them despite of the fact - /// that they may succeed the said yield point in the post-order. - guard_bindings: SmallVec<[SmallVec<[HirId; 4]>; 1]>, - guard_bindings_set: HirIdSet, linted_values: HirIdSet, drop_ranges: DropRanges, } @@ -48,7 +40,6 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { scope: Option, expr: Option<&'tcx Expr<'tcx>>, source_span: Span, - guard_borrowing_from_pattern: bool, ) { use rustc_span::DUMMY_SP; @@ -89,8 +80,7 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { // If it is a borrowing happening in the guard, // it needs to be recorded regardless because they // do live across this yield point. - guard_borrowing_from_pattern - || yield_data.expr_and_pat_count >= self.expr_count + yield_data.expr_and_pat_count >= self.expr_count }) .cloned() }) @@ -196,8 +186,6 @@ pub fn resolve_interior<'a, 'tcx>( expr_count: 0, kind, prev_unresolved_span: None, - guard_bindings: <_>::default(), - guard_bindings_set: <_>::default(), linted_values: <_>::default(), drop_ranges: drop_ranges::compute_drop_ranges(fcx, def_id, body), }; @@ -284,8 +272,41 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { let Arm { guard, pat, body, .. } = arm; self.visit_pat(pat); if let Some(ref g) = guard { - self.guard_bindings.push(<_>::default()); { + // If there is a guard, we need to count all variables bound in the pattern as + // borrowed for the entire guard body, regardless of whether they are accessed. + // We do this by walking the pattern bindings and recording `&T` for any `x: T` + // that is bound. + + struct ArmPatCollector<'a, 'b, 'tcx> { + interior_visitor: &'a mut InteriorVisitor<'b, 'tcx>, + scope: Scope, + } + + impl<'a, 'b, 'tcx> Visitor<'tcx> for ArmPatCollector<'a, 'b, 'tcx> { + fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { + intravisit::walk_pat(self, pat); + if let PatKind::Binding(_, id, ident, ..) = pat.kind { + let ty = + self.interior_visitor.fcx.typeck_results.borrow().node_type(id); + let tcx = self.interior_visitor.fcx.tcx; + let ty = tcx.mk_ref( + // Use `ReErased` as `resolve_interior` is going to replace all the + // regions anyway. + tcx.mk_region(ty::ReErased), + ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, + ); + self.interior_visitor.record( + ty, + id, + Some(self.scope), + None, + ident.span, + ); + } + } + } + ArmPatCollector { interior_visitor: self, scope: Scope { id: g.body().hir_id.local_id, data: ScopeData::Node }, @@ -301,12 +322,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { self.visit_let_expr(l); } } - - let mut scope_var_ids = - self.guard_bindings.pop().expect("should have pushed at least one earlier"); - for var_id in scope_var_ids.drain(..) { - self.guard_bindings_set.remove(&var_id); - } } self.visit_expr(body); } @@ -319,13 +334,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { if let PatKind::Binding(..) = pat.kind { let scope = self.region_scope_tree.var_scope(pat.hir_id.local_id).unwrap(); let ty = self.fcx.typeck_results.borrow().pat_ty(pat); - self.record(ty, pat.hir_id, Some(scope), None, pat.span, false); + self.record(ty, pat.hir_id, Some(scope), None, pat.span); } } fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) { - let mut guard_borrowing_from_pattern = false; - match &expr.kind { ExprKind::Call(callee, args) => match &callee.kind { ExprKind::Path(qpath) => { @@ -352,16 +365,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { } _ => intravisit::walk_expr(self, expr), }, - ExprKind::Path(qpath) => { - intravisit::walk_expr(self, expr); - let res = self.fcx.typeck_results.borrow().qpath_res(qpath, expr.hir_id); - match res { - Res::Local(id) if self.guard_bindings_set.contains(&id) => { - guard_borrowing_from_pattern = true; - } - _ => {} - } - } _ => intravisit::walk_expr(self, expr), } @@ -390,14 +393,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { // If there are adjustments, then record the final type -- // this is the actual value that is being produced. if let Some(adjusted_ty) = self.fcx.typeck_results.borrow().expr_ty_adjusted_opt(expr) { - self.record( - adjusted_ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); + self.record(adjusted_ty, expr.hir_id, scope, Some(expr), expr.span); } // Also record the unadjusted type (which is the only type if @@ -425,68 +421,13 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { // The type table might not have information for this expression // if it is in a malformed scope. (#66387) if let Some(ty) = self.fcx.typeck_results.borrow().expr_ty_opt(expr) { - if guard_borrowing_from_pattern { - // Match guards create references to all the bindings in the pattern that are used - // in the guard, e.g. `y if is_even(y) => ...` becomes `is_even(*r_y)` where `r_y` - // is a reference to `y`, so we must record a reference to the type of the binding. - let tcx = self.fcx.tcx; - let ref_ty = tcx.mk_ref( - // Use `ReErased` as `resolve_interior` is going to replace all the regions anyway. - tcx.mk_region(ty::ReErased), - ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, - ); - self.record( - ref_ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); - } - self.record( - ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); + self.record(ty, expr.hir_id, scope, Some(expr), expr.span); } else { self.fcx.tcx.sess.delay_span_bug(expr.span, "no type for node"); } } } -struct ArmPatCollector<'a, 'b, 'tcx> { - interior_visitor: &'a mut InteriorVisitor<'b, 'tcx>, - scope: Scope, -} - -impl<'a, 'b, 'tcx> Visitor<'tcx> for ArmPatCollector<'a, 'b, 'tcx> { - fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { - intravisit::walk_pat(self, pat); - if let PatKind::Binding(_, id, ..) = pat.kind { - self.interior_visitor - .guard_bindings - .last_mut() - .expect("should have pushed at least one earlier") - .push(id); - self.interior_visitor.guard_bindings_set.insert(id); - - let ty = self.interior_visitor.fcx.typeck_results.borrow().node_type(id); - let ty = self.interior_visitor.fcx.tcx.mk_ref( - // Use `ReErased` as `resolve_interior` is going to replace all the regions anyway. - self.interior_visitor.fcx.tcx.mk_region(ty::ReErased), - ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, - ); - // FIXME: use the right span - let span = rustc_span::DUMMY_SP; - self.interior_visitor.record(ty, id, Some(self.scope), None, span, true); - } - } -} - #[derive(Default)] pub struct SuspendCheckData<'a, 'tcx> { expr: Option<&'tcx Expr<'tcx>>, From 7d1dbdf3de3abcce9bbd571e5c88b890e9a37243 Mon Sep 17 00:00:00 2001 From: Eric Holk Date: Thu, 19 May 2022 16:32:06 -0700 Subject: [PATCH 7/7] Update IfLet syntax --- compiler/rustc_hir/src/hir.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 5bd6632640f3b..57655365cca95 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1332,7 +1332,7 @@ impl<'hir> Guard<'hir> { /// - `if let x = e` pub fn body(&self) -> &'hir Expr<'hir> { match self { - Guard::If(e) | Guard::IfLet(_, e) => e, + Guard::If(e) | Guard::IfLet(Let { init: e, .. }) => e, } } }