Rename is_disaligned to is_potentially_disaligned for better semantic clarity; Unified to ty::Array(element_ty, _) | ty::Slice(element_ty) => …;

Modify Chinese comments to English comments

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_disaligned<'tcx, L>(
+pub fn is_potentially_disaligned<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,
     typing_env: ty::TypingEnv<'tcx>,
@@ -73,21 +73,10 @@ where
 /// Try to determine the alignment of an array element type
 fn get_element_alignment<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Align> {
     match ty.kind() {
-        ty::Array(element_ty, _) => {
-            // For arrays, the alignment is the same as the element type
+        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,
-            }
-        }
-        ty::Slice(element_ty) => {
-            // For 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 };
+            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,
@@ -96,6 +85,7 @@ fn get_element_alignment<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Align>
         _ => None,
     }
 }
+
 pub fn is_within_packed<'tcx, L>(
     tcx: TyCtxt<'tcx>,
     local_decls: &L,

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_disaligned, is_within_packed};
+pub use self::alignment::{is_potentially_disaligned, 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_disaligned(tcx, body, typing_env, place) =>
+                    if util::is_potentially_disaligned(tcx, body, typing_env, place) =>
                 {
                     add_move_for_packed_drop(
                         tcx,

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -37,7 +37,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_disaligned(self.tcx, self.body, self.typing_env, *place)
+        if context.is_borrow() && util::is_potentially_disaligned(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-const-generic.rs

@@ -8,7 +8,7 @@ struct PascalString<const CAP: usize> {
 }
 
 fn bar<const CAP: usize>(s: &PascalString<CAP>) -> &str {
-    // 目标：这行不应触发 E0793
+    // Goal: this line should not trigger E0793
     std::str::from_utf8(&s.buf[0..s.len as usize]).unwrap()
 }