Guard patterns: MIR lowering

compiler/rustc_hir_analysis/src/check/region.rs

@@ -213,6 +213,13 @@ fn resolve_arm<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, arm: &'tcx hir:
 
 #[tracing::instrument(level = "debug", skip(visitor))]
 fn resolve_pat<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, pat: &'tcx hir::Pat<'tcx>) {
+    // We walk the whole pattern here to avoid walking `cond` expr another time on `walk_pat`
+    if let PatKind::Guard(pat, cond) = pat.kind {
+        resolve_cond(visitor, cond);
+        resolve_pat(visitor, pat);
+        return;
+    }
+
     // If this is a binding then record the lifetime of that binding.
     if let PatKind::Binding(..) = pat.kind {
         record_var_lifetime(visitor, pat.hir_id.local_id);

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -956,13 +956,14 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                         read_discriminant();
                     }
                 }
+
                 PatKind::Or(_)
                 | PatKind::Box(_)
                 | PatKind::Ref(..)
-                | PatKind::Guard(..)
                 | PatKind::Tuple(..)
                 | PatKind::Wild
                 | PatKind::Missing
+                | PatKind::Guard(..)
                 | PatKind::Err(_) => {
                     // If the PatKind is Or, Box, Ref, Guard, or Tuple, the relevant accesses
                     // are made later as these patterns contains subpatterns.

compiler/rustc_mir_build/src/builder/matches/match_pair.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use rustc_abi::FieldIdx;
 use rustc_middle::mir::{Pinnedness, Place, PlaceElem, ProjectionElem};
 use rustc_middle::span_bug;
-use rustc_middle::thir::{Ascription, DerefPatBorrowMode, FieldPat, Pat, PatKind};
+use rustc_middle::thir::{Ascription, DerefPatBorrowMode, ExprId, FieldPat, Pat, PatKind};
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 use rustc_span::Span;
 
@@ -87,11 +87,15 @@ impl<'tcx> FlatPat<'tcx> {
     /// when squashing any or-patterns.
     fn from_inter_pat(inter_pat: InterPat<'tcx>) -> Self {
         let mut match_pairs = vec![];
+        let mut guard_patterns = vec![];
+        if let Some(guard_pat) = inter_pat.guard {
+            guard_patterns.push(super::OrderedPatternData::One(guard_pat));
+        }
         let mut extra_data = PatternExtraData {
             span: inter_pat.pattern_span,
-            bindings: vec![],
-            ascriptions: vec![],
+            guards: guard_patterns,
             is_never: inter_pat.is_never,
+            ..Default::default()
         };
         squash_inter_pat(inter_pat, &mut match_pairs, &mut extra_data);
 
@@ -114,12 +118,14 @@ fn squash_inter_pat<'tcx>(
         or_subpats,
         ascriptions,
         binding,
+        guard,
         pattern_span,
         is_never: _, // Not needed by `MatchPairTree` forests.
     } = inter_pat;
 
     // Type ascriptions can appear regardless of whether the node is an or-pattern.
     extra_data.ascriptions.extend(ascriptions);
+    guard.inspect(|&g| extra_data.guards.push(super::OrderedPatternData::One(g)));
 
     // Or and non-or patterns have very different handling.
     if let Some(or_subpats) = or_subpats {
@@ -139,7 +145,11 @@ fn squash_inter_pat<'tcx>(
             // or-patterns that will be simplified by `merge_trivial_subcandidates`. In
             // other words, we can assume this expands into subcandidates.
             // FIXME(@dianne): this needs updating/removing if we always merge or-patterns
-            extra_data.bindings.push(super::SubpatternBindings::FromOrPattern);
+            extra_data.bindings.push(super::OrderedPatternData::FromOrPattern);
+        }
+
+        if or_subpats.iter().any(|pat| !pat.extra_data.guards.is_empty()) {
+            extra_data.guards.push(super::OrderedPatternData::FromOrPattern);
         }
 
         match_pairs.push(MatchPairTree {
@@ -179,7 +189,7 @@ fn squash_inter_pat<'tcx>(
         // the binding to `copy_field` will occur before the binding for `x`.
         // See <https://github.com/rust-lang/rust/issues/69971> for more background.
         if let Some(binding) = binding {
-            extra_data.bindings.push(super::SubpatternBindings::One(binding));
+            extra_data.bindings.push(super::OrderedPatternData::One(binding));
         }
     }
 }
@@ -214,6 +224,8 @@ struct InterPat<'tcx> {
     /// Binding to establish for a [`PatKind::Binding`] node.
     binding: Option<super::Binding<'tcx>>,
 
+    guard: Option<ExprId>,
+
     /// Span field of the THIR pattern this node was created from.
     pattern_span: Span,
     /// True if this pattern can never match, because all of its alternatives
@@ -256,6 +268,7 @@ impl<'tcx> InterPat<'tcx> {
         let mut or_subpats = None;
         let mut ascriptions = vec![];
         let mut binding = None;
+        let mut guard = None;
 
         // Apply any type ascriptions to the value at `match_pair.place`.
         if let Some(place) = place
@@ -454,8 +467,10 @@ impl<'tcx> InterPat<'tcx> {
                 Some(TestableCase::Deref { temp, mutability })
             }
 
-            PatKind::Guard { .. } => {
-                // FIXME(guard_patterns)
+            PatKind::Guard { ref subpattern, condition } => {
+                let subpattern = InterPat::lower_thir_pat(cx, place_builder, subpattern);
+                subpats.push(subpattern);
+                guard = Some(condition);
                 None
             }
 
@@ -479,6 +494,7 @@ impl<'tcx> InterPat<'tcx> {
             or_subpats,
             ascriptions,
             binding,
+            guard,
             pattern_span: pattern.span,
             is_never,
         }