1 files changed, 86 insertions, 31 deletions

diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 86f82e3fa..3efbce773 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -2,9 +2,11 @@
 //! through the body using inference results: mismatched arg counts, missing
 //! fields, etc.
 
-use std::sync::Arc;
+use std::{cell::RefCell, sync::Arc};
 
-use hir_def::{expr::Statement, path::path, resolver::HasResolver, AssocItemId, DefWithBodyId};
+use hir_def::{
+    expr::Statement, path::path, resolver::HasResolver, AssocItemId, DefWithBodyId, HasModule,
+};
 use hir_expand::name;
 use rustc_hash::FxHashSet;
 use syntax::{ast, AstPtr};
@@ -12,7 +14,10 @@ use syntax::{ast, AstPtr};
 use crate::{
     db::HirDatabase,
     diagnostics::{
-        match_check::{is_useful, MatchCheckCtx, Matrix, PatStack, Usefulness},
+        match_check::{
+            self,
+            usefulness::{compute_match_usefulness, expand_pattern, MatchCheckCtx, PatternArena},
+        },
         MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkOrSomeInTailExpr,
         MissingPatFields, RemoveThisSemicolon,
     },
@@ -294,12 +299,12 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             &infer.type_of_expr[match_expr]
         };
 
-        let cx = MatchCheckCtx { match_expr, body, infer: infer.clone(), db };
-        let pats = arms.iter().map(|arm| arm.pat);
+        let pattern_arena = RefCell::new(PatternArena::new());
 
-        let mut seen = Matrix::empty();
-        for pat in pats {
-            if let Some(pat_ty) = infer.type_of_pat.get(pat) {
+        let mut m_arms = Vec::new();
+        let mut has_lowering_errors = false;
+        for arm in arms {
+            if let Some(pat_ty) = infer.type_of_pat.get(arm.pat) {
                 // We only include patterns whose type matches the type
                 // of the match expression. If we had a InvalidMatchArmPattern
                 // diagnostic or similar we could raise that in an else
@@ -315,14 +320,25 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                         .as_reference()
                         .map(|(match_expr_ty, ..)| match_expr_ty == pat_ty)
                         .unwrap_or(false))
-                    && types_of_subpatterns_do_match(pat, &cx.body, &infer)
+                    && types_of_subpatterns_do_match(arm.pat, &body, &infer)
                 {
                     // If we had a NotUsefulMatchArm diagnostic, we could
                     // check the usefulness of each pattern as we added it
                     // to the matrix here.
-                    let v = PatStack::from_pattern(pat);
-                    seen.push(&cx, v);
-                    continue;
+                    let m_arm = match_check::MatchArm {
+                        pat: self.lower_pattern(
+                            arm.pat,
+                            &mut pattern_arena.borrow_mut(),
+                            db,
+                            &body,
+                            &mut has_lowering_errors,
+                        ),
+                        has_guard: arm.guard.is_some(),
+                    };
+                    m_arms.push(m_arm);
+                    if !has_lowering_errors {
+                        continue;
+                    }
                 }
             }
 
@@ -330,34 +346,73 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             // fit the match expression, we skip this diagnostic. Skipping the entire
             // diagnostic rather than just not including this match arm is preferred
             // to avoid the chance of false positives.
+            #[cfg(test)]
+            match_check::tests::report_bail_out(db, self.owner, arm.pat, self.sink);
             return;
         }
 
-        match is_useful(&cx, &seen, &PatStack::from_wild()) {
-            Ok(Usefulness::Useful) => (),
-            // if a wildcard pattern is not useful, then all patterns are covered
-            Ok(Usefulness::NotUseful) => return,
-            // this path is for unimplemented checks, so we err on the side of not
-            // reporting any errors
-            _ => return,
-        }
+        let cx = MatchCheckCtx {
+            module: self.owner.module(db.upcast()),
+            match_expr,
+            infer: &infer,
+            db,
+            pattern_arena: &pattern_arena,
+            eprint_panic_context: &|| {
+                use syntax::AstNode;
+                if let Ok(scrutinee_sptr) = source_map.expr_syntax(match_expr) {
+                    let root = scrutinee_sptr.file_syntax(db.upcast());
+                    if let Some(match_ast) = scrutinee_sptr.value.to_node(&root).syntax().parent() {
+                        eprintln!(
+                            "Match checking is about to panic on this expression:\n{}",
+                            match_ast.to_string(),
+                        );
+                    }
+                }
+            },
+        };
+        let report = compute_match_usefulness(&cx, &m_arms);
 
-        if let Ok(source_ptr) = source_map.expr_syntax(id) {
-            let root = source_ptr.file_syntax(db.upcast());
-            if let ast::Expr::MatchExpr(match_expr) = &source_ptr.value.to_node(&root) {
-                if let (Some(match_expr), Some(arms)) =
-                    (match_expr.expr(), match_expr.match_arm_list())
-                {
-                    self.sink.push(MissingMatchArms {
-                        file: source_ptr.file_id,
-                        match_expr: AstPtr::new(&match_expr),
-                        arms: AstPtr::new(&arms),
-                    })
+        // FIXME Report unreacheble arms
+        // https://github.com/rust-lang/rust/blob/25c15cdbe/compiler/rustc_mir_build/src/thir/pattern/check_match.rs#L200-L201
+
+        let witnesses = report.non_exhaustiveness_witnesses;
+        // FIXME Report witnesses
+        // eprintln!("compute_match_usefulness(..) -> {:?}", &witnesses);
+        if !witnesses.is_empty() {
+            if let Ok(source_ptr) = source_map.expr_syntax(id) {
+                let root = source_ptr.file_syntax(db.upcast());
+                if let ast::Expr::MatchExpr(match_expr) = &source_ptr.value.to_node(&root) {
+                    if let (Some(match_expr), Some(arms)) =
+                        (match_expr.expr(), match_expr.match_arm_list())
+                    {
+                        self.sink.push(MissingMatchArms {
+                            file: source_ptr.file_id,
+                            match_expr: AstPtr::new(&match_expr),
+                            arms: AstPtr::new(&arms),
+                        })
+                    }
                 }
             }
         }
     }
 
+    fn lower_pattern(
+        &self,
+        pat: PatId,
+        pattern_arena: &mut PatternArena,
+        db: &dyn HirDatabase,
+        body: &Body,
+        have_errors: &mut bool,
+    ) -> match_check::PatId {
+        let mut patcx = match_check::PatCtxt::new(db, &self.infer, body);
+        let pattern = patcx.lower_pattern(pat);
+        let pattern = pattern_arena.alloc(expand_pattern(pattern));
+        if !patcx.errors.is_empty() {
+            *have_errors = true;
+        }
+        pattern
+    }
+
     fn validate_results_in_tail_expr(&mut self, body_id: ExprId, id: ExprId, db: &dyn HirDatabase) {
         // the mismatch will be on the whole block currently
         let mismatch = match self.infer.type_mismatch_for_expr(body_id) {