Handle ty::Opaque correctly

compiler/rustc_mir_build/src/thir/pattern/usefulness.rs

@@ -883,7 +883,22 @@ impl<'p, 'tcx> PatternColumn<'p, 'tcx> {
         self.patterns.is_empty()
     }
     fn head_ty(&self) -> Option<Ty<'tcx>> {
-        self.patterns.get(0).map(|p| p.ty())
+        if self.patterns.len() == 0 {
+            return None;
+        }
+        // If the type is opaque and it is revealed anywhere in the column, we take the revealed
+        // version. Otherwise we could encounter constructors for the revealed type and crash.
+        let is_opaque = |ty: Ty<'tcx>| matches!(ty.kind(), ty::Alias(ty::Opaque, ..));
+        let first_ty = self.patterns[0].ty();
+        if is_opaque(first_ty) {
+            for pat in &self.patterns {
+                let ty = pat.ty();
+                if !is_opaque(ty) {
+                    return Some(ty);
+                }
+            }
+        }
+        Some(first_ty)
     }
 
     fn analyze_ctors(&self, pcx: &PatCtxt<'_, 'p, 'tcx>) -> SplitConstructorSet<'tcx> {

tests/ui/type-alias-impl-trait/issue-96572-unconstrained.rs

@@ -26,11 +26,9 @@ fn upvar() {
 fn enum_upvar() {
     type T = impl Copy;
     let foo: T = Some((1u32, 2u32));
-    let x = move || {
+    let x = move || match foo {
-        match foo {
+        None => (),
-            None => (),
+        Some((a, b)) => (),
-            Some((a, b)) => (),
-        }
     };
 }
 
@@ -63,6 +61,19 @@ mod only_pattern {
             None => {}
         }
     }
+
+    type V = impl Copy;
+
+    fn baz(baz: Option<V>) {
+        match baz {
+            _ => {}
+            Some((mut x, mut y)) => {
+                x = 42;
+                y = "foo";
+            }
+            None => {}
+        }
+    }
 }
 
 mod only_pattern_rpit {
@@ -71,11 +82,7 @@ mod only_pattern_rpit {
         let (mut x, mut y) = foo(false);
         x = 42;
         y = "foo";
-        if b {
+        if b { panic!() } else { foo(true) }
-            panic!()
-        } else {
-            foo(true)
-        }
     }
 
     fn bar(b: bool) -> Option<impl Copy> {