Rollup merge of #155340 - oli-obk:size-skeleton-pat-tys, r=mati865

Handle nonnull pattern types in size skeleton

The original comment was correct, the size is always the same, but we have more information now. In theory there was an additional bug that would have allowed transmuting things of different sizes, but I don't see how that would have been actually doable as the `tail` types would always have differed.

fixes #155330

Author: matthiaskrgr

compiler/rustc_middle/src/ty/layout.rs

@@ -508,8 +508,21 @@ impl<'tcx> SizeSkeleton<'tcx> {
                 }
             }
 
-            // Pattern types are always the same size as their base.
-            ty::Pat(base, _) => SizeSkeleton::compute(base, tcx, typing_env),
+            ty::Pat(base, pat) => {
+                // Pattern types are always the same size as their base.
+                let base = SizeSkeleton::compute(base, tcx, typing_env);
+                match *pat {
+                    ty::PatternKind::Range { .. } | ty::PatternKind::Or(_) => base,
+                    // But in the case of `!null` patterns we need to note that in the
+                    // raw pointer.
+                    ty::PatternKind::NotNull => match base? {
+                        SizeSkeleton::Known(..) | SizeSkeleton::Generic(_) => base,
+                        SizeSkeleton::Pointer { non_zero: _, tail } => {
+                            Ok(SizeSkeleton::Pointer { non_zero: true, tail })
+                        }
+                    },
+                }
+            }
 
             _ => Err(err),
         }

tests/ui/transmute/raw-ptr-non-null.rs

@@ -0,0 +1,11 @@
+//! After the use of pattern types inside `NonNull`,
+//! transmuting between a niche optimized enum wrapping a
+//! generic `NonNull` and raw pointers stopped working.
+//@ check-pass
+
+use std::ptr::NonNull;
+pub const fn is_null<'a, T: ?Sized>(ptr: *const T) -> bool {
+    unsafe { matches!(core::mem::transmute::<*const T, Option<NonNull<T>>>(ptr), None) }
+}
+
+fn main() {}