Fully destructure slice and array constants into patterns

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

@@ -820,7 +820,11 @@ enum Constructor<'tcx> {
     Single,
     /// Enum variants.
     Variant(DefId),
-    /// String literals
+    /// String literals. These have their own variant, because they behave essentially like
+    /// `&[u8]`, but there's no way to pattern match on parts of strings. So we could convert them
+    /// to slice constructors, but then we'd have to special case other code sites to not treat them
+    /// *exactly* like slice constructors. It seems simpler overall to just give them their own
+    /// variant.
     Str(&'tcx ty::Const<'tcx>),
     /// Ranges of integer literal values (`2`, `2..=5` or `2..5`).
     IntRange(IntRange<'tcx>),

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

@@ -158,6 +158,9 @@ crate enum PatKind<'tcx> {
         subpattern: Pat<'tcx>,
     },
 
+    /// Opaque constant. This will be treated as a single, but unknown value.
+    /// Except for `&str`, which will be handled as a string pattern and thus exhaustiveness
+    /// checking will detect if you use the same string twice in different patterns.
     Constant {
         value: &'tcx ty::Const<'tcx>,
     },