implement resolution of guard condition expressions

Author: max-niederman

compiler/rustc_ast/src/ast.rs

@@ -607,7 +607,7 @@ impl Pat {
     /// Walk top-down and call `it` in each place where a pattern occurs
     /// starting with the root pattern `walk` is called on. If `it` returns
     /// false then we will descend no further but siblings will be processed.
-    pub fn walk(&self, it: &mut impl FnMut(&Pat) -> bool) {
+    pub fn walk<'s>(&'s self, it: &mut impl FnMut(&'s Pat) -> bool) {
         if !it(self) {
             return;
         }

compiler/rustc_resolve/src/late.rs

@@ -732,7 +732,14 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
     fn visit_pat(&mut self, p: &'ast Pat) {
         let prev = self.diag_metadata.current_pat;
         self.diag_metadata.current_pat = Some(p);
-        visit::walk_pat(self, p);
+
+        match p.kind {
+            // We visit only the subpattern, allowing the condition to be resolved later in `resolve_pat`.
+            PatKind::Guard(ref subpat, _) => self.visit_pat(subpat),
+            // Otherwise, we just walk the pattern.
+            _ => visit::walk_pat(self, p),
+        }
+
         self.diag_metadata.current_pat = prev;
     }
     fn visit_local(&mut self, local: &'ast Local) {
@@ -3645,7 +3652,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
     /// See the implementation and `fresh_binding` for more details.
     fn resolve_pattern_inner(
         &mut self,
-        pat: &Pat,
+        pat: &'ast Pat,
         pat_src: PatternSource,
         bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>,
     ) {
@@ -3705,6 +3712,15 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
                     // Prevent visiting `ps` as we've already done so above.
                     return false;
                 }
+                PatKind::Guard(ref subpat, ref cond) => {
+                    self.with_rib(ValueNS, RibKind::Normal, |this| {
+                        this.resolve_pattern_inner(subpat, pat_src, bindings);
+                        this.resolve_expr(cond, None);
+                    });
+
+                    // Prevent visiting `pat` as we've already done so above.
+                    return false;
+                }
                 _ => {}
             }
             true