More changes for splitting exhaustiveness into a crate

[iDawer]

This threads bug! macro via Context trait and pattern allocations via an auxiliary trait.

The Context trait has received for<'p> Alloc<'p, &'p Self, Cx = Self> bound. I don't know if this is the best way to give users an ability to choose an arena implementation. I was striving to not clutter Context trait with 'p lifetime.

This PR targets Nadrieril:split-exhaustiveness-into-crate branch. Keeping it just for cherry picking commits that make sense to you

[iDawer]

Another thing I think could be an improvement:

In RA Ty struct is Clone but not Copy. Could we make Context::Ty bound more general with Clone?

[iDawer]

Played with Alloc a bit and found a possible tweak:

remove `Cx` associated type

diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 379446367..7810b28ee 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -1249,18 +1249,17 @@ fn span_bug(span: Option<Self::Span>, args: fmt::Arguments<'_>) -> ! {
 }
 
 impl<'p, 'tcx> usefulness::Alloc<'p, &'p Self> for MatchCheckCtxt<'tcx> {
-    type Cx = Self;
     type PatternArena = TypedArena<DeconstructedPat<'p, Self>>;
 
     fn alloc_pat(
-        arena: &'p Self::PatternArena,
+        arena: &'p usefulness::PatternArena<'p, Self>,
         pat: DeconstructedPat<'p, Self>,
     ) -> &'p DeconstructedPat<'p, Self> {
         arena.alloc(pat)
     }
 
     fn alloc_pats_from_iter(
-        arena: &'p Self::PatternArena,
+        arena: &'p usefulness::PatternArena<'p, Self>,
         pats: impl IntoIterator<Item = DeconstructedPat<'p, Self>>,
     ) -> &'p [DeconstructedPat<'p, Self>] {
         arena.alloc_from_iter(pats)
diff --git a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs
index c147eeeeb..c292fb9a9 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/usefulness.rs
@@ -302,10 +302,10 @@ macro_rules! bug {
 /// The `Copy` and `Debug` bounds are not actually used, but are needed because derived impls add
 /// extra useless bounds on `Cx`.
 ///
-/// In `for<'p> Alloc<'p, &'p Self, Cx = Self>`, `&'p Self` is special here: it implies `Self: 'p`.
+/// In `for<'p> Alloc<'p, &'p Self>`, `&'p Self` is special here: it implies `Self: 'p`.
 /// This is crucial for implementors that contain references, say `'tcx`, to be able to implement
 /// `Alloc` without an explicit bounds to the HRTB lifetime (`'tcx: 'p`).
-pub(crate) trait Context: Debug + Copy + for<'p> Alloc<'p, &'p Self, Cx = Self> {
+pub(crate) trait Context: Debug + Copy + for<'p> Alloc<'p, &'p Self> {
     type Ty: Debug + Copy;
     type TyList: Debug + Clone;
     type TyListIter: Iterator<Item = Self::Ty>;
@@ -364,23 +364,28 @@ fn list_variant_nonhidden_fields(
 }
 
 pub(crate) trait Alloc<'p, L> {
-    type Cx: Context;
     type PatternArena;
 
     fn alloc_pat(
-        arena: &'p Self::PatternArena,
-        pat: DeconstructedPat<'p, Self::Cx>,
-    ) -> &'p DeconstructedPat<'p, Self::Cx>;
+        arena: &'p PatternArena<'p, Self>,
+        pat: DeconstructedPat<'p, Self>,
+    ) -> &'p DeconstructedPat<'p, Self>
+    where
+        Self: Context;
 
     fn alloc_pats_from_iter(
-        arena: &'p Self::PatternArena,
-        pats: impl IntoIterator<Item = DeconstructedPat<'p, Self::Cx>>,
-    ) -> &'p [DeconstructedPat<'p, Self::Cx>];
+        arena: &'p PatternArena<'p, Self>,
+        pats: impl IntoIterator<Item = DeconstructedPat<'p, Self>>,
+    ) -> &'p [DeconstructedPat<'p, Self>]
+    where
+        Self: Context;
 }
 
+pub(crate) type PatternArena<'p, Cx> = <Cx as Alloc<'p, &'p Cx>>::PatternArena;
+
 pub(crate) struct UsefulnessCtxt<'p, Cx: Context> {
     pub(crate) cx: Cx,
-    pub(crate) pattern_arena: &'p <Cx as Alloc<'p, &'p Cx>>::PatternArena,
+    pub(crate) pattern_arena: &'p PatternArena<'p, Cx>,
 }
 
 #[derive(Copy, Clone)]

The downside is the Alloc impls have to use projections instead of just Self::PatternArena or concrete type

[Nadrieril]

I'm rebooting the effort here: rust-lang#118842