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

@@ -947,13 +947,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

@@ -138,6 +138,8 @@ impl<'tcx> MatchPairTree<'tcx> {
             PatKind::Missing | PatKind::Wild | PatKind::Error(_) => None,
 
             PatKind::Or { ref pats } => {
+                use super::OrderedPatternData;
+
                 let pats: Box<[FlatPat<'tcx>]> =
                     pats.iter().map(|pat| FlatPat::new(place_builder.clone(), pat, cx)).collect();
                 if !pats[0].extra_data.bindings.is_empty() {
@@ -146,7 +148,10 @@ impl<'tcx> MatchPairTree<'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(OrderedPatternData::FromOrPattern);
+                }
+                if pats.iter().any(|pat| !pat.extra_data.guard_patterns.is_empty()) {
+                    extra_data.guard_patterns.push(super::OrderedPatternData::FromOrPattern);
                 }
                 Some(TestableCase::Or { pats })
             }
@@ -217,7 +222,7 @@ impl<'tcx> MatchPairTree<'tcx> {
 
                 // Then push this binding, after any bindings in the subpattern.
                 if let Some(source) = place {
-                    extra_data.bindings.push(super::SubpatternBindings::One(super::Binding {
+                    extra_data.bindings.push(super::OrderedPatternData::One(super::Binding {
                         span: pattern.span,
                         source,
                         var_id: var,
@@ -361,9 +366,10 @@ impl<'tcx> MatchPairTree<'tcx> {
                 Some(TestableCase::Deref { temp, mutability })
             }
 
-            PatKind::Guard { .. } => {
-                // FIXME(guard_patterns)
-                None
+            PatKind::Guard { ref subpattern, condition } => {
+                MatchPairTree::for_pattern(place_builder, subpattern, cx, match_pairs, extra_data);
+                extra_data.guard_patterns.push(super::OrderedPatternData::One(condition));
+                return;
             }
 
             PatKind::Never => Some(TestableCase::Never),