Add test cases to verify u8/i8 array fix

Author: hns1971

compiler/rustc_const_eval/src/util/alignment.rs

@@ -6,7 +6,7 @@ use tracing::debug;
 /// Returns `true` if this place is allowed to be less aligned
 /// than its containing struct (because it is within a packed
 /// struct).
-pub fn is_potentially_disaligned<'tcx, L>(
+pub fn is_potentially_misaligned<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,
     typing_env: ty::TypingEnv<'tcx>,
@@ -15,25 +15,16 @@ pub fn is_potentially_disaligned<'tcx, L>(
 where
     L: HasLocalDecls<'tcx>,
 {
-    debug!("is_disaligned({:?})", place);
+    debug!("is_potentially_misaligned({:?})", place);
     let Some(pack) = is_within_packed(tcx, local_decls, place) else {
-        debug!("is_disaligned({:?}) - not within packed", place);
+        debug!("is_potentially_misaligned({:?}) - not within packed", place);
         return false;
     };
 
     let ty = place.ty(local_decls, tcx).ty;
     let unsized_tail = || tcx.struct_tail_for_codegen(ty, typing_env);
 
-    // Try to normalize the type to resolve any generic parameters
-    let normalized_ty = match tcx.try_normalize_erasing_regions(typing_env, ty) {
-        Ok(normalized) => normalized,
-        Err(_) => {
-            // If normalization fails, fall back to the original type
-            ty
-        }
-    };
-
-    match tcx.layout_of(typing_env.as_query_input(normalized_ty)) {
+    match tcx.layout_of(typing_env.as_query_input(ty)) {
         Ok(layout) => {
             if layout.align.abi <= pack
                 && (layout.is_sized() || matches!(unsized_tail().kind(), ty::Slice(..) | ty::Str))
@@ -44,7 +35,7 @@ where
                 // just an approximation -- except when the unsized tail is a slice, where the alignment
                 // is fully determined by the type.
                 debug!(
-                    "is_disaligned({:?}) - align = {}, packed = {}; not disaligned",
+                    "is_potentially_misaligned({:?}) - align = {}, packed = {}; not disaligned",
                     place,
                     layout.align.abi.bytes(),
                     pack.bytes()
@@ -55,12 +46,12 @@ where
             }
         }
         Err(_) => {
-            // We cannot figure out the layout. This often happens with generic types.
-            // For const generic arrays like [u8; CAP], we can make a reasonable assumption
-            // about their alignment based on the element type.
+            // Soundness-critical: this may return false positives (reporting potential misalignment),
+            // but must not return false negatives. When layout is unavailable, we stay conservative
+            // except for arrays of u8/i8 whose ABI alignment is provably 1.
 
             // Try to determine alignment from the type structure
-            if let Some(element_align) = get_element_alignment(tcx, normalized_ty) {
+            if let Some(element_align) = get_element_alignment(tcx, ty) {
                 element_align > pack
             } else {
                 // If we still can't determine alignment, conservatively assume disaligned
@@ -71,16 +62,21 @@ where
 }
 
 /// Try to determine the alignment of an array element type
-fn get_element_alignment<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Align> {
+fn get_element_alignment<'tcx>(_tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Align> {
     match ty.kind() {
         ty::Array(element_ty, _) | ty::Slice(element_ty) => {
-            // For arrays and slices, the alignment is the same as the element type
-            let param_env = ty::ParamEnv::empty();
-            let typing_env =
-                ty::TypingEnv { typing_mode: ty::TypingMode::non_body_analysis(), param_env };
-            match tcx.layout_of(typing_env.as_query_input(*element_ty)) {
-                Ok(layout) => Some(layout.align.abi),
-                Err(_) => None,
+            // Only allow u8 and i8 arrays when layout computation fails
+            // Other types are conservatively assumed to be misaligned
+            match element_ty.kind() {
+                ty::Uint(ty::UintTy::U8) | ty::Int(ty::IntTy::I8) => {
+                    // For u8 and i8, we know their alignment is 1
+                    Some(Align::from_bytes(1).unwrap())
+                }
+                _ => {
+                    // For other types, we cannot safely determine alignment
+                    // Conservatively return None to indicate potential misalignment
+                    None
+                }
             }
         }
         _ => None,

compiler/rustc_const_eval/src/util/mod.rs

@@ -6,7 +6,7 @@ mod check_validity_requirement;
 mod compare_types;
 mod type_name;
 
-pub use self::alignment::{is_potentially_disaligned, is_within_packed};
+pub use self::alignment::{is_potentially_misaligned, is_within_packed};
 pub use self::check_validity_requirement::check_validity_requirement;
 pub(crate) use self::check_validity_requirement::validate_scalar_in_layout;
 pub use self::compare_types::{relate_types, sub_types};

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -51,7 +51,7 @@ impl<'tcx> crate::MirPass<'tcx> for AddMovesForPackedDrops {
 
             match terminator.kind {
                 TerminatorKind::Drop { place, .. }
-                    if util::is_potentially_disaligned(tcx, body, typing_env, place) =>
+                    if util::is_potentially_misaligned(tcx, body, typing_env, place) =>
                 {
                     add_move_for_packed_drop(
                         tcx,

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -38,7 +38,7 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
 
     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, _location: Location) {
         if context.is_borrow()
-            && util::is_potentially_disaligned(self.tcx, self.body, self.typing_env, *place)
+            && util::is_potentially_misaligned(self.tcx, self.body, self.typing_env, *place)
         {
             let def_id = self.body.source.instance.def_id();
             if let Some(impl_def_id) = self.tcx.impl_of_assoc(def_id)

tests/ui/packed/packed-array-i8-const-generic.rs

@@ -0,0 +1,19 @@
+//@ check-pass
+#![allow(dead_code)]
+
+#[repr(C, packed)]
+struct PascalStringI8<const CAP: usize> {
+    len: u8,
+    buf: [i8; CAP],
+}
+
+fn bar<const CAP: usize>(s: &PascalStringI8<CAP>) -> &[i8] {
+    // Goal: this line should not trigger E0793 for i8 arrays
+    &s.buf[0..s.len as usize]
+}
+
+fn main() {
+    let p = PascalStringI8::<10> { len: 3, buf: [1, 2, 3, 0, 0, 0, 0, 0, 0, 0] };
+    let s = bar(&p);
+    assert_eq!(s, &[1, 2, 3]);
+}