Replace local copy of exhaustiveness checking with upstream librarified version

11 files changed, 603 insertions, 1952 deletions

diff --git a/Cargo.lock b/Cargo.lock
index a743d1c870a..bdb9feee5f1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -166,7 +166,7 @@ checksum = "5676cea088c32290fe65c82895be9d06dd21e0fa49bb97ca840529e9417ab71a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
  "synstructure",
 ]
 
@@ -313,6 +313,17 @@ dependencies = [
 ]
 
 [[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
 name = "derive_arbitrary"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -320,7 +331,7 @@ checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -581,7 +592,8 @@ dependencies = [
  "profile",
  "project-model",
  "ra-ap-rustc_abi",
- "ra-ap-rustc_index",
+ "ra-ap-rustc_index 0.21.0",
+ "ra-ap-rustc_pattern_analysis",
  "rustc-hash",
  "scoped-tls",
  "smallvec",
@@ -1412,7 +1424,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7816f980fab89e878ff2e916e2077d484e3aa1c619a3cc982c8a417c3dfe45fa"
 dependencies = [
  "bitflags 1.3.2",
- "ra-ap-rustc_index",
+ "ra-ap-rustc_index 0.21.0",
  "tracing",
 ]
 
@@ -1423,7 +1435,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8352918d61aa4afab9f2ed7314cf638976b20949b3d61d2f468c975b0d251f24"
 dependencies = [
  "arrayvec",
- "ra-ap-rustc_index_macros",
+ "ra-ap-rustc_index_macros 0.21.0",
+ "smallvec",
+]
+
+[[package]]
+name = "ra-ap-rustc_index"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5313d7f243b63ef9e58d94355b11aa8499f1328055f1f58adf0a5ea7d2faca"
+dependencies = [
+ "arrayvec",
+ "ra-ap-rustc_index_macros 0.33.0",
  "smallvec",
 ]
 
@@ -1435,7 +1458,19 @@ checksum = "66a9424018828155a3e3596515598f90e68427d8f35eff6df7f0856c73fc58a8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
+ "synstructure",
+]
+
+[[package]]
+name = "ra-ap-rustc_index_macros"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a83108ebf3e73dde205b9c25706209bcd7736480820f90ded28eabaf8b469f25"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
  "synstructure",
 ]
 
@@ -1455,11 +1490,25 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d557201d71792487bd2bab637ab5be9aa6fff59b88e25e12de180b0f9d2df60f"
 dependencies = [
- "ra-ap-rustc_index",
+ "ra-ap-rustc_index 0.21.0",
  "ra-ap-rustc_lexer",
 ]
 
 [[package]]
+name = "ra-ap-rustc_pattern_analysis"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c4085e0c771fd4b883930b599ef42966b855762bbe4052c17673b3253421a6d"
+dependencies = [
+ "derivative",
+ "ra-ap-rustc_index 0.33.0",
+ "rustc-hash",
+ "rustc_apfloat",
+ "smallvec",
+ "tracing",
+]
+
+[[package]]
 name = "rayon"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1593,7 +1642,7 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1609,6 +1658,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
+name = "rustc_apfloat"
+version = "0.2.0+llvm-462a31f5a5ab"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465187772033a5ee566f69fe008df03628fce549a0899aae76f0a0c2e34696be"
+dependencies = [
+ "bitflags 1.3.2",
+ "smallvec",
+]
+
+[[package]]
 name = "ryu"
 version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1670,7 +1729,7 @@ checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1693,7 +1752,7 @@ checksum = "bcec881020c684085e55a25f7fd888954d56609ef363479dc5a1305eb0d40cab"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1707,9 +1766,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "2593d31f82ead8df961d8bd23a64c2ccf2eb5dd34b0a34bfb4dd54011c72009e"
 
 [[package]]
 name = "smol_str"
@@ -1772,6 +1831,17 @@ dependencies = [
 
 [[package]]
 name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
 version = "2.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
@@ -1789,7 +1859,7 @@ checksum = "285ba80e733fac80aa4270fbcdf83772a79b80aa35c97075320abfee4a915b06"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
  "unicode-xid",
 ]
 
@@ -1876,7 +1946,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
@@ -1977,7 +2047,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.39",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 2547f1ccb99..ed5b2eb9b2d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -83,6 +83,7 @@ ra-ap-rustc_lexer = { version = "0.21.0", default-features = false }
 ra-ap-rustc_parse_format = { version = "0.21.0", default-features = false }
 ra-ap-rustc_index = { version = "0.21.0", default-features = false }
 ra-ap-rustc_abi = { version = "0.21.0", default-features = false }
+ra-ap-rustc_pattern_analysis = { version = "0.33.0", default-features = false }
 
 # local crates that aren't published to crates.io. These should not have versions.
 sourcegen = { path = "./crates/sourcegen" }
diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
index adf070fe7da..790e3b414b6 100644
--- a/crates/hir-def/src/lib.rs
+++ b/crates/hir-def/src/lib.rs
@@ -939,6 +939,15 @@ impl From<AssocItemId> for AttrDefId {
         }
     }
 }
+impl From<VariantId> for AttrDefId {
+    fn from(vid: VariantId) -> Self {
+        match vid {
+            VariantId::EnumVariantId(id) => id.into(),
+            VariantId::StructId(id) => id.into(),
+            VariantId::UnionId(id) => id.into(),
+        }
+    }
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum VariantId {
diff --git a/crates/hir-ty/Cargo.toml b/crates/hir-ty/Cargo.toml
index 822a7d3e919..1f8f8744f9e 100644
--- a/crates/hir-ty/Cargo.toml
+++ b/crates/hir-ty/Cargo.toml
@@ -36,6 +36,7 @@ indexmap.workspace = true
 
 ra-ap-rustc_abi.workspace = true
 ra-ap-rustc_index.workspace = true
+ra-ap-rustc_pattern_analysis.workspace = true
 
 
 # local deps
diff --git a/crates/hir-ty/src/diagnostics/expr.rs b/crates/hir-ty/src/diagnostics/expr.rs
index f1bf162bc6b..530608292e6 100644
--- a/crates/hir-ty/src/diagnostics/expr.rs
+++ b/crates/hir-ty/src/diagnostics/expr.rs
@@ -11,6 +11,7 @@ use hir_def::{ItemContainerId, Lookup};
 use hir_expand::name;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
+use rustc_pattern_analysis::usefulness::{compute_match_usefulness, ValidityConstraint};
 use triomphe::Arc;
 use typed_arena::Arena;
 
@@ -18,8 +19,7 @@ use crate::{
     db::HirDatabase,
     diagnostics::match_check::{
         self,
-        deconstruct_pat::DeconstructedPat,
-        usefulness::{compute_match_usefulness, MatchCheckCtx},
+        pat_analysis::{self, DeconstructedPat, MatchCheckCtx, WitnessPat},
     },
     display::HirDisplay,
     InferenceResult, Ty, TyExt,
@@ -152,7 +152,14 @@ impl ExprValidator {
         }
 
         let pattern_arena = Arena::new();
-        let cx = MatchCheckCtx::new(self.owner.module(db.upcast()), self.owner, db, &pattern_arena);
+        let ty_arena = Arena::new();
+        let cx = MatchCheckCtx::new(
+            self.owner.module(db.upcast()),
+            self.owner,
+            db,
+            &pattern_arena,
+            &ty_arena,
+        );
 
         let mut m_arms = Vec::with_capacity(arms.len());
         let mut has_lowering_errors = false;
@@ -178,9 +185,10 @@ impl ExprValidator {
                     // If we had a NotUsefulMatchArm diagnostic, we could
                     // check the usefulness of each pattern as we added it
                     // to the matrix here.
-                    let m_arm = match_check::MatchArm {
+                    let m_arm = pat_analysis::MatchArm {
                         pat: self.lower_pattern(&cx, arm.pat, db, &body, &mut has_lowering_errors),
                         has_guard: arm.guard.is_some(),
+                        arm_data: (),
                     };
                     m_arms.push(m_arm);
                     if !has_lowering_errors {
@@ -197,7 +205,15 @@ impl ExprValidator {
             return;
         }
 
-        let report = compute_match_usefulness(&cx, &m_arms, scrut_ty);
+        let report = match compute_match_usefulness(
+            rustc_pattern_analysis::MatchCtxt { tycx: &cx },
+            m_arms.as_slice(),
+            scrut_ty.clone(),
+            ValidityConstraint::ValidOnly,
+        ) {
+            Ok(report) => report,
+            Err(void) => match void {},
+        };
 
         // FIXME Report unreachable arms
         // https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/check_match.rs#L200
@@ -213,7 +229,7 @@ impl ExprValidator {
 
     fn lower_pattern<'p>(
         &self,
-        cx: &MatchCheckCtx<'_, 'p>,
+        cx: &MatchCheckCtx<'p>,
         pat: PatId,
         db: &dyn HirDatabase,
         body: &Body,
@@ -221,7 +237,7 @@ impl ExprValidator {
     ) -> &'p DeconstructedPat<'p> {
         let mut patcx = match_check::PatCtxt::new(db, &self.infer, body);
         let pattern = patcx.lower_pattern(pat);
-        let pattern = cx.pattern_arena.alloc(DeconstructedPat::from_pat(cx, &pattern));
+        let pattern = cx.pattern_arena.alloc(cx.lower_pat(&pattern));
         if !patcx.errors.is_empty() {
             *have_errors = true;
         }
@@ -364,16 +380,16 @@ fn types_of_subpatterns_do_match(pat: PatId, body: &Body, infer: &InferenceResul
 }
 
 fn missing_match_arms<'p>(
-    cx: &MatchCheckCtx<'_, 'p>,
+    cx: &MatchCheckCtx<'p>,
     scrut_ty: &Ty,
-    witnesses: Vec<DeconstructedPat<'p>>,
+    witnesses: Vec<WitnessPat<'p>>,
     arms: &[MatchArm],
 ) -> String {
-    struct DisplayWitness<'a, 'p>(&'a DeconstructedPat<'p>, &'a MatchCheckCtx<'a, 'p>);
+    struct DisplayWitness<'a, 'p>(&'a WitnessPat<'p>, &'a MatchCheckCtx<'p>);
     impl fmt::Display for DisplayWitness<'_, '_> {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             let DisplayWitness(witness, cx) = *self;
-            let pat = witness.to_pat(cx);
+            let pat = cx.hoist_witness_pat(witness);
             write!(f, "{}", pat.display(cx.db))
         }
     }
diff --git a/crates/hir-ty/src/diagnostics/match_check.rs b/crates/hir-ty/src/diagnostics/match_check.rs
index 9e84cd0184c..8d6e502c6ab 100644
--- a/crates/hir-ty/src/diagnostics/match_check.rs
+++ b/crates/hir-ty/src/diagnostics/match_check.rs
@@ -7,8 +7,7 @@
 
 mod pat_util;
 
-pub(crate) mod deconstruct_pat;
-pub(crate) mod usefulness;
+pub(crate) mod pat_analysis;
 
 use chalk_ir::Mutability;
 use hir_def::{
@@ -27,8 +26,6 @@ use crate::{
 
 use self::pat_util::EnumerateAndAdjustIterator;
 
-pub(crate) use self::usefulness::MatchArm;
-
 #[derive(Clone, Debug)]
 pub(crate) enum PatternError {
     Unimplemented,
diff --git a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs b/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
deleted file mode 100644
index f066f8b798d..00000000000
--- a/crates/hir-ty/src/diagnostics/match_check/deconstruct_pat.rs
+++ /dev/null
@@ -1,1098 +0,0 @@
-//! [`super::usefulness`] explains most of what is happening in this file. As explained there,
-//! values and patterns are made from constructors applied to fields. This file defines a
-//! `Constructor` enum, a `Fields` struct, and various operations to manipulate them and convert
-//! them from/to patterns.
-//!
-//! There's one idea that is not detailed in [`super::usefulness`] because the details are not
-//! needed there: _constructor splitting_.
-//!
-//! # Constructor splitting
-//!
-//! The idea is as follows: given a constructor `c` and a matrix, we want to specialize in turn
-//! with all the value constructors that are covered by `c`, and compute usefulness for each.
-//! Instead of listing all those constructors (which is intractable), we group those value
-//! constructors together as much as possible. Example:
-//!
-//! ```
-//! match (0, false) {
-//!     (0 ..=100, true) => {} // `p_1`
-//!     (50..=150, false) => {} // `p_2`
-//!     (0 ..=200, _) => {} // `q`
-//! }
-//! ```
-//!
-//! The naive approach would try all numbers in the range `0..=200`. But we can be a lot more
-//! clever: `0` and `1` for example will match the exact same rows, and return equivalent
-//! witnesses. In fact all of `0..50` would. We can thus restrict our exploration to 4
-//! constructors: `0..50`, `50..=100`, `101..=150` and `151..=200`. That is enough and infinitely
-//! more tractable.
-//!
-//! We capture this idea in a function `split(p_1 ... p_n, c)` which returns a list of constructors
-//! `c'` covered by `c`. Given such a `c'`, we require that all value ctors `c''` covered by `c'`
-//! return an equivalent set of witnesses after specializing and computing usefulness.
-//! In the example above, witnesses for specializing by `c''` covered by `0..50` will only differ
-//! in their first element.
-//!
-//! We usually also ask that the `c'` together cover all of the original `c`. However we allow
-//! skipping some constructors as long as it doesn't change whether the resulting list of witnesses
-//! is empty of not. We use this in the wildcard `_` case.
-//!
-//! Splitting is implemented in the [`Constructor::split`] function. We don't do splitting for
-//! or-patterns; instead we just try the alternatives one-by-one. For details on splitting
-//! wildcards, see [`SplitWildcard`]; for integer ranges, see [`SplitIntRange`].
-
-use std::{
-    cell::Cell,
-    cmp::{max, min},
-    iter::once,
-    ops::RangeInclusive,
-};
-
-use hir_def::{EnumVariantId, HasModule, LocalFieldId, VariantId};
-use smallvec::{smallvec, SmallVec};
-use stdx::never;
-
-use crate::{
-    infer::normalize, inhabitedness::is_enum_variant_uninhabited_from, AdtId, Interner, Scalar, Ty,
-    TyExt, TyKind,
-};
-
-use super::{
-    is_box,
-    usefulness::{helper::Captures, MatchCheckCtx, PatCtxt},
-    FieldPat, Pat, PatKind,
-};
-
-use self::Constructor::*;
-
-/// Recursively expand this pattern into its subpatterns. Only useful for or-patterns.
-fn expand_or_pat(pat: &Pat) -> Vec<&Pat> {
-    fn expand<'p>(pat: &'p Pat, vec: &mut Vec<&'p Pat>) {
-        if let PatKind::Or { pats } = pat.kind.as_ref() {
-            for pat in pats {
-                expand(pat, vec);
-            }
-        } else {
-            vec.push(pat)
-        }
-    }
-
-    let mut pats = Vec::new();
-    expand(pat, &mut pats);
-    pats
-}
-
-/// [Constructor] uses this in unimplemented variants.
-/// It allows porting match expressions from upstream algorithm without losing semantics.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub(super) enum Void {}
-
-/// An inclusive interval, used for precise integer exhaustiveness checking.
-/// `IntRange`s always store a contiguous range. This means that values are
-/// encoded such that `0` encodes the minimum value for the integer,
-/// regardless of the signedness.
-/// For example, the pattern `-128..=127i8` is encoded as `0..=255`.
-/// This makes comparisons and arithmetic on interval endpoints much more
-/// straightforward. See `signed_bias` for details.
-///
-/// `IntRange` is never used to encode an empty range or a "range" that wraps
-/// around the (offset) space: i.e., `range.lo <= range.hi`.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(super) struct IntRange {
-    range: RangeInclusive<u128>,
-}
-
-impl IntRange {
-    #[inline]
-    fn is_integral(ty: &Ty) -> bool {
-        matches!(
-            ty.kind(Interner),
-            TyKind::Scalar(Scalar::Char | Scalar::Int(_) | Scalar::Uint(_) | Scalar::Bool)
-        )
-    }
-
-    fn is_singleton(&self) -> bool {
-        self.range.start() == self.range.end()
-    }
-
-    fn boundaries(&self) -> (u128, u128) {
-        (*self.range.start(), *self.range.end())
-    }
-
-    #[inline]
-    fn from_bool(value: bool) -> IntRange {
-        let val = value as u128;
-        IntRange { range: val..=val }
-    }
-
-    #[inline]
-    fn from_range(lo: u128, hi: u128, scalar_ty: Scalar) -> IntRange {
-        match scalar_ty {
-            Scalar::Bool => IntRange { range: lo..=hi },
-            _ => unimplemented!(),
-        }
-    }
-
-    fn is_subrange(&self, other: &Self) -> bool {
-        other.range.start() <= self.range.start() && self.range.end() <= other.range.end()
-    }
-
-    fn intersection(&self, other: &Self) -> Option<Self> {
-        let (lo, hi) = self.boundaries();
-        let (other_lo, other_hi) = other.boundaries();
-        if lo <= other_hi && other_lo <= hi {
-            Some(IntRange { range: max(lo, other_lo)..=min(hi, other_hi) })
-        } else {
-            None
-        }
-    }
-
-    fn to_pat(&self, _cx: &MatchCheckCtx<'_, '_>, ty: Ty) -> Pat {
-        match ty.kind(Interner) {
-            TyKind::Scalar(Scalar::Bool) => {
-                let kind = match self.boundaries() {
-                    (0, 0) => PatKind::LiteralBool { value: false },
-                    (1, 1) => PatKind::LiteralBool { value: true },
-                    (0, 1) => PatKind::Wild,
-                    (lo, hi) => {
-                        never!("bad range for bool pattern: {}..={}", lo, hi);
-                        PatKind::Wild
-                    }
-                };
-                Pat { ty, kind: kind.into() }
-            }
-            _ => unimplemented!(),
-        }
-    }
-
-    /// See `Constructor::is_covered_by`
-    fn is_covered_by(&self, other: &Self) -> bool {
-        if self.intersection(other).is_some() {
-            // Constructor splitting should ensure that all intersections we encounter are actually
-            // inclusions.
-            assert!(self.is_subrange(other));
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// Represents a border between 2 integers. Because the intervals spanning borders must be able to
-/// cover every integer, we need to be able to represent 2^128 + 1 such borders.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-enum IntBorder {
-    JustBefore(u128),
-    AfterMax,
-}
-
-/// A range of integers that is partitioned into disjoint subranges. This does constructor
-/// splitting for integer ranges as explained at the top of the file.
-///
-/// This is fed multiple ranges, and returns an output that covers the input, but is split so that
-/// the only intersections between an output range and a seen range are inclusions. No output range
-/// straddles the boundary of one of the inputs.
-///
-/// The following input:
-/// ```
-///   |-------------------------| // `self`
-/// |------|  |----------|   |----|
-///    |-------| |-------|
-/// ```
-/// would be iterated over as follows:
-/// ```
-///   ||---|--||-|---|---|---|--|
-/// ```
-#[derive(Debug, Clone)]
-struct SplitIntRange {
-    /// The range we are splitting
-    range: IntRange,
-    /// The borders of ranges we have seen. They are all contained within `range`. This is kept
-    /// sorted.
-    borders: Vec<IntBorder>,
-}
-
-impl SplitIntRange {
-    fn new(range: IntRange) -> Self {
-        SplitIntRange { range, borders: Vec::new() }
-    }
-
-    /// Internal use
-    fn to_borders(r: IntRange) -> [IntBorder; 2] {
-        use IntBorder::*;
-        let (lo, hi) = r.boundaries();
-        let lo = JustBefore(lo);
-        let hi = match hi.checked_add(1) {
-            Some(m) => JustBefore(m),
-            None => AfterMax,
-        };
-        [lo, hi]
-    }
-
-    /// Add ranges relative to which we split.
-    fn split(&mut self, ranges: impl Iterator<Item = IntRange>) {
-        let this_range = &self.range;
-        let included_ranges = ranges.filter_map(|r| this_range.intersection(&r));
-        let included_borders = included_ranges.flat_map(|r| {
-            let borders = Self::to_borders(r);
-            once(borders[0]).chain(once(borders[1]))
-        });
-        self.borders.extend(included_borders);
-        self.borders.sort_unstable();
-    }
-
-    /// Iterate over the contained ranges.
-    fn iter(&self) -> impl Iterator<Item = IntRange> + '_ {
-        use IntBorder::*;
-
-        let self_range = Self::to_borders(self.range.clone());
-        // Start with the start of the range.
-        let mut prev_border = self_range[0];
-        self.borders
-            .iter()
-            .copied()
-            // End with the end of the range.
-            .chain(once(self_range[1]))
-            // List pairs of adjacent borders.
-            .map(move |border| {
-                let ret = (prev_border, border);
-                prev_border = border;
-                ret
-            })
-            // Skip duplicates.
-            .filter(|(prev_border, border)| prev_border != border)
-            // Finally, convert to ranges.
-            .map(|(prev_border, border)| {
-                let range = match (prev_border, border) {
-                    (JustBefore(n), JustBefore(m)) if n < m => n..=(m - 1),
-                    (JustBefore(n), AfterMax) => n..=u128::MAX,
-                    _ => unreachable!(), // Ruled out by the sorting and filtering we did
-                };
-                IntRange { range }
-            })
-    }
-}
-
-/// A constructor for array and slice patterns.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub(super) struct Slice {
-    _unimplemented: Void,
-}
-
-impl Slice {
-    fn arity(self) -> usize {
-        match self._unimplemented {}
-    }
-
-    /// See `Constructor::is_covered_by`
-    fn is_covered_by(self, _other: Self) -> bool {
-        match self._unimplemented {}
-    }
-}
-
-/// A value can be decomposed into a constructor applied to some fields. This struct represents
-/// the constructor. See also `Fields`.
-///
-/// `pat_constructor` retrieves the constructor corresponding to a pattern.
-/// `specialize_constructor` returns the list of fields corresponding to a pattern, given a
-/// constructor. `Constructor::apply` reconstructs the pattern from a pair of `Constructor` and
-/// `Fields`.
-#[allow(dead_code)]
-#[derive(Clone, Debug, PartialEq)]
-pub(super) enum Constructor {
-    /// The constructor for patterns that have a single constructor, like tuples, struct patterns
-    /// and fixed-length arrays.
-    Single,
-    /// Enum variants.
-    Variant(EnumVariantId),
-    /// Ranges of integer literal values (`2`, `2..=5` or `2..5`).
-    IntRange(IntRange),
-    /// Ranges of floating-point literal values (`2.0..=5.2`).
-    FloatRange(Void),
-    /// String literals. Strings are not quite the same as `&[u8]` so we treat them separately.
-    Str(Void),
-    /// Array and slice patterns.
-    Slice(Slice),
-    /// Constants that must not be matched structurally. They are treated as black
-    /// boxes for the purposes of exhaustiveness: we must not inspect them, and they
-    /// don't count towards making a match exhaustive.
-    Opaque,
-    /// Fake extra constructor for enums that aren't allowed to be matched exhaustively. Also used
-    /// for those types for which we cannot list constructors explicitly, like `f64` and `str`.
-    NonExhaustive,
-    /// Stands for constructors that are not seen in the matrix, as explained in the documentation
-    /// for [`SplitWildcard`]. The carried `bool` is used for the `non_exhaustive_omitted_patterns`
-    /// lint.
-    Missing { nonexhaustive_enum_missing_real_variants: bool },
-    /// Wildcard pattern.
-    Wildcard,
-    /// Or-pattern.
-    Or,
-}
-
-impl Constructor {
-    pub(super) fn is_wildcard(&self) -> bool {
-        matches!(self, Wildcard)
-    }
-
-    pub(super) fn is_non_exhaustive(&self) -> bool {
-        matches!(self, NonExhaustive)
-    }
-
-    fn as_int_range(&self) -> Option<&IntRange> {
-        match self {
-            IntRange(range) => Some(range),
-            _ => None,
-        }
-    }
-
-    fn as_slice(&self) -> Option<Slice> {
-        match self {
-            Slice(slice) => Some(*slice),
-            _ => None,
-        }
-    }
-
-    pub(super) fn is_unstable_variant(&self, _pcx: PatCtxt<'_, '_>) -> bool {
-        false //FIXME: implement this
-    }
-
-    pub(super) fn is_doc_hidden_variant(&self, _pcx: PatCtxt<'_, '_>) -> bool {
-        false //FIXME: implement this
-    }
-
-    fn variant_id_for_adt(&self, adt: hir_def::AdtId) -> VariantId {
-        match *self {
-            Variant(id) => id.into(),
-            Single => {
-                assert!(!matches!(adt, hir_def::AdtId::EnumId(_)));
-                match adt {
-                    hir_def::AdtId::EnumId(_) => unreachable!(),
-                    hir_def::AdtId::StructId(id) => id.into(),
-                    hir_def::AdtId::UnionId(id) => id.into(),
-                }
-            }
-            _ => panic!("bad constructor {self:?} for adt {adt:?}"),
-        }
-    }
-
-    /// The number of fields for this constructor. This must be kept in sync with
-    /// `Fields::wildcards`.
-    pub(super) fn arity(&self, pcx: PatCtxt<'_, '_>) -> usize {
-        match self {
-            Single | Variant(_) => match *pcx.ty.kind(Interner) {
-                TyKind::Tuple(arity, ..) => arity,
-                TyKind::Ref(..) => 1,
-                TyKind::Adt(adt, ..) => {
-                    if is_box(pcx.cx.db, adt.0) {
-                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
-                        // patterns. If we're here we can assume this is a box pattern.
-                        1
-                    } else {
-                        let variant = self.variant_id_for_adt(adt.0);
-                        Fields::list_variant_nonhidden_fields(pcx.cx, pcx.ty, variant).count()
-                    }
-                }
-                _ => {
-                    never!("Unexpected type for `Single` constructor: {:?}", pcx.ty);
-                    0
-                }
-            },
-            Slice(slice) => slice.arity(),
-            Str(..)
-            | FloatRange(..)
-            | IntRange(..)
-            | NonExhaustive
-            | Opaque
-            | Missing { .. }
-            | Wildcard => 0,
-            Or => {
-                never!("The `Or` constructor doesn't have a fixed arity");
-                0
-            }
-        }
-    }
-
-    /// Some constructors (namely `Wildcard`, `IntRange` and `Slice`) actually stand for a set of actual
-    /// constructors (like variants, integers or fixed-sized slices). When specializing for these
-    /// constructors, we want to be specialising for the actual underlying constructors.
-    /// Naively, we would simply return the list of constructors they correspond to. We instead are
-    /// more clever: if there are constructors that we know will behave the same wrt the current
-    /// matrix, we keep them grouped. For example, all slices of a sufficiently large length
-    /// will either be all useful or all non-useful with a given matrix.
-    ///
-    /// See the branches for details on how the splitting is done.
-    ///
-    /// This function may discard some irrelevant constructors if this preserves behavior and
-    /// diagnostics. Eg. for the `_` case, we ignore the constructors already present in the
-    /// matrix, unless all of them are.
-    pub(super) fn split<'a>(
-        &self,
-        pcx: PatCtxt<'_, '_>,
-        ctors: impl Iterator<Item = &'a Constructor> + Clone,
-    ) -> SmallVec<[Self; 1]> {
-        match self {
-            Wildcard => {
-                let mut split_wildcard = SplitWildcard::new(pcx);
-                split_wildcard.split(pcx, ctors);
-                split_wildcard.into_ctors(pcx)
-            }
-            // Fast-track if the range is trivial. In particular, we don't do the overlapping
-            // ranges check.
-            IntRange(ctor_range) if !ctor_range.is_singleton() => {
-                let mut split_range = SplitIntRange::new(ctor_range.clone());
-                let int_ranges = ctors.filter_map(|ctor| ctor.as_int_range());
-                split_range.split(int_ranges.cloned());
-                split_range.iter().map(IntRange).collect()
-            }
-            Slice(slice) => match slice._unimplemented {},
-            // Any other constructor can be used unchanged.
-            _ => smallvec![self.clone()],
-        }
-    }
-
-    /// Returns whether `self` is covered by `other`, i.e. whether `self` is a subset of `other`.
-    /// For the simple cases, this is simply checking for equality. For the "grouped" constructors,
-    /// this checks for inclusion.
-    // We inline because this has a single call site in `Matrix::specialize_constructor`.
-    #[inline]
-    pub(super) fn is_covered_by(&self, _pcx: PatCtxt<'_, '_>, other: &Self) -> bool {
-        // This must be kept in sync with `is_covered_by_any`.
-        match (self, other) {
-            // Wildcards cover anything
-            (_, Wildcard) => true,
-            // The missing ctors are not covered by anything in the matrix except wildcards.
-            (Missing { .. } | Wildcard, _) => false,
-
-            (Single, Single) => true,
-            (Variant(self_id), Variant(other_id)) => self_id == other_id,
-
-            (IntRange(self_range), IntRange(other_range)) => self_range.is_covered_by(other_range),
-            (FloatRange(void), FloatRange(..)) => match *void {},
-            (Str(void), Str(..)) => match *void {},
-            (Slice(self_slice), Slice(other_slice)) => self_slice.is_covered_by(*other_slice),
-
-            // We are trying to inspect an opaque constant. Thus we skip the row.
-            (Opaque, _) | (_, Opaque) => false,
-            // Only a wildcard pattern can match the special extra constructor.
-            (NonExhaustive, _) => false,
-
-            _ => {
-                never!("trying to compare incompatible constructors {:?} and {:?}", self, other);
-                // Continue with 'whatever is covered' supposed to result in false no-error diagnostic.
-                true
-            }
-        }
-    }
-
-    /// Faster version of `is_covered_by` when applied to many constructors. `used_ctors` is
-    /// assumed to be built from `matrix.head_ctors()` with wildcards filtered out, and `self` is
-    /// assumed to have been split from a wildcard.
-    fn is_covered_by_any(&self, _pcx: PatCtxt<'_, '_>, used_ctors: &[Constructor]) -> bool {
-        if used_ctors.is_empty() {
-            return false;
-        }
-
-        // This must be kept in sync with `is_covered_by`.
-        match self {
-            // If `self` is `Single`, `used_ctors` cannot contain anything else than `Single`s.
-            Single => !used_ctors.is_empty(),
-            Variant(_) => used_ctors.iter().any(|c| c == self),
-            IntRange(range) => used_ctors
-                .iter()
-                .filter_map(|c| c.as_int_range())
-                .any(|other| range.is_covered_by(other)),
-            Slice(slice) => used_ctors
-                .iter()
-                .filter_map(|c| c.as_slice())
-                .any(|other| slice.is_covered_by(other)),
-            // This constructor is never covered by anything else
-            NonExhaustive => false,
-            Str(..) | FloatRange(..) | Opaque | Missing { .. } | Wildcard | Or => {
-                never!("found unexpected ctor in all_ctors: {:?}", self);
-                true
-            }
-        }
-    }
-}
-
-/// A wildcard constructor that we split relative to the constructors in the matrix, as explained
-/// at the top of the file.
-///
-/// A constructor that is not present in the matrix rows will only be covered by the rows that have
-/// wildcards. Thus we can group all of those constructors together; we call them "missing
-/// constructors". Splitting a wildcard would therefore list all present constructors individually
-/// (or grouped if they are integers or slices), and then all missing constructors together as a
-/// group.
-///
-/// However we can go further: since any constructor will match the wildcard rows, and having more
-/// rows can only reduce the amount of usefulness witnesses, we can skip the present constructors
-/// and only try the missing ones.
-/// This will not preserve the whole list of witnesses, but will preserve whether the list is empty
-/// or not. In fact this is quite natural from the point of view of diagnostics too. This is done
-/// in `to_ctors`: in some cases we only return `Missing`.
-#[derive(Debug)]
-pub(super) struct SplitWildcard {
-    /// Constructors seen in the matrix.
-    matrix_ctors: Vec<Constructor>,
-    /// All the constructors for this type
-    all_ctors: SmallVec<[Constructor; 1]>,
-}
-
-impl SplitWildcard {
-    pub(super) fn new(pcx: PatCtxt<'_, '_>) -> Self {
-        let cx = pcx.cx;
-        let make_range = |start, end, scalar| IntRange(IntRange::from_range(start, end, scalar));
-
-        // Unhandled types are treated as non-exhaustive. Being explicit here instead of falling
-        // to catchall arm to ease further implementation.
-        let unhandled = || smallvec![NonExhaustive];
-
-        // This determines the set of all possible constructors for the type `pcx.ty`. For numbers,
-        // arrays and slices we use ranges and variable-length slices when appropriate.
-        //
-        // If the `exhaustive_patterns` feature is enabled, we make sure to omit constructors that
-        // are statically impossible. E.g., for `Option<!>`, we do not include `Some(_)` in the
-        // returned list of constructors.
-        // Invariant: this is empty if and only if the type is uninhabited (as determined by
-        // `cx.is_uninhabited()`).
-        let all_ctors = match pcx.ty.kind(Interner) {
-            TyKind::Scalar(Scalar::Bool) => smallvec![make_range(0, 1, Scalar::Bool)],
-            // TyKind::Array(..) if ... => unhandled(),
-            TyKind::Array(..) | TyKind::Slice(..) => unhandled(),
-            TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), subst) => {
-                let enum_data = cx.db.enum_data(*enum_id);
-
-                // If the enum is declared as `#[non_exhaustive]`, we treat it as if it had an
-                // additional "unknown" constructor.
-                // There is no point in enumerating all possible variants, because the user can't
-                // actually match against them all themselves. So we always return only the fictitious
-                // constructor.
-                // E.g., in an example like:
-                //
-                // ```
-                //     let err: io::ErrorKind = ...;
-                //     match err {
-                //         io::ErrorKind::NotFound => {},
-                //     }
-                // ```
-                //
-                // we don't want to show every possible IO error, but instead have only `_` as the
-                // witness.
-                let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(pcx.ty);
-
-                let is_exhaustive_pat_feature = cx.feature_exhaustive_patterns();
-
-                // If `exhaustive_patterns` is disabled and our scrutinee is an empty enum, we treat it
-                // as though it had an "unknown" constructor to avoid exposing its emptiness. The
-                // exception is if the pattern is at the top level, because we want empty matches to be
-                // considered exhaustive.
-                let is_secretly_empty = enum_data.variants.is_empty()
-                    && !is_exhaustive_pat_feature
-                    && !pcx.is_top_level;
-
-                let mut ctors: SmallVec<[_; 1]> = enum_data
-                    .variants
-                    .iter()
-                    .map(|&(variant, _)| variant)
-                    .filter(|&variant| {
-                        // If `exhaustive_patterns` is enabled, we exclude variants known to be
-                        // uninhabited.
-                        let is_uninhabited = is_exhaustive_pat_feature
-                            && is_enum_variant_uninhabited_from(variant, subst, cx.module, cx.db);
-                        !is_uninhabited
-                    })
-                    .map(Variant)
-                    .collect();
-
-                if is_secretly_empty || is_declared_nonexhaustive {
-                    ctors.push(NonExhaustive);
-                }
-                ctors
-            }
-            TyKind::Scalar(Scalar::Char) => unhandled(),
-            TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(),
-            TyKind::Never if !cx.feature_exhaustive_patterns() && !pcx.is_top_level => {
-                smallvec![NonExhaustive]
-            }
-            TyKind::Never => SmallVec::new(),
-            _ if cx.is_uninhabited(pcx.ty) => SmallVec::new(),
-            TyKind::Adt(..) | TyKind::Tuple(..) | TyKind::Ref(..) => smallvec![Single],
-            // This type is one for which we cannot list constructors, like `str` or `f64`.
-            _ => smallvec![NonExhaustive],
-        };
-
-        SplitWildcard { matrix_ctors: Vec::new(), all_ctors }
-    }
-
-    /// Pass a set of constructors relative to which to split this one. Don't call twice, it won't
-    /// do what you want.
-    pub(super) fn split<'a>(
-        &mut self,
-        pcx: PatCtxt<'_, '_>,
-        ctors: impl Iterator<Item = &'a Constructor> + Clone,
-    ) {
-        // Since `all_ctors` never contains wildcards, this won't recurse further.
-        self.all_ctors =
-            self.all_ctors.iter().flat_map(|ctor| ctor.split(pcx, ctors.clone())).collect();
-        self.matrix_ctors = ctors.filter(|c| !c.is_wildcard()).cloned().collect();
-    }
-
-    /// Whether there are any value constructors for this type that are not present in the matrix.
-    fn any_missing(&self, pcx: PatCtxt<'_, '_>) -> bool {
-        self.iter_missing(pcx).next().is_some()
-    }
-
-    /// Iterate over the constructors for this type that are not present in the matrix.
-    pub(super) fn iter_missing<'a, 'p>(
-        &'a self,
-        pcx: PatCtxt<'a, 'p>,
-    ) -> impl Iterator<Item = &'a Constructor> + Captures<'p> {
-        self.all_ctors.iter().filter(move |ctor| !ctor.is_covered_by_any(pcx, &self.matrix_ctors))
-    }
-
-    /// Return the set of constructors resulting from splitting the wildcard. As explained at the
-    /// top of the file, if any constructors are missing we can ignore the present ones.
-    fn into_ctors(self, pcx: PatCtxt<'_, '_>) -> SmallVec<[Constructor; 1]> {
-        if self.any_missing(pcx) {
-            // Some constructors are missing, thus we can specialize with the special `Missing`
-            // constructor, which stands for those constructors that are not seen in the matrix,
-            // and matches the same rows as any of them (namely the wildcard rows). See the top of
-            // the file for details.
-            // However, when all constructors are missing we can also specialize with the full
-            // `Wildcard` constructor. The difference will depend on what we want in diagnostics.
-
-            // If some constructors are missing, we typically want to report those constructors,
-            // e.g.:
-            // ```
-            //     enum Direction { N, S, E, W }
-            //     let Direction::N = ...;
-            // ```
-            // we can report 3 witnesses: `S`, `E`, and `W`.
-            //
-            // However, if the user didn't actually specify a constructor
-            // in this arm, e.g., in
-            // ```
-            //     let x: (Direction, Direction, bool) = ...;
-            //     let (_, _, false) = x;
-            // ```
-            // we don't want to show all 16 possible witnesses `(<direction-1>, <direction-2>,
-            // true)` - we are satisfied with `(_, _, true)`. So if all constructors are missing we
-            // prefer to report just a wildcard `_`.
-            //
-            // The exception is: if we are at the top-level, for example in an empty match, we
-            // sometimes prefer reporting the list of constructors instead of just `_`.
-            let report_when_all_missing = pcx.is_top_level && !IntRange::is_integral(pcx.ty);
-            let ctor = if !self.matrix_ctors.is_empty() || report_when_all_missing {
-                if pcx.is_non_exhaustive {
-                    Missing {
-                        nonexhaustive_enum_missing_real_variants: self
-                            .iter_missing(pcx)
-                            .any(|c| !(c.is_non_exhaustive() || c.is_unstable_variant(pcx))),
-                    }
-                } else {
-                    Missing { nonexhaustive_enum_missing_real_variants: false }
-                }
-            } else {
-                Wildcard
-            };
-            return smallvec![ctor];
-        }
-
-        // All the constructors are present in the matrix, so we just go through them all.
-        self.all_ctors
-    }
-}
-
-/// A value can be decomposed into a constructor applied to some fields. This struct represents
-/// those fields, generalized to allow patterns in each field. See also `Constructor`.
-///
-/// This is constructed for a constructor using [`Fields::wildcards()`]. The idea is that
-/// [`Fields::wildcards()`] constructs a list of fields where all entries are wildcards, and then
-/// given a pattern we fill some of the fields with its subpatterns.
-/// In the following example `Fields::wildcards` returns `[_, _, _, _]`. Then in
-/// `extract_pattern_arguments` we fill some of the entries, and the result is
-/// `[Some(0), _, _, _]`.
-/// ```rust
-/// let x: [Option<u8>; 4] = foo();
-/// match x {
-///     [Some(0), ..] => {}
-/// }
-/// ```
-///
-/// Note that the number of fields of a constructor may not match the fields declared in the
-/// original struct/variant. This happens if a private or `non_exhaustive` field is uninhabited,
-/// because the code mustn't observe that it is uninhabited. In that case that field is not
-/// included in `fields`. For that reason, when you have a `mir::Field` you must use
-/// `index_with_declared_idx`.
-#[derive(Clone, Copy)]
-pub(super) struct Fields<'p> {
-    fields: &'p [DeconstructedPat<'p>],
-}
-
-impl<'p> Fields<'p> {
-    fn empty() -> Self {
-        Fields { fields: &[] }
-    }
-
-    fn singleton(cx: &MatchCheckCtx<'_, 'p>, field: DeconstructedPat<'p>) -> Self {
-        let field = cx.pattern_arena.alloc(field);
-        Fields { fields: std::slice::from_ref(field) }
-    }
-
-    pub(super) fn from_iter(
-        cx: &MatchCheckCtx<'_, 'p>,
-        fields: impl IntoIterator<Item = DeconstructedPat<'p>>,
-    ) -> Self {
-        let fields: &[_] = cx.pattern_arena.alloc_extend(fields);
-        Fields { fields }
-    }
-
-    fn wildcards_from_tys(cx: &MatchCheckCtx<'_, 'p>, tys: impl IntoIterator<Item = Ty>) -> Self {
-        Fields::from_iter(cx, tys.into_iter().map(DeconstructedPat::wildcard))
-    }
-
-    // In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide
-    // uninhabited fields in order not to reveal the uninhabitedness of the whole variant.
-    // This lists the fields we keep along with their types.
-    fn list_variant_nonhidden_fields<'a>(
-        cx: &'a MatchCheckCtx<'a, 'p>,
-        ty: &'a Ty,
-        variant: VariantId,
-    ) -> impl Iterator<Item = (LocalFieldId, Ty)> + Captures<'a> + Captures<'p> {
-        let (adt, substs) = ty.as_adt().unwrap();
-
-        let adt_is_local = variant.module(cx.db.upcast()).krate() == cx.module.krate();
-        // Whether we must not match the fields of this variant exhaustively.
-        let is_non_exhaustive = is_field_list_non_exhaustive(variant, cx) && !adt_is_local;
-
-        let visibility = cx.db.field_visibilities(variant);
-        let field_ty = cx.db.field_types(variant);
-        let fields_len = variant.variant_data(cx.db.upcast()).fields().len() as u32;
-
-        (0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).filter_map(move |fid| {
-            let ty = field_ty[fid].clone().substitute(Interner, substs);
-            let ty = normalize(cx.db, cx.db.trait_environment_for_body(cx.body), ty);
-            let is_visible = matches!(adt, hir_def::AdtId::EnumId(..))
-                || visibility[fid].is_visible_from(cx.db.upcast(), cx.module);
-            let is_uninhabited = cx.is_uninhabited(&ty);
-
-            if is_uninhabited && (!is_visible || is_non_exhaustive) {
-                None
-            } else {
-                Some((fid, ty))
-            }
-        })
-    }
-
-    /// Creates a new list of wildcard fields for a given constructor. The result must have a
-    /// length of `constructor.arity()`.
-    pub(crate) fn wildcards(
-        cx: &MatchCheckCtx<'_, 'p>,
-        ty: &Ty,
-        constructor: &Constructor,
-    ) -> Self {
-        let ret = match constructor {
-            Single | Variant(_) => match ty.kind(Interner) {
-                TyKind::Tuple(_, substs) => {
-                    let tys = substs.iter(Interner).map(|ty| ty.assert_ty_ref(Interner));
-                    Fields::wildcards_from_tys(cx, tys.cloned())
-                }
-                TyKind::Ref(.., rty) => Fields::wildcards_from_tys(cx, once(rty.clone())),
-                &TyKind::Adt(AdtId(adt), ref substs) => {
-                    if is_box(cx.db, adt) {
-                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
-                        // patterns. If we're here we can assume this is a box pattern.
-                        let subst_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
-                        Fields::wildcards_from_tys(cx, once(subst_ty))
-                    } else {
-                        let variant = constructor.variant_id_for_adt(adt);
-                        let tys = Fields::list_variant_nonhidden_fields(cx, ty, variant)
-                            .map(|(_, ty)| ty);
-                        Fields::wildcards_from_tys(cx, tys)
-                    }
-                }
-                ty_kind => {
-                    never!("Unexpected type for `Single` constructor: {:?}", ty_kind);
-                    Fields::wildcards_from_tys(cx, once(ty.clone()))
-                }
-            },
-            Slice(slice) => match slice._unimplemented {},
-            Str(..)
-            | FloatRange(..)
-            | IntRange(..)
-            | NonExhaustive
-            | Opaque
-            | Missing { .. }
-            | Wildcard => Fields::empty(),
-            Or => {
-                never!("called `Fields::wildcards` on an `Or` ctor");
-                Fields::empty()
-            }
-        };
-        ret
-    }
-
-    /// Returns the list of patterns.
-    pub(super) fn iter_patterns<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + Captures<'a> {
-        self.fields.iter()
-    }
-}
-
-/// Values and patterns can be represented as a constructor applied to some fields. This represents
-/// a pattern in this form.
-/// This also keeps track of whether the pattern has been found reachable during analysis. For this
-/// reason we should be careful not to clone patterns for which we care about that. Use
-/// `clone_and_forget_reachability` if you're sure.
-pub(crate) struct DeconstructedPat<'p> {
-    ctor: Constructor,
-    fields: Fields<'p>,
-    ty: Ty,
-    reachable: Cell<bool>,
-}
-
-impl<'p> DeconstructedPat<'p> {
-    pub(super) fn wildcard(ty: Ty) -> Self {
-        Self::new(Wildcard, Fields::empty(), ty)
-    }
-
-    pub(super) fn new(ctor: Constructor, fields: Fields<'p>, ty: Ty) -> Self {
-        DeconstructedPat { ctor, fields, ty, reachable: Cell::new(false) }
-    }
-
-    /// Construct a pattern that matches everything that starts with this constructor.
-    /// For example, if `ctor` is a `Constructor::Variant` for `Option::Some`, we get the pattern
-    /// `Some(_)`.
-    pub(super) fn wild_from_ctor(pcx: PatCtxt<'_, 'p>, ctor: Constructor) -> Self {
-        let fields = Fields::wildcards(pcx.cx, pcx.ty, &ctor);
-        DeconstructedPat::new(ctor, fields, pcx.ty.clone())
-    }
-
-    /// Clone this value. This method emphasizes that cloning loses reachability information and
-    /// should be done carefully.
-    pub(super) fn clone_and_forget_reachability(&self) -> Self {
-        DeconstructedPat::new(self.ctor.clone(), self.fields, self.ty.clone())
-    }
-
-    pub(crate) fn from_pat(cx: &MatchCheckCtx<'_, 'p>, pat: &Pat) -> Self {
-        let mkpat = |pat| DeconstructedPat::from_pat(cx, pat);
-        let ctor;
-        let fields;
-        match pat.kind.as_ref() {
-            PatKind::Binding { subpattern: Some(subpat), .. } => return mkpat(subpat),
-            PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
-                ctor = Wildcard;
-                fields = Fields::empty();
-            }
-            PatKind::Deref { subpattern } => {
-                ctor = Single;
-                fields = Fields::singleton(cx, mkpat(subpattern));
-            }
-            PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => {
-                match pat.ty.kind(Interner) {
-                    TyKind::Tuple(_, substs) => {
-                        ctor = Single;
-                        let mut wilds: SmallVec<[_; 2]> = substs
-                            .iter(Interner)
-                            .map(|arg| arg.assert_ty_ref(Interner).clone())
-                            .map(DeconstructedPat::wildcard)
-                            .collect();
-                        for pat in subpatterns {
-                            let idx: u32 = pat.field.into_raw().into();
-                            wilds[idx as usize] = mkpat(&pat.pattern);
-                        }
-                        fields = Fields::from_iter(cx, wilds)
-                    }
-                    TyKind::Adt(adt, substs) if is_box(cx.db, adt.0) => {
-                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
-                        // patterns. If we're here we can assume this is a box pattern.
-                        // FIXME(Nadrieril): A `Box` can in theory be matched either with `Box(_,
-                        // _)` or a box pattern. As a hack to avoid an ICE with the former, we
-                        // ignore other fields than the first one. This will trigger an error later
-                        // anyway.
-                        // See https://github.com/rust-lang/rust/issues/82772 ,
-                        // explanation: https://github.com/rust-lang/rust/pull/82789#issuecomment-796921977
-                        // The problem is that we can't know from the type whether we'll match
-                        // normally or through box-patterns. We'll have to figure out a proper
-                        // solution when we introduce generalized deref patterns. Also need to
-                        // prevent mixing of those two options.
-                        let pat =
-                            subpatterns.iter().find(|pat| pat.field.into_raw() == 0u32.into());
-                        let field = if let Some(pat) = pat {
-                            mkpat(&pat.pattern)
-                        } else {
-                            let ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
-                            DeconstructedPat::wildcard(ty)
-                        };
-                        ctor = Single;
-                        fields = Fields::singleton(cx, field)
-                    }
-                    &TyKind::Adt(adt, _) => {
-                        ctor = match pat.kind.as_ref() {
-                            PatKind::Leaf { .. } => Single,
-                            PatKind::Variant { enum_variant, .. } => Variant(*enum_variant),
-                            _ => {
-                                never!();
-                                Wildcard
-                            }
-                        };
-                        let variant = ctor.variant_id_for_adt(adt.0);
-                        let fields_len = variant.variant_data(cx.db.upcast()).fields().len();
-                        // For each field in the variant, we store the relevant index into `self.fields` if any.
-                        let mut field_id_to_id: Vec<Option<usize>> = vec![None; fields_len];
-                        let tys = Fields::list_variant_nonhidden_fields(cx, &pat.ty, variant)
-                            .enumerate()
-                            .map(|(i, (fid, ty))| {
-                                let field_idx: u32 = fid.into_raw().into();
-                                field_id_to_id[field_idx as usize] = Some(i);
-                                ty
-                            });
-                        let mut wilds: SmallVec<[_; 2]> =
-                            tys.map(DeconstructedPat::wildcard).collect();
-                        for pat in subpatterns {
-                            let field_idx: u32 = pat.field.into_raw().into();
-                            if let Some(i) = field_id_to_id[field_idx as usize] {
-                                wilds[i] = mkpat(&pat.pattern);
-                            }
-                        }
-                        fields = Fields::from_iter(cx, wilds);
-                    }
-                    _ => {
-                        never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty);
-                        ctor = Wildcard;
-                        fields = Fields::empty();
-                    }
-                }
-            }
-            &PatKind::LiteralBool { value } => {
-                ctor = IntRange(IntRange::from_bool(value));
-                fields = Fields::empty();
-            }
-            PatKind::Or { .. } => {
-                ctor = Or;
-                let pats: SmallVec<[_; 2]> = expand_or_pat(pat).into_iter().map(mkpat).collect();
-                fields = Fields::from_iter(cx, pats)
-            }
-        }
-        DeconstructedPat::new(ctor, fields, pat.ty.clone())
-    }
-
-    pub(crate) fn to_pat(&self, cx: &MatchCheckCtx<'_, 'p>) -> Pat {
-        let mut subpatterns = self.iter_fields().map(|p| p.to_pat(cx));
-        let pat = match &self.ctor {
-            Single | Variant(_) => match self.ty.kind(Interner) {
-                TyKind::Tuple(..) => PatKind::Leaf {
-                    subpatterns: subpatterns
-                        .zip(0u32..)
-                        .map(|(p, i)| FieldPat {
-                            field: LocalFieldId::from_raw(i.into()),
-                            pattern: p,
-                        })
-                        .collect(),
-                },
-                TyKind::Adt(adt, _) if is_box(cx.db, adt.0) => {
-                    // Without `box_patterns`, the only legal pattern of type `Box` is `_` (outside
-                    // of `std`). So this branch is only reachable when the feature is enabled and
-                    // the pattern is a box pattern.
-                    PatKind::Deref { subpattern: subpatterns.next().unwrap() }
-                }
-                TyKind::Adt(adt, substs) => {
-                    let variant = self.ctor.variant_id_for_adt(adt.0);
-                    let subpatterns = Fields::list_variant_nonhidden_fields(cx, self.ty(), variant)
-                        .zip(subpatterns)
-                        .map(|((field, _ty), pattern)| FieldPat { field, pattern })
-                        .collect();
-
-                    if let VariantId::EnumVariantId(enum_variant) = variant {
-                        PatKind::Variant { substs: substs.clone(), enum_variant, subpatterns }
-                    } else {
-                        PatKind::Leaf { subpatterns }
-                    }
-                }
-                // Note: given the expansion of `&str` patterns done in `expand_pattern`, we should
-                // be careful to reconstruct the correct constant pattern here. However a string
-                // literal pattern will never be reported as a non-exhaustiveness witness, so we
-                // ignore this issue.
-                TyKind::Ref(..) => PatKind::Deref { subpattern: subpatterns.next().unwrap() },
-                _ => {
-                    never!("unexpected ctor for type {:?} {:?}", self.ctor, self.ty);
-                    PatKind::Wild
-                }
-            },
-            &Slice(slice) => match slice._unimplemented {},
-            &Str(void) => match void {},
-            &FloatRange(void) => match void {},
-            IntRange(range) => return range.to_pat(cx, self.ty.clone()),
-            Wildcard | NonExhaustive => PatKind::Wild,
-            Missing { .. } => {
-                never!(
-                    "trying to convert a `Missing` constructor into a `Pat`; this is a bug, \
-                    `Missing` should have been processed in `apply_constructors`"
-                );
-                PatKind::Wild
-            }
-            Opaque | Or => {
-                never!("can't convert to pattern: {:?}", self.ctor);
-                PatKind::Wild
-            }
-        };
-        Pat { ty: self.ty.clone(), kind: Box::new(pat) }
-    }
-
-    pub(super) fn is_or_pat(&self) -> bool {
-        matches!(self.ctor, Or)
-    }
-
-    pub(super) fn ctor(&self) -> &Constructor {
-        &self.ctor
-    }
-
-    pub(super) fn ty(&self) -> &Ty {
-        &self.ty
-    }
-
-    pub(super) fn iter_fields<'a>(&'a self) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + 'a {
-        self.fields.iter_patterns()
-    }
-
-    /// Specialize this pattern with a constructor.
-    /// `other_ctor` can be different from `self.ctor`, but must be covered by it.
-    pub(super) fn specialize<'a>(
-        &'a self,
-        cx: &MatchCheckCtx<'_, 'p>,
-        other_ctor: &Constructor,
-    ) -> SmallVec<[&'p DeconstructedPat<'p>; 2]> {
-        match (&self.ctor, other_ctor) {
-            (Wildcard, _) => {
-                // We return a wildcard for each field of `other_ctor`.
-                Fields::wildcards(cx, &self.ty, other_ctor).iter_patterns().collect()
-            }
-            (Slice(self_slice), Slice(other_slice))
-                if self_slice.arity() != other_slice.arity() =>
-            {
-                match self_slice._unimplemented {}
-            }
-            _ => self.fields.iter_patterns().collect(),
-        }
-    }
-
-    /// We keep track for each pattern if it was ever reachable during the analysis. This is used
-    /// with `unreachable_spans` to report unreachable subpatterns arising from or patterns.
-    pub(super) fn set_reachable(&self) {
-        self.reachable.set(true)
-    }
-    pub(super) fn is_reachable(&self) -> bool {
-        self.reachable.get()
-    }
-}
-
-fn is_field_list_non_exhaustive(variant_id: VariantId, cx: &MatchCheckCtx<'_, '_>) -> bool {
-    let attr_def_id = match variant_id {
-        VariantId::EnumVariantId(id) => id.into(),
-        VariantId::StructId(id) => id.into(),
-        VariantId::UnionId(id) => id.into(),
-    };
-    cx.db.attrs(attr_def_id).by_key("non_exhaustive").exists()
-}
diff --git a/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
new file mode 100644
index 00000000000..cd67ca59931
--- /dev/null
+++ b/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -0,0 +1,475 @@
+//! Interface with `rustc_pattern_analysis`.
+
+use std::fmt;
+
+use hir_def::{DefWithBodyId, EnumVariantId, HasModule, LocalFieldId, ModuleId, VariantId};
+use rustc_hash::FxHashMap;
+use rustc_pattern_analysis::{
+    constructor::{Constructor, ConstructorSet, VariantVisibility},
+    index::IdxContainer,
+    Captures, TypeCx,
+};
+use smallvec::SmallVec;
+use stdx::never;
+use typed_arena::Arena;
+
+use crate::{
+    db::HirDatabase,
+    infer::normalize,
+    inhabitedness::{is_enum_variant_uninhabited_from, is_ty_uninhabited_from},
+    AdtId, Interner, Scalar, Ty, TyExt, TyKind,
+};
+
+use super::{is_box, FieldPat, Pat, PatKind};
+
+use Constructor::*;
+
+// Re-export r-a-specific versions of all these types.
+pub(crate) type DeconstructedPat<'p> =
+    rustc_pattern_analysis::pat::DeconstructedPat<'p, MatchCheckCtx<'p>>;
+pub(crate) type MatchArm<'p> = rustc_pattern_analysis::MatchArm<'p, MatchCheckCtx<'p>>;
+pub(crate) type WitnessPat<'p> = rustc_pattern_analysis::pat::WitnessPat<MatchCheckCtx<'p>>;
+
+/// [Constructor] uses this in unimplemented variants.
+/// It allows porting match expressions from upstream algorithm without losing semantics.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum Void {}
+
+#[derive(Clone)]
+pub(crate) struct MatchCheckCtx<'p> {
+    module: ModuleId,
+    body: DefWithBodyId,
+    pub(crate) db: &'p dyn HirDatabase,
+    pub(crate) pattern_arena: &'p Arena<DeconstructedPat<'p>>,
+    ty_arena: &'p Arena<Ty>,
+    exhaustive_patterns: bool,
+}
+
+impl<'p> MatchCheckCtx<'p> {
+    pub(crate) fn new(
+        module: ModuleId,
+        body: DefWithBodyId,
+        db: &'p dyn HirDatabase,
+        pattern_arena: &'p Arena<DeconstructedPat<'p>>,
+        ty_arena: &'p Arena<Ty>,
+    ) -> Self {
+        let def_map = db.crate_def_map(module.krate());
+        let exhaustive_patterns = def_map.is_unstable_feature_enabled("exhaustive_patterns");
+        Self { module, body, db, pattern_arena, exhaustive_patterns, ty_arena }
+    }
+
+    fn is_uninhabited(&self, ty: &Ty) -> bool {
+        is_ty_uninhabited_from(ty, self.module, self.db)
+    }
+
+    /// Returns whether the given type is an enum from another crate declared `#[non_exhaustive]`.
+    fn is_foreign_non_exhaustive_enum(&self, ty: &Ty) -> bool {
+        match ty.as_adt() {
+            Some((adt @ hir_def::AdtId::EnumId(_), _)) => {
+                let has_non_exhaustive_attr =
+                    self.db.attrs(adt.into()).by_key("non_exhaustive").exists();
+                let is_local = adt.module(self.db.upcast()).krate() == self.module.krate();
+                has_non_exhaustive_attr && !is_local
+            }
+            _ => false,
+        }
+    }
+
+    fn variant_id_for_adt(&self, ctor: &Constructor<Self>, adt: hir_def::AdtId) -> VariantId {
+        match ctor {
+            &Variant(id) => id.into(),
+            Struct | UnionField => {
+                assert!(!matches!(adt, hir_def::AdtId::EnumId(_)));
+                match adt {
+                    hir_def::AdtId::EnumId(_) => unreachable!(),
+                    hir_def::AdtId::StructId(id) => id.into(),
+                    hir_def::AdtId::UnionId(id) => id.into(),
+                }
+            }
+            _ => panic!("bad constructor {self:?} for adt {adt:?}"),
+        }
+    }
+
+    // In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide
+    // uninhabited fields in order not to reveal the uninhabitedness of the whole variant.
+    // This lists the fields we keep along with their types.
+    fn list_variant_nonhidden_fields<'a>(
+        &'a self,
+        ty: &'a Ty,
+        variant: VariantId,
+    ) -> impl Iterator<Item = (LocalFieldId, Ty)> + Captures<'a> + Captures<'p> {
+        let cx = self;
+        let (adt, substs) = ty.as_adt().unwrap();
+
+        let adt_is_local = variant.module(cx.db.upcast()).krate() == cx.module.krate();
+
+        // Whether we must not match the fields of this variant exhaustively.
+        let is_non_exhaustive =
+            cx.db.attrs(variant.into()).by_key("non_exhaustive").exists() && !adt_is_local;
+
+        let visibility = cx.db.field_visibilities(variant);
+        let field_ty = cx.db.field_types(variant);
+        let fields_len = variant.variant_data(cx.db.upcast()).fields().len() as u32;
+
+        (0..fields_len).map(|idx| LocalFieldId::from_raw(idx.into())).filter_map(move |fid| {
+            let ty = field_ty[fid].clone().substitute(Interner, substs);
+            let ty = normalize(cx.db, cx.db.trait_environment_for_body(cx.body), ty);
+            let is_visible = matches!(adt, hir_def::AdtId::EnumId(..))
+                || visibility[fid].is_visible_from(cx.db.upcast(), cx.module);
+            let is_uninhabited = cx.is_uninhabited(&ty);
+
+            if is_uninhabited && (!is_visible || is_non_exhaustive) {
+                None
+            } else {
+                Some((fid, ty))
+            }
+        })
+    }
+
+    pub(crate) fn lower_pat(&self, pat: &Pat) -> DeconstructedPat<'p> {
+        let singleton = |pat| std::slice::from_ref(self.pattern_arena.alloc(pat));
+        let ctor;
+        let fields: &[_];
+
+        match pat.kind.as_ref() {
+            PatKind::Binding { subpattern: Some(subpat), .. } => return self.lower_pat(subpat),
+            PatKind::Binding { subpattern: None, .. } | PatKind::Wild => {
+                ctor = Wildcard;
+                fields = &[];
+            }
+            PatKind::Deref { subpattern } => {
+                ctor = match pat.ty.kind(Interner) {
+                    // This is a box pattern.
+                    TyKind::Adt(adt, _) if is_box(self.db, adt.0) => Struct,
+                    TyKind::Ref(..) => Ref,
+                    _ => {
+                        never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty);
+                        Wildcard
+                    }
+                };
+                fields = singleton(self.lower_pat(subpattern));
+            }
+            PatKind::Leaf { subpatterns } | PatKind::Variant { subpatterns, .. } => {
+                match pat.ty.kind(Interner) {
+                    TyKind::Tuple(_, substs) => {
+                        ctor = Struct;
+                        let mut wilds: SmallVec<[_; 2]> = substs
+                            .iter(Interner)
+                            .map(|arg| arg.assert_ty_ref(Interner).clone())
+                            .map(DeconstructedPat::wildcard)
+                            .collect();
+                        for pat in subpatterns {
+                            let idx: u32 = pat.field.into_raw().into();
+                            wilds[idx as usize] = self.lower_pat(&pat.pattern);
+                        }
+                        fields = self.pattern_arena.alloc_extend(wilds)
+                    }
+                    TyKind::Adt(adt, substs) if is_box(self.db, adt.0) => {
+                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
+                        // patterns. If we're here we can assume this is a box pattern.
+                        // FIXME(Nadrieril): A `Box` can in theory be matched either with `Box(_,
+                        // _)` or a box pattern. As a hack to avoid an ICE with the former, we
+                        // ignore other fields than the first one. This will trigger an error later
+                        // anyway.
+                        // See https://github.com/rust-lang/rust/issues/82772 ,
+                        // explanation: https://github.com/rust-lang/rust/pull/82789#issuecomment-796921977
+                        // The problem is that we can't know from the type whether we'll match
+                        // normally or through box-patterns. We'll have to figure out a proper
+                        // solution when we introduce generalized deref patterns. Also need to
+                        // prevent mixing of those two options.
+                        let pat =
+                            subpatterns.iter().find(|pat| pat.field.into_raw() == 0u32.into());
+                        let field = if let Some(pat) = pat {
+                            self.lower_pat(&pat.pattern)
+                        } else {
+                            let ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
+                            DeconstructedPat::wildcard(ty)
+                        };
+                        ctor = Struct;
+                        fields = singleton(field);
+                    }
+                    &TyKind::Adt(adt, _) => {
+                        ctor = match pat.kind.as_ref() {
+                            PatKind::Leaf { .. } if matches!(adt.0, hir_def::AdtId::UnionId(_)) => {
+                                UnionField
+                            }
+                            PatKind::Leaf { .. } => Struct,
+                            PatKind::Variant { enum_variant, .. } => Variant(*enum_variant),
+                            _ => {
+                                never!();
+                                Wildcard
+                            }
+                        };
+                        let variant = self.variant_id_for_adt(&ctor, adt.0);
+                        let fields_len = variant.variant_data(self.db.upcast()).fields().len();
+                        // For each field in the variant, we store the relevant index into `self.fields` if any.
+                        let mut field_id_to_id: Vec<Option<usize>> = vec![None; fields_len];
+                        let tys = self
+                            .list_variant_nonhidden_fields(&pat.ty, variant)
+                            .enumerate()
+                            .map(|(i, (fid, ty))| {
+                                let field_idx: u32 = fid.into_raw().into();
+                                field_id_to_id[field_idx as usize] = Some(i);
+                                ty
+                            });
+                        let mut wilds: SmallVec<[_; 2]> =
+                            tys.map(DeconstructedPat::wildcard).collect();
+                        for pat in subpatterns {
+                            let field_idx: u32 = pat.field.into_raw().into();
+                            if let Some(i) = field_id_to_id[field_idx as usize] {
+                                wilds[i] = self.lower_pat(&pat.pattern);
+                            }
+                        }
+                        fields = self.pattern_arena.alloc_extend(wilds);
+                    }
+                    _ => {
+                        never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty);
+                        ctor = Wildcard;
+                        fields = &[];
+                    }
+                }
+            }
+            &PatKind::LiteralBool { value } => {
+                ctor = Bool(value);
+                fields = &[];
+            }
+            PatKind::Or { pats } => {
+                ctor = Or;
+                // Collect here because `Arena::alloc_extend` panics on reentrancy.
+                let subpats: SmallVec<[_; 2]> =
+                    pats.into_iter().map(|pat| self.lower_pat(pat)).collect();
+                fields = self.pattern_arena.alloc_extend(subpats);
+            }
+        }
+        DeconstructedPat::new(ctor, fields, pat.ty.clone(), ())
+    }
+
+    pub(crate) fn hoist_witness_pat(&self, pat: &WitnessPat<'p>) -> Pat {
+        let mut subpatterns = pat.iter_fields().map(|p| self.hoist_witness_pat(p));
+        let kind = match pat.ctor() {
+            &Bool(value) => PatKind::LiteralBool { value },
+            IntRange(_) => unimplemented!(),
+            Struct | Variant(_) | UnionField => match pat.ty().kind(Interner) {
+                TyKind::Tuple(..) => PatKind::Leaf {
+                    subpatterns: subpatterns
+                        .zip(0u32..)
+                        .map(|(p, i)| FieldPat {
+                            field: LocalFieldId::from_raw(i.into()),
+                            pattern: p,
+                        })
+                        .collect(),
+                },
+                TyKind::Adt(adt, _) if is_box(self.db, adt.0) => {
+                    // Without `box_patterns`, the only legal pattern of type `Box` is `_` (outside
+                    // of `std`). So this branch is only reachable when the feature is enabled and
+                    // the pattern is a box pattern.
+                    PatKind::Deref { subpattern: subpatterns.next().unwrap() }
+                }
+                TyKind::Adt(adt, substs) => {
+                    let variant = self.variant_id_for_adt(pat.ctor(), adt.0);
+                    let subpatterns = self
+                        .list_variant_nonhidden_fields(pat.ty(), variant)
+                        .zip(subpatterns)
+                        .map(|((field, _ty), pattern)| FieldPat { field, pattern })
+                        .collect();
+
+                    if let VariantId::EnumVariantId(enum_variant) = variant {
+                        PatKind::Variant { substs: substs.clone(), enum_variant, subpatterns }
+                    } else {
+                        PatKind::Leaf { subpatterns }
+                    }
+                }
+                _ => {
+                    never!("unexpected ctor for type {:?} {:?}", pat.ctor(), pat.ty());
+                    PatKind::Wild
+                }
+            },
+            // Note: given the expansion of `&str` patterns done in `expand_pattern`, we should
+            // be careful to reconstruct the correct constant pattern here. However a string
+            // literal pattern will never be reported as a non-exhaustiveness witness, so we
+            // ignore this issue.
+            Ref => PatKind::Deref { subpattern: subpatterns.next().unwrap() },
+            Slice(_) => unimplemented!(),
+            &Str(void) => match void {},
+            Wildcard | NonExhaustive | Hidden => PatKind::Wild,
+            Missing | F32Range(..) | F64Range(..) | Opaque(..) | Or => {
+                never!("can't convert to pattern: {:?}", pat.ctor());
+                PatKind::Wild
+            }
+        };
+        Pat { ty: pat.ty().clone(), kind: Box::new(kind) }
+    }
+}
+
+impl<'p> TypeCx for MatchCheckCtx<'p> {
+    type Error = Void;
+    type Ty = Ty;
+    type VariantIdx = EnumVariantId;
+    type StrLit = Void;
+    type ArmData = ();
+    type PatData = ();
+
+    fn is_exhaustive_patterns_feature_on(&self) -> bool {
+        self.exhaustive_patterns
+    }
+
+    fn ctor_arity(
+        &self,
+        ctor: &rustc_pattern_analysis::constructor::Constructor<Self>,
+        ty: &Self::Ty,
+    ) -> usize {
+        match ctor {
+            Struct | Variant(_) | UnionField => match *ty.kind(Interner) {
+                TyKind::Tuple(arity, ..) => arity,
+                TyKind::Adt(AdtId(adt), ..) => {
+                    if is_box(self.db, adt) {
+                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
+                        // patterns. If we're here we can assume this is a box pattern.
+                        1
+                    } else {
+                        let variant = self.variant_id_for_adt(ctor, adt);
+                        self.list_variant_nonhidden_fields(ty, variant).count()
+                    }
+                }
+                _ => {
+                    never!("Unexpected type for `Single` constructor: {:?}", ty);
+                    0
+                }
+            },
+            Ref => 1,
+            Slice(..) => unimplemented!(),
+            Bool(..) | IntRange(..) | F32Range(..) | F64Range(..) | Str(..) | Opaque(..)
+            | NonExhaustive | Hidden | Missing | Wildcard => 0,
+            Or => {
+                never!("The `Or` constructor doesn't have a fixed arity");
+                0
+            }
+        }
+    }
+
+    fn ctor_sub_tys(
+        &self,
+        ctor: &rustc_pattern_analysis::constructor::Constructor<Self>,
+        ty: &Self::Ty,
+    ) -> &[Self::Ty] {
+        use std::iter::once;
+        fn alloc<'a>(cx: &'a MatchCheckCtx<'_>, iter: impl Iterator<Item = Ty>) -> &'a [Ty] {
+            cx.ty_arena.alloc_extend(iter)
+        }
+        match ctor {
+            Struct | Variant(_) | UnionField => match ty.kind(Interner) {
+                TyKind::Tuple(_, substs) => {
+                    let tys = substs.iter(Interner).map(|ty| ty.assert_ty_ref(Interner));
+                    alloc(self, tys.cloned())
+                }
+                TyKind::Ref(.., rty) => alloc(self, once(rty.clone())),
+                &TyKind::Adt(AdtId(adt), ref substs) => {
+                    if is_box(self.db, adt) {
+                        // The only legal patterns of type `Box` (outside `std`) are `_` and box
+                        // patterns. If we're here we can assume this is a box pattern.
+                        let subst_ty = substs.at(Interner, 0).assert_ty_ref(Interner).clone();
+                        alloc(self, once(subst_ty))
+                    } else {
+                        let variant = self.variant_id_for_adt(ctor, adt);
+                        let tys = self.list_variant_nonhidden_fields(ty, variant).map(|(_, ty)| ty);
+                        alloc(self, tys)
+                    }
+                }
+                ty_kind => {
+                    never!("Unexpected type for `{:?}` constructor: {:?}", ctor, ty_kind);
+                    alloc(self, once(ty.clone()))
+                }
+            },
+            Ref => match ty.kind(Interner) {
+                TyKind::Ref(.., rty) => alloc(self, once(rty.clone())),
+                ty_kind => {
+                    never!("Unexpected type for `{:?}` constructor: {:?}", ctor, ty_kind);
+                    alloc(self, once(ty.clone()))
+                }
+            },
+            Slice(_) => unreachable!("Found a `Slice` constructor in match checking"),
+            Bool(..) | IntRange(..) | F32Range(..) | F64Range(..) | Str(..) | Opaque(..)
+            | NonExhaustive | Hidden | Missing | Wildcard => &[],
+            Or => {
+                never!("called `Fields::wildcards` on an `Or` ctor");
+                &[]
+            }
+        }
+    }
+
+    fn ctors_for_ty(
+        &self,
+        ty: &Self::Ty,
+    ) -> Result<rustc_pattern_analysis::constructor::ConstructorSet<Self>, Self::Error> {
+        let cx = self;
+
+        // Unhandled types are treated as non-exhaustive. Being explicit here instead of falling
+        // to catchall arm to ease further implementation.
+        let unhandled = || ConstructorSet::Unlistable;
+
+        // This determines the set of all possible constructors for the type `ty`. For numbers,
+        // arrays and slices we use ranges and variable-length slices when appropriate.
+        //
+        // If the `exhaustive_patterns` feature is enabled, we make sure to omit constructors that
+        // are statically impossible. E.g., for `Option<!>`, we do not include `Some(_)` in the
+        // returned list of constructors.
+        // Invariant: this is empty if and only if the type is uninhabited (as determined by
+        // `cx.is_uninhabited()`).
+        Ok(match ty.kind(Interner) {
+            TyKind::Scalar(Scalar::Bool) => ConstructorSet::Bool,
+            TyKind::Scalar(Scalar::Char) => unhandled(),
+            TyKind::Scalar(Scalar::Int(..) | Scalar::Uint(..)) => unhandled(),
+            TyKind::Array(..) | TyKind::Slice(..) => unhandled(),
+            TyKind::Adt(AdtId(hir_def::AdtId::EnumId(enum_id)), subst) => {
+                let enum_data = cx.db.enum_data(*enum_id);
+                let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(ty);
+
+                if enum_data.variants.is_empty() && !is_declared_nonexhaustive {
+                    ConstructorSet::NoConstructors
+                } else {
+                    let mut variants = FxHashMap::default();
+                    for &(variant, _) in enum_data.variants.iter() {
+                        let is_uninhabited =
+                            is_enum_variant_uninhabited_from(variant, subst, cx.module, cx.db);
+                        let visibility = if is_uninhabited {
+                            VariantVisibility::Empty
+                        } else {
+                            VariantVisibility::Visible
+                        };
+                        variants.insert(variant, visibility);
+                    }
+
+                    ConstructorSet::Variants {
+                        variants: IdxContainer(variants),
+                        non_exhaustive: is_declared_nonexhaustive,
+                    }
+                }
+            }
+            TyKind::Adt(AdtId(hir_def::AdtId::UnionId(_)), _) => ConstructorSet::Union,
+            TyKind::Adt(..) | TyKind::Tuple(..) => {
+                ConstructorSet::Struct { empty: cx.is_uninhabited(ty) }
+            }
+            TyKind::Ref(..) => ConstructorSet::Ref,
+            TyKind::Never => ConstructorSet::NoConstructors,
+            // This type is one for which we cannot list constructors, like `str` or `f64`.
+            _ => ConstructorSet::Unlistable,
+        })
+    }
+
+    fn debug_pat(
+        _f: &mut fmt::Formatter<'_>,
+        _pat: &rustc_pattern_analysis::pat::DeconstructedPat<'_, Self>,
+    ) -> fmt::Result {
+        unimplemented!()
+    }
+
+    fn bug(&self, fmt: fmt::Arguments<'_>) -> ! {
+        panic!("{}", fmt)
+    }
+}
+
+impl<'p> fmt::Debug for MatchCheckCtx<'p> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MatchCheckCtx").finish()
+    }
+}
diff --git a/crates/hir-ty/src/diagnostics/match_check/usefulness.rs b/crates/hir-ty/src/diagnostics/match_check/usefulness.rs
deleted file mode 100644
index 1b1a5ff2694..00000000000
--- a/crates/hir-ty/src/diagnostics/match_check/usefulness.rs
+++ /dev/null
@@ -1,824 +0,0 @@
-//! Based on rust-lang/rust (last sync f31622a50 2021-11-12)
-//! <https://github.com/rust-lang/rust/blob/f31622a50/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs>
-//!
-//! -----
-//!
-//! This file includes the logic for exhaustiveness and reachability checking for pattern-matching.
-//! Specifically, given a list of patterns for a type, we can tell whether:
-//! (a) each pattern is reachable (reachability)
-//! (b) the patterns cover every possible value for the type (exhaustiveness)
-//!
-//! The algorithm implemented here is a modified version of the one described in [this
-//! paper](http://moscova.inria.fr/~maranget/papers/warn/index.html). We have however generalized
-//! it to accommodate the variety of patterns that Rust supports. We thus explain our version here,
-//! without being as rigorous.
-//!
-//!
-//! # Summary
-//!
-//! The core of the algorithm is the notion of "usefulness". A pattern `q` is said to be *useful*
-//! relative to another pattern `p` of the same type if there is a value that is matched by `q` and
-//! not matched by `p`. This generalizes to many `p`s: `q` is useful w.r.t. a list of patterns
-//! `p_1 .. p_n` if there is a value that is matched by `q` and by none of the `p_i`. We write
-//! `usefulness(p_1 .. p_n, q)` for a function that returns a list of such values. The aim of this
-//! file is to compute it efficiently.
-//!
-//! This is enough to compute reachability: a pattern in a `match` expression is reachable iff it
-//! is useful w.r.t. the patterns above it:
-//! ```rust
-//! match x {
-//!     Some(_) => ...,
-//!     None => ..., // reachable: `None` is matched by this but not the branch above
-//!     Some(0) => ..., // unreachable: all the values this matches are already matched by
-//!                     // `Some(_)` above
-//! }
-//! ```
-//!
-//! This is also enough to compute exhaustiveness: a match is exhaustive iff the wildcard `_`
-//! pattern is _not_ useful w.r.t. the patterns in the match. The values returned by `usefulness`
-//! are used to tell the user which values are missing.
-//! ```rust
-//! match x {
-//!     Some(0) => ...,
-//!     None => ...,
-//!     // not exhaustive: `_` is useful because it matches `Some(1)`
-//! }
-//! ```
-//!
-//! The entrypoint of this file is the [`compute_match_usefulness`] function, which computes
-//! reachability for each match branch and exhaustiveness for the whole match.
-//!
-//!
-//! # Constructors and fields
-//!
-//! Note: we will often abbreviate "constructor" as "ctor".
-//!
-//! The idea that powers everything that is done in this file is the following: a (matcheable)
-//! value is made from a constructor applied to a number of subvalues. Examples of constructors are
-//! `Some`, `None`, `(,)` (the 2-tuple constructor), `Foo {..}` (the constructor for a struct
-//! `Foo`), and `2` (the constructor for the number `2`). This is natural when we think of
-//! pattern-matching, and this is the basis for what follows.
-//!
-//! Some of the ctors listed above might feel weird: `None` and `2` don't take any arguments.
-//! That's ok: those are ctors that take a list of 0 arguments; they are the simplest case of
-//! ctors. We treat `2` as a ctor because `u64` and other number types behave exactly like a huge
-//! `enum`, with one variant for each number. This allows us to see any matcheable value as made up
-//! from a tree of ctors, each having a set number of children. For example: `Foo { bar: None,
-//! baz: Ok(0) }` is made from 4 different ctors, namely `Foo{..}`, `None`, `Ok` and `0`.
-//!
-//! This idea can be extended to patterns: they are also made from constructors applied to fields.
-//! A pattern for a given type is allowed to use all the ctors for values of that type (which we
-//! call "value constructors"), but there are also pattern-only ctors. The most important one is
-//! the wildcard (`_`), and the others are integer ranges (`0..=10`), variable-length slices (`[x,
-//! ..]`), and or-patterns (`Ok(0) | Err(_)`). Examples of valid patterns are `42`, `Some(_)`, `Foo
-//! { bar: Some(0) | None, baz: _ }`. Note that a binder in a pattern (e.g. `Some(x)`) matches the
-//! same values as a wildcard (e.g. `Some(_)`), so we treat both as wildcards.
-//!
-//! From this deconstruction we can compute whether a given value matches a given pattern; we
-//! simply look at ctors one at a time. Given a pattern `p` and a value `v`, we want to compute
-//! `matches!(v, p)`. It's mostly straightforward: we compare the head ctors and when they match
-//! we compare their fields recursively. A few representative examples:
-//!
-//! - `matches!(v, _) := true`
-//! - `matches!((v0,  v1), (p0,  p1)) := matches!(v0, p0) && matches!(v1, p1)`
-//! - `matches!(Foo { bar: v0, baz: v1 }, Foo { bar: p0, baz: p1 }) := matches!(v0, p0) && matches!(v1, p1)`
-//! - `matches!(Ok(v0), Ok(p0)) := matches!(v0, p0)`
-//! - `matches!(Ok(v0), Err(p0)) := false` (incompatible variants)
-//! - `matches!(v, 1..=100) := matches!(v, 1) || ... || matches!(v, 100)`
-//! - `matches!([v0], [p0, .., p1]) := false` (incompatible lengths)
-//! - `matches!([v0, v1, v2], [p0, .., p1]) := matches!(v0, p0) && matches!(v2, p1)`
-//! - `matches!(v, p0 | p1) := matches!(v, p0) || matches!(v, p1)`
-//!
-//! Constructors, fields and relevant operations are defined in the [`super::deconstruct_pat`] module.
-//!
-//! Note: this constructors/fields distinction may not straightforwardly apply to every Rust type.
-//! For example a value of type `Rc<u64>` can't be deconstructed that way, and `&str` has an
-//! infinitude of constructors. There are also subtleties with visibility of fields and
-//! uninhabitedness and various other things. The constructors idea can be extended to handle most
-//! of these subtleties though; caveats are documented where relevant throughout the code.
-//!
-//! Whether constructors cover each other is computed by [`Constructor::is_covered_by`].
-//!
-//!
-//! # Specialization
-//!
-//! Recall that we wish to compute `usefulness(p_1 .. p_n, q)`: given a list of patterns `p_1 ..
-//! p_n` and a pattern `q`, all of the same type, we want to find a list of values (called
-//! "witnesses") that are matched by `q` and by none of the `p_i`. We obviously don't just
-//! enumerate all possible values. From the discussion above we see that we can proceed
-//! ctor-by-ctor: for each value ctor of the given type, we ask "is there a value that starts with
-//! this constructor and matches `q` and none of the `p_i`?". As we saw above, there's a lot we can
-//! say from knowing only the first constructor of our candidate value.
-//!
-//! Let's take the following example:
-//! ```
-//! match x {
-//!     Enum::Variant1(_) => {} // `p1`
-//!     Enum::Variant2(None, 0) => {} // `p2`
-//!     Enum::Variant2(Some(_), 0) => {} // `q`
-//! }
-//! ```
-//!
-//! We can easily see that if our candidate value `v` starts with `Variant1` it will not match `q`.
-//! If `v = Variant2(v0, v1)` however, whether or not it matches `p2` and `q` will depend on `v0`
-//! and `v1`. In fact, such a `v` will be a witness of usefulness of `q` exactly when the tuple
-//! `(v0, v1)` is a witness of usefulness of `q'` in the following reduced match:
-//!
-//! ```
-//! match x {
-//!     (None, 0) => {} // `p2'`
-//!     (Some(_), 0) => {} // `q'`
-//! }
-//! ```
-//!
-//! This motivates a new step in computing usefulness, that we call _specialization_.
-//! Specialization consist of filtering a list of patterns for those that match a constructor, and
-//! then looking into the constructor's fields. This enables usefulness to be computed recursively.
-//!
-//! Instead of acting on a single pattern in each row, we will consider a list of patterns for each
-//! row, and we call such a list a _pattern-stack_. The idea is that we will specialize the
-//! leftmost pattern, which amounts to popping the constructor and pushing its fields, which feels
-//! like a stack. We note a pattern-stack simply with `[p_1 ... p_n]`.
-//! Here's a sequence of specializations of a list of pattern-stacks, to illustrate what's
-//! happening:
-//! ```
-//! [Enum::Variant1(_)]
-//! [Enum::Variant2(None, 0)]
-//! [Enum::Variant2(Some(_), 0)]
-//! //==>> specialize with `Variant2`
-//! [None, 0]
-//! [Some(_), 0]
-//! //==>> specialize with `Some`
-//! [_, 0]
-//! //==>> specialize with `true` (say the type was `bool`)
-//! [0]
-//! //==>> specialize with `0`
-//! []
-//! ```
-//!
-//! The function `specialize(c, p)` takes a value constructor `c` and a pattern `p`, and returns 0
-//! or more pattern-stacks. If `c` does not match the head constructor of `p`, it returns nothing;
-//! otherwise if returns the fields of the constructor. This only returns more than one
-//! pattern-stack if `p` has a pattern-only constructor.
-//!
-//! - Specializing for the wrong constructor returns nothing
-//!
-//!   `specialize(None, Some(p0)) := []`
-//!
-//! - Specializing for the correct constructor returns a single row with the fields
-//!
-//!   `specialize(Variant1, Variant1(p0, p1, p2)) := [[p0, p1, p2]]`
-//!
-//!   `specialize(Foo{..}, Foo { bar: p0, baz: p1 }) := [[p0, p1]]`
-//!
-//! - For or-patterns, we specialize each branch and concatenate the results
-//!
-//!   `specialize(c, p0 | p1) := specialize(c, p0) ++ specialize(c, p1)`
-//!
-//! - We treat the other pattern constructors as if they were a large or-pattern of all the
-//!   possibilities:
-//!
-//!   `specialize(c, _) := specialize(c, Variant1(_) | Variant2(_, _) | ...)`
-//!
-//!   `specialize(c, 1..=100) := specialize(c, 1 | ... | 100)`
-//!
-//!   `specialize(c, [p0, .., p1]) := specialize(c, [p0, p1] | [p0, _, p1] | [p0, _, _, p1] | ...)`
-//!
-//! - If `c` is a pattern-only constructor, `specialize` is defined on a case-by-case basis. See
-//!   the discussion about constructor splitting in [`super::deconstruct_pat`].
-//!
-//!
-//! We then extend this function to work with pattern-stacks as input, by acting on the first
-//! column and keeping the other columns untouched.
-//!
-//! Specialization for the whole matrix is done in [`Matrix::specialize_constructor`]. Note that
-//! or-patterns in the first column are expanded before being stored in the matrix. Specialization
-//! for a single patstack is done from a combination of [`Constructor::is_covered_by`] and
-//! [`PatStack::pop_head_constructor`]. The internals of how it's done mostly live in the
-//! [`Fields`] struct.
-//!
-//!
-//! # Computing usefulness
-//!
-//! We now have all we need to compute usefulness. The inputs to usefulness are a list of
-//! pattern-stacks `p_1 ... p_n` (one per row), and a new pattern_stack `q`. The paper and this
-//! file calls the list of patstacks a _matrix_. They must all have the same number of columns and
-//! the patterns in a given column must all have the same type. `usefulness` returns a (possibly
-//! empty) list of witnesses of usefulness. These witnesses will also be pattern-stacks.
-//!
-//! - base case: `n_columns == 0`.
-//!     Since a pattern-stack functions like a tuple of patterns, an empty one functions like the
-//!     unit type. Thus `q` is useful iff there are no rows above it, i.e. if `n == 0`.
-//!
-//! - inductive case: `n_columns > 0`.
-//!     We need a way to list the constructors we want to try. We will be more clever in the next
-//!     section but for now assume we list all value constructors for the type of the first column.
-//!
-//!     - for each such ctor `c`:
-//!
-//!         - for each `q'` returned by `specialize(c, q)`:
-//!
-//!             - we compute `usefulness(specialize(c, p_1) ... specialize(c, p_n), q')`
-//!
-//!         - for each witness found, we revert specialization by pushing the constructor `c` on top.
-//!
-//!     - We return the concatenation of all the witnesses found, if any.
-//!
-//! Example:
-//! ```
-//! [Some(true)] // p_1
-//! [None] // p_2
-//! [Some(_)] // q
-//! //==>> try `None`: `specialize(None, q)` returns nothing
-//! //==>> try `Some`: `specialize(Some, q)` returns a single row
-//! [true] // p_1'
-//! [_] // q'
-//! //==>> try `true`: `specialize(true, q')` returns a single row
-//! [] // p_1''
-//! [] // q''
-//! //==>> base case; `n != 0` so `q''` is not useful.
-//! //==>> go back up a step
-//! [true] // p_1'
-//! [_] // q'
-//! //==>> try `false`: `specialize(false, q')` returns a single row
-//! [] // q''
-//! //==>> base case; `n == 0` so `q''` is useful. We return the single witness `[]`
-//! witnesses:
-//! []
-//! //==>> undo the specialization with `false`
-//! witnesses:
-//! [false]
-//! //==>> undo the specialization with `Some`
-//! witnesses:
-//! [Some(false)]
-//! //==>> we have tried all the constructors. The output is the single witness `[Some(false)]`.
-//! ```
-//!
-//! This computation is done in [`is_useful`]. In practice we don't care about the list of
-//! witnesses when computing reachability; we only need to know whether any exist. We do keep the
-//! witnesses when computing exhaustiveness to report them to the user.
-//!
-//!
-//! # Making usefulness tractable: constructor splitting
-//!
-//! We're missing one last detail: which constructors do we list? Naively listing all value
-//! constructors cannot work for types like `u64` or `&str`, so we need to be more clever. The
-//! first obvious insight is that we only want to list constructors that are covered by the head
-//! constructor of `q`. If it's a value constructor, we only try that one. If it's a pattern-only
-//! constructor, we use the final clever idea for this algorithm: _constructor splitting_, where we
-//! group together constructors that behave the same.
-//!
-//! The details are not necessary to understand this file, so we explain them in
-//! [`super::deconstruct_pat`]. Splitting is done by the [`Constructor::split`] function.
-
-use std::iter::once;
-
-use hir_def::{AdtId, DefWithBodyId, HasModule, ModuleId};
-use smallvec::{smallvec, SmallVec};
-use typed_arena::Arena;
-
-use crate::{db::HirDatabase, inhabitedness::is_ty_uninhabited_from, Ty, TyExt};
-
-use super::deconstruct_pat::{Constructor, DeconstructedPat, Fields, SplitWildcard};
-
-use self::{helper::Captures, ArmType::*, Usefulness::*};
-
-pub(crate) struct MatchCheckCtx<'a, 'p> {
-    pub(crate) module: ModuleId,
-    pub(crate) body: DefWithBodyId,
-    pub(crate) db: &'a dyn HirDatabase,
-    /// Lowered patterns from arms plus generated by the check.
-    pub(crate) pattern_arena: &'p Arena<DeconstructedPat<'p>>,
-    exhaustive_patterns: bool,
-}
-
-impl<'a, 'p> MatchCheckCtx<'a, 'p> {
-    pub(crate) fn new(
-        module: ModuleId,
-        body: DefWithBodyId,
-        db: &'a dyn HirDatabase,
-        pattern_arena: &'p Arena<DeconstructedPat<'p>>,
-    ) -> Self {
-        let def_map = db.crate_def_map(module.krate());
-        let exhaustive_patterns = def_map.is_unstable_feature_enabled("exhaustive_patterns");
-        Self { module, body, db, pattern_arena, exhaustive_patterns }
-    }
-
-    pub(super) fn is_uninhabited(&self, ty: &Ty) -> bool {
-        if self.feature_exhaustive_patterns() {
-            is_ty_uninhabited_from(ty, self.module, self.db)
-        } else {
-            false
-        }
-    }
-
-    /// Returns whether the given type is an enum from another crate declared `#[non_exhaustive]`.
-    pub(super) fn is_foreign_non_exhaustive_enum(&self, ty: &Ty) -> bool {
-        match ty.as_adt() {
-            Some((adt @ AdtId::EnumId(_), _)) => {
-                let has_non_exhaustive_attr =
-                    self.db.attrs(adt.into()).by_key("non_exhaustive").exists();
-                let is_local = adt.module(self.db.upcast()).krate() == self.module.krate();
-                has_non_exhaustive_attr && !is_local
-            }
-            _ => false,
-        }
-    }
-
-    // Rust's unstable feature described as "Allows exhaustive pattern matching on types that contain uninhabited types."
-    pub(super) fn feature_exhaustive_patterns(&self) -> bool {
-        self.exhaustive_patterns
-    }
-}
-
-#[derive(Copy, Clone)]
-pub(super) struct PatCtxt<'a, 'p> {
-    pub(super) cx: &'a MatchCheckCtx<'a, 'p>,
-    /// Type of the current column under investigation.
-    pub(super) ty: &'a Ty,
-    /// Whether the current pattern is the whole pattern as found in a match arm, or if it's a
-    /// subpattern.
-    pub(super) is_top_level: bool,
-    /// Whether the current pattern is from a `non_exhaustive` enum.
-    pub(super) is_non_exhaustive: bool,
-}
-
-/// A row of a matrix. Rows of len 1 are very common, which is why `SmallVec[_; 2]`
-/// works well.
-#[derive(Clone)]
-pub(super) struct PatStack<'p> {
-    pats: SmallVec<[&'p DeconstructedPat<'p>; 2]>,
-}
-
-impl<'p> PatStack<'p> {
-    fn from_pattern(pat: &'p DeconstructedPat<'p>) -> Self {
-        Self::from_vec(smallvec![pat])
-    }
-
-    fn from_vec(vec: SmallVec<[&'p DeconstructedPat<'p>; 2]>) -> Self {
-        PatStack { pats: vec }
-    }
-
-    fn is_empty(&self) -> bool {
-        self.pats.is_empty()
-    }
-
-    fn len(&self) -> usize {
-        self.pats.len()
-    }
-
-    fn head(&self) -> &'p DeconstructedPat<'p> {
-        self.pats[0]
-    }
-
-    // Recursively expand the first pattern into its subpatterns. Only useful if the pattern is an
-    // or-pattern. Panics if `self` is empty.
-    fn expand_or_pat(&self) -> impl Iterator<Item = PatStack<'p>> + Captures<'_> {
-        self.head().iter_fields().map(move |pat| {
-            let mut new_patstack = PatStack::from_pattern(pat);
-            new_patstack.pats.extend_from_slice(&self.pats[1..]);
-            new_patstack
-        })
-    }
-
-    /// This computes `S(self.head().ctor(), self)`. See top of the file for explanations.
-    ///
-    /// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing
-    /// fields filled with wild patterns.
-    ///
-    /// This is roughly the inverse of `Constructor::apply`.
-    fn pop_head_constructor(&self, cx: &MatchCheckCtx<'_, 'p>, ctor: &Constructor) -> PatStack<'p> {
-        // We pop the head pattern and push the new fields extracted from the arguments of
-        // `self.head()`.
-        let mut new_fields: SmallVec<[_; 2]> = self.head().specialize(cx, ctor);
-        new_fields.extend_from_slice(&self.pats[1..]);
-        PatStack::from_vec(new_fields)
-    }
-}
-
-/// A 2D matrix.
-#[derive(Clone)]
-pub(super) struct Matrix<'p> {
-    patterns: Vec<PatStack<'p>>,
-}
-
-impl<'p> Matrix<'p> {
-    fn empty() -> Self {
-        Matrix { patterns: vec![] }
-    }
-
-    /// Number of columns of this matrix. `None` is the matrix is empty.
-    pub(super) fn _column_count(&self) -> Option<usize> {
-        self.patterns.first().map(|r| r.len())
-    }
-
-    /// Pushes a new row to the matrix. If the row starts with an or-pattern, this recursively
-    /// expands it.
-    fn push(&mut self, row: PatStack<'p>) {
-        if !row.is_empty() && row.head().is_or_pat() {
-            self.patterns.extend(row.expand_or_pat());
-        } else {
-            self.patterns.push(row);
-        }
-    }
-
-    /// Iterate over the first component of each row
-    fn heads(&self) -> impl Iterator<Item = &'p DeconstructedPat<'p>> + Clone + Captures<'_> {
-        self.patterns.iter().map(|r| r.head())
-    }
-
-    /// This computes `S(constructor, self)`. See top of the file for explanations.
-    fn specialize_constructor(&self, pcx: PatCtxt<'_, 'p>, ctor: &Constructor) -> Matrix<'p> {
-        let mut matrix = Matrix::empty();
-        for row in &self.patterns {
-            if ctor.is_covered_by(pcx, row.head().ctor()) {
-                let new_row = row.pop_head_constructor(pcx.cx, ctor);
-                matrix.push(new_row);
-            }
-        }
-        matrix
-    }
-}
-
-/// This carries the results of computing usefulness, as described at the top of the file. When
-/// checking usefulness of a match branch, we use the `NoWitnesses` variant, which also keeps track
-/// of potential unreachable sub-patterns (in the presence of or-patterns). When checking
-/// exhaustiveness of a whole match, we use the `WithWitnesses` variant, which carries a list of
-/// witnesses of non-exhaustiveness when there are any.
-/// Which variant to use is dictated by `ArmType`.
-enum Usefulness<'p> {
-    /// If we don't care about witnesses, simply remember if the pattern was useful.
-    NoWitnesses { useful: bool },
-    /// Carries a list of witnesses of non-exhaustiveness. If empty, indicates that the whole
-    /// pattern is unreachable.
-    WithWitnesses(Vec<Witness<'p>>),
-}
-
-impl<'p> Usefulness<'p> {
-    fn new_useful(preference: ArmType) -> Self {
-        match preference {
-            // A single (empty) witness of reachability.
-            FakeExtraWildcard => WithWitnesses(vec![Witness(vec![])]),
-            RealArm => NoWitnesses { useful: true },
-        }
-    }
-    fn new_not_useful(preference: ArmType) -> Self {
-        match preference {
-            FakeExtraWildcard => WithWitnesses(vec![]),
-            RealArm => NoWitnesses { useful: false },
-        }
-    }
-
-    fn is_useful(&self) -> bool {
-        match self {
-            Usefulness::NoWitnesses { useful } => *useful,
-            Usefulness::WithWitnesses(witnesses) => !witnesses.is_empty(),
-        }
-    }
-
-    /// Combine usefulnesses from two branches. This is an associative operation.
-    fn extend(&mut self, other: Self) {
-        match (&mut *self, other) {
-            (WithWitnesses(_), WithWitnesses(o)) if o.is_empty() => {}
-            (WithWitnesses(s), WithWitnesses(o)) if s.is_empty() => *self = WithWitnesses(o),
-            (WithWitnesses(s), WithWitnesses(o)) => s.extend(o),
-            (NoWitnesses { useful: s_useful }, NoWitnesses { useful: o_useful }) => {
-                *s_useful = *s_useful || o_useful
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// After calculating usefulness after a specialization, call this to reconstruct a usefulness
-    /// that makes sense for the matrix pre-specialization. This new usefulness can then be merged
-    /// with the results of specializing with the other constructors.
-    fn apply_constructor(
-        self,
-        pcx: PatCtxt<'_, 'p>,
-        matrix: &Matrix<'p>,
-        ctor: &Constructor,
-    ) -> Self {
-        match self {
-            NoWitnesses { .. } => self,
-            WithWitnesses(ref witnesses) if witnesses.is_empty() => self,
-            WithWitnesses(witnesses) => {
-                let new_witnesses = if let Constructor::Missing { .. } = ctor {
-                    // We got the special `Missing` constructor, so each of the missing constructors
-                    // gives a new pattern that is not caught by the match. We list those patterns.
-                    let new_patterns = if pcx.is_non_exhaustive {
-                        // Here we don't want the user to try to list all variants, we want them to add
-                        // a wildcard, so we only suggest that.
-                        vec![DeconstructedPat::wildcard(pcx.ty.clone())]
-                    } else {
-                        let mut split_wildcard = SplitWildcard::new(pcx);
-                        split_wildcard.split(pcx, matrix.heads().map(DeconstructedPat::ctor));
-
-                        // This lets us know if we skipped any variants because they are marked
-                        // `doc(hidden)` or they are unstable feature gate (only stdlib types).
-                        let mut hide_variant_show_wild = false;
-                        // Construct for each missing constructor a "wild" version of this
-                        // constructor, that matches everything that can be built with
-                        // it. For example, if `ctor` is a `Constructor::Variant` for
-                        // `Option::Some`, we get the pattern `Some(_)`.
-                        let mut new: Vec<DeconstructedPat<'_>> = split_wildcard
-                            .iter_missing(pcx)
-                            .filter_map(|missing_ctor| {
-                                // Check if this variant is marked `doc(hidden)`
-                                if missing_ctor.is_doc_hidden_variant(pcx)
-                                    || missing_ctor.is_unstable_variant(pcx)
-                                {
-                                    hide_variant_show_wild = true;
-                                    return None;
-                                }
-                                Some(DeconstructedPat::wild_from_ctor(pcx, missing_ctor.clone()))
-                            })
-                            .collect();
-
-                        if hide_variant_show_wild {
-                            new.push(DeconstructedPat::wildcard(pcx.ty.clone()))
-                        }
-
-                        new
-                    };
-
-                    witnesses
-                        .into_iter()
-                        .flat_map(|witness| {
-                            new_patterns.iter().map(move |pat| {
-                                Witness(
-                                    witness
-                                        .0
-                                        .iter()
-                                        .chain(once(pat))
-                                        .map(DeconstructedPat::clone_and_forget_reachability)
-                                        .collect(),
-                                )
-                            })
-                        })
-                        .collect()
-                } else {
-                    witnesses
-                        .into_iter()
-                        .map(|witness| witness.apply_constructor(pcx, ctor))
-                        .collect()
-                };
-                WithWitnesses(new_witnesses)
-            }
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-enum ArmType {
-    FakeExtraWildcard,
-    RealArm,
-}
-
-/// A witness of non-exhaustiveness for error reporting, represented
-/// as a list of patterns (in reverse order of construction) with
-/// wildcards inside to represent elements that can take any inhabitant
-/// of the type as a value.
-///
-/// A witness against a list of patterns should have the same types
-/// and length as the pattern matched against. Because Rust `match`
-/// is always against a single pattern, at the end the witness will
-/// have length 1, but in the middle of the algorithm, it can contain
-/// multiple patterns.
-///
-/// For example, if we are constructing a witness for the match against
-///
-/// ```
-/// struct Pair(Option<(u32, u32)>, bool);
-///
-/// match (p: Pair) {
-///    Pair(None, _) => {}
-///    Pair(_, false) => {}
-/// }
-/// ```
-///
-/// We'll perform the following steps:
-/// 1. Start with an empty witness
-///     `Witness(vec![])`
-/// 2. Push a witness `true` against the `false`
-///     `Witness(vec![true])`
-/// 3. Push a witness `Some(_)` against the `None`
-///     `Witness(vec![true, Some(_)])`
-/// 4. Apply the `Pair` constructor to the witnesses
-///     `Witness(vec![Pair(Some(_), true)])`
-///
-/// The final `Pair(Some(_), true)` is then the resulting witness.
-pub(crate) struct Witness<'p>(Vec<DeconstructedPat<'p>>);
-
-impl<'p> Witness<'p> {
-    /// Asserts that the witness contains a single pattern, and returns it.
-    fn single_pattern(self) -> DeconstructedPat<'p> {
-        assert_eq!(self.0.len(), 1);
-        self.0.into_iter().next().unwrap()
-    }
-
-    /// Constructs a partial witness for a pattern given a list of
-    /// patterns expanded by the specialization step.
-    ///
-    /// When a pattern P is discovered to be useful, this function is used bottom-up
-    /// to reconstruct a complete witness, e.g., a pattern P' that covers a subset
-    /// of values, V, where each value in that set is not covered by any previously
-    /// used patterns and is covered by the pattern P'. Examples:
-    ///
-    /// left_ty: tuple of 3 elements
-    /// pats: [10, 20, _]           => (10, 20, _)
-    ///
-    /// left_ty: struct X { a: (bool, &'static str), b: usize}
-    /// pats: [(false, "foo"), 42]  => X { a: (false, "foo"), b: 42 }
-    fn apply_constructor(mut self, pcx: PatCtxt<'_, 'p>, ctor: &Constructor) -> Self {
-        let pat = {
-            let len = self.0.len();
-            let arity = ctor.arity(pcx);
-            let pats = self.0.drain((len - arity)..).rev();
-            let fields = Fields::from_iter(pcx.cx, pats);
-            DeconstructedPat::new(ctor.clone(), fields, pcx.ty.clone())
-        };
-
-        self.0.push(pat);
-
-        self
-    }
-}
-
-/// Algorithm from <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
-/// The algorithm from the paper has been modified to correctly handle empty
-/// types. The changes are:
-///   (0) We don't exit early if the pattern matrix has zero rows. We just
-///       continue to recurse over columns.
-///   (1) all_constructors will only return constructors that are statically
-///       possible. E.g., it will only return `Ok` for `Result<T, !>`.
-///
-/// This finds whether a (row) vector `v` of patterns is 'useful' in relation
-/// to a set of such vectors `m` - this is defined as there being a set of
-/// inputs that will match `v` but not any of the sets in `m`.
-///
-/// All the patterns at each column of the `matrix ++ v` matrix must have the same type.
-///
-/// This is used both for reachability checking (if a pattern isn't useful in
-/// relation to preceding patterns, it is not reachable) and exhaustiveness
-/// checking (if a wildcard pattern is useful in relation to a matrix, the
-/// matrix isn't exhaustive).
-///
-/// `is_under_guard` is used to inform if the pattern has a guard. If it
-/// has one it must not be inserted into the matrix. This shouldn't be
-/// relied on for soundness.
-fn is_useful<'p>(
-    cx: &MatchCheckCtx<'_, 'p>,
-    matrix: &Matrix<'p>,
-    v: &PatStack<'p>,
-    witness_preference: ArmType,
-    is_under_guard: bool,
-    is_top_level: bool,
-) -> Usefulness<'p> {
-    let Matrix { patterns: rows, .. } = matrix;
-
-    // The base case. We are pattern-matching on () and the return value is
-    // based on whether our matrix has a row or not.
-    // NOTE: This could potentially be optimized by checking rows.is_empty()
-    // first and then, if v is non-empty, the return value is based on whether
-    // the type of the tuple we're checking is inhabited or not.
-    if v.is_empty() {
-        let ret = if rows.is_empty() {
-            Usefulness::new_useful(witness_preference)
-        } else {
-            Usefulness::new_not_useful(witness_preference)
-        };
-        return ret;
-    }
-
-    debug_assert!(rows.iter().all(|r| r.len() == v.len()));
-
-    let ty = v.head().ty();
-    let is_non_exhaustive = cx.is_foreign_non_exhaustive_enum(ty);
-    let pcx = PatCtxt { cx, ty, is_top_level, is_non_exhaustive };
-
-    // If the first pattern is an or-pattern, expand it.
-    let mut ret = Usefulness::new_not_useful(witness_preference);
-    if v.head().is_or_pat() {
-        // We try each or-pattern branch in turn.
-        let mut matrix = matrix.clone();
-        for v in v.expand_or_pat() {
-            let usefulness = is_useful(cx, &matrix, &v, witness_preference, is_under_guard, false);
-            ret.extend(usefulness);
-            // If pattern has a guard don't add it to the matrix.
-            if !is_under_guard {
-                // We push the already-seen patterns into the matrix in order to detect redundant
-                // branches like `Some(_) | Some(0)`.
-                matrix.push(v);
-            }
-        }
-    } else {
-        let v_ctor = v.head().ctor();
-
-        // FIXME: implement `overlapping_range_endpoints` lint
-
-        // We split the head constructor of `v`.
-        let split_ctors = v_ctor.split(pcx, matrix.heads().map(DeconstructedPat::ctor));
-        // For each constructor, we compute whether there's a value that starts with it that would
-        // witness the usefulness of `v`.
-        let start_matrix = matrix;
-        for ctor in split_ctors {
-            // We cache the result of `Fields::wildcards` because it is used a lot.
-            let spec_matrix = start_matrix.specialize_constructor(pcx, &ctor);
-            let v = v.pop_head_constructor(cx, &ctor);
-            let usefulness =
-                is_useful(cx, &spec_matrix, &v, witness_preference, is_under_guard, false);
-            let usefulness = usefulness.apply_constructor(pcx, start_matrix, &ctor);
-
-            // FIXME: implement `non_exhaustive_omitted_patterns` lint
-
-            ret.extend(usefulness);
-        }
-    };
-
-    if ret.is_useful() {
-        v.head().set_reachable();
-    }
-
-    ret
-}
-
-/// The arm of a match expression.
-#[derive(Clone, Copy)]
-pub(crate) struct MatchArm<'p> {
-    pub(crate) pat: &'p DeconstructedPat<'p>,
-    pub(crate) has_guard: bool,
-}
-
-/// Indicates whether or not a given arm is reachable.
-#[derive(Clone, Debug)]
-pub(crate) enum Reachability {
-    /// The arm is reachable. This additionally carries a set of or-pattern branches that have been
-    /// found to be unreachable despite the overall arm being reachable. Used only in the presence
-    /// of or-patterns, otherwise it stays empty.
-    // FIXME: store unreachable subpattern IDs
-    Reachable,
-    /// The arm is unreachable.
-    Unreachable,
-}
-
-/// The output of checking a match for exhaustiveness and arm reachability.
-pub(crate) struct UsefulnessReport<'p> {
-    /// For each arm of the input, whether that arm is reachable after the arms above it.
-    pub(crate) _arm_usefulness: Vec<(MatchArm<'p>, Reachability)>,
-    /// If the match is exhaustive, this is empty. If not, this contains witnesses for the lack of
-    /// exhaustiveness.
-    pub(crate) non_exhaustiveness_witnesses: Vec<DeconstructedPat<'p>>,
-}
-
-/// The entrypoint for the usefulness algorithm. Computes whether a match is exhaustive and which
-/// of its arms are reachable.
-///
-/// Note: the input patterns must have been lowered through
-/// `check_match::MatchVisitor::lower_pattern`.
-pub(crate) fn compute_match_usefulness<'p>(
-    cx: &MatchCheckCtx<'_, 'p>,
-    arms: &[MatchArm<'p>],
-    scrut_ty: &Ty,
-) -> UsefulnessReport<'p> {
-    let mut matrix = Matrix::empty();
-    let arm_usefulness = arms
-        .iter()
-        .copied()
-        .map(|arm| {
-            let v = PatStack::from_pattern(arm.pat);
-            is_useful(cx, &matrix, &v, RealArm, arm.has_guard, true);
-            if !arm.has_guard {
-                matrix.push(v);
-            }
-            let reachability = if arm.pat.is_reachable() {
-                Reachability::Reachable
-            } else {
-                Reachability::Unreachable
-            };
-            (arm, reachability)
-        })
-        .collect();
-
-    let wild_pattern = cx.pattern_arena.alloc(DeconstructedPat::wildcard(scrut_ty.clone()));
-    let v = PatStack::from_pattern(wild_pattern);
-    let usefulness = is_useful(cx, &matrix, &v, FakeExtraWildcard, false, true);
-    let non_exhaustiveness_witnesses = match usefulness {
-        WithWitnesses(pats) => pats.into_iter().map(Witness::single_pattern).collect(),
-        NoWitnesses { .. } => panic!("bug"),
-    };
-    UsefulnessReport { _arm_usefulness: arm_usefulness, non_exhaustiveness_witnesses }
-}
-
-pub(crate) mod helper {
-    // Copy-pasted from rust/compiler/rustc_data_structures/src/captures.rs
-    /// "Signaling" trait used in impl trait to tag lifetimes that you may
-    /// need to capture but don't really need for other reasons.
-    /// Basically a workaround; see [this comment] for details.
-    ///
-    /// [this comment]: https://github.com/rust-lang/rust/issues/34511#issuecomment-373423999
-    // FIXME(eddyb) false positive, the lifetime parameter is "phantom" but needed.
-    #[allow(unused_lifetimes)]
-    pub(crate) trait Captures<'a> {}
-
-    impl<'a, T: ?Sized> Captures<'a> for T {}
-}
diff --git a/crates/hir-ty/src/lib.rs b/crates/hir-ty/src/lib.rs
index 19052a18b19..8d180f98617 100644
--- a/crates/hir-ty/src/lib.rs
+++ b/crates/hir-ty/src/lib.rs
@@ -15,6 +15,9 @@ extern crate rustc_abi;
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_abi as rustc_abi;
 
+// No need to use the in-tree one.
+extern crate ra_ap_rustc_pattern_analysis as rustc_pattern_analysis;
+
 mod builder;
 mod chalk_db;
 mod chalk_ext;
diff --git a/crates/rust-analyzer/tests/slow-tests/tidy.rs b/crates/rust-analyzer/tests/slow-tests/tidy.rs
index db192cf8fe5..d3146ab7671 100644
--- a/crates/rust-analyzer/tests/slow-tests/tidy.rs
+++ b/crates/rust-analyzer/tests/slow-tests/tidy.rs
@@ -154,6 +154,7 @@ fn check_licenses() {
 Apache-2.0
 Apache-2.0 OR BSL-1.0
 Apache-2.0 OR MIT
+Apache-2.0 WITH LLVM-exception
 Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT
 Apache-2.0/MIT
 BSD-3-Clause