remove unaligned & unsized field support from lib & their lang items

BennoLossin · BennoLossin · commit d05a18493d61 · 2025-09-19T12:19:05.000+02:00
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -638,7 +638,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 rustc_apfloat::Round::NearestTiesToEven,
             )?,
 
-            sym::unaligned_field_offset => self.unaligned_field_offset(instance, dest)?,
+            sym::field_offset => self.field_offset(instance, dest)?,
 
             // Unsupported intrinsic: skip the return_to_block below.
             _ => return interp_ok(false),
@@ -649,7 +649,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(true)
     }
 
-    fn unaligned_field_offset(
+    fn field_offset(
         &mut self,
         instance: ty::Instance<'tcx>,
         dest: &PlaceTy<'tcx, M::Provenance>,
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
@@ -442,11 +442,10 @@ language_item_table! {
     Reborrow,                sym::reborrow,            reborrow,                   Target::Trait,          GenericRequirement::Exact(0);
 
     // Experimental lang items for field projections.
-    Field,                          sym::Field,                         field_trait,                      Target::Trait,                                        GenericRequirement::None;
-    UnalignedField,                 sym::UnalignedField,                unaligned_field_trait,            Target::Trait,                                        GenericRequirement::None;
-    UnalignedFieldBase,             sym::UnalignedFieldBase,            unaligned_field_base,             Target::AssocTy,                                      GenericRequirement::None;
-    UnalignedFieldType,             sym::UnalignedFieldType,            unaligned_field_type,             Target::AssocTy,                                      GenericRequirement::None;
-    UnalignedFieldOFFSET,           sym::UnalignedFieldOFFSET,          unaligned_field_offset,           Target::AssocConst,                                   GenericRequirement::None;
+    Field,                 sym::Field,                field_trait,            Target::Trait,               GenericRequirement::None;
+    FieldBase,             sym::FieldBase,            field_base,             Target::AssocTy,             GenericRequirement::None;
+    FieldType,             sym::FieldType,            field_type,             Target::AssocTy,             GenericRequirement::None;
+    FieldOffset,           sym::FieldOffset,          field_offset,           Target::AssocConst,          GenericRequirement::None;
 }
 
 /// The requirement imposed on the generics of a lang item
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -141,7 +141,7 @@ fn intrinsic_operation_unsafety(tcx: TyCtxt<'_>, intrinsic_id: LocalDefId) -> hi
         | sym::prefetch_read_instruction
         | sym::prefetch_write_instruction
         | sym::const_eval_select
-        | sym::unaligned_field_offset => hir::Safety::Safe,
+        | sym::field_offset => hir::Safety::Safe,
         _ => hir::Safety::Unsafe,
     };
 
@@ -674,7 +674,7 @@ pub(crate) fn check_intrinsic_type(
         | sym::atomic_xor => (2, 1, vec![Ty::new_mut_ptr(tcx, param(0)), param(1)], param(0)),
         sym::atomic_fence | sym::atomic_singlethreadfence => (0, 1, Vec::new(), tcx.types.unit),
 
-        sym::unaligned_field_offset => (1, 0, Vec::new(), tcx.types.usize),
+        sym::field_offset => (1, 0, Vec::new(), tcx.types.usize),
 
         other => {
             tcx.dcx().emit_err(UnrecognizedIntrinsicFunction { span, name: other });
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -852,7 +852,6 @@ bidirectional_lang_item_map! {
     Sized,
     TransmuteTrait,
     Tuple,
-    UnalignedField,
     Unpin,
     Unsize,
 // tidy-alphabetical-end
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -234,6 +234,9 @@ symbols! {
         Err,
         Error,
         Field,
+        FieldBase,
+        FieldOffset,
+        FieldType,
         File,
         FileType,
         FmtArgumentsNew,
@@ -379,10 +382,6 @@ symbols! {
         Ty,
         TyCtxt,
         TyKind,
-        UnalignedField,
-        UnalignedFieldBase,
-        UnalignedFieldOFFSET,
-        UnalignedFieldType,
         Unknown,
         Unsize,
         UnsizedConstParamTy,
@@ -1041,6 +1040,7 @@ symbols! {
         field,
         field_init_shorthand,
         field_of,
+        field_offset,
         field_projections,
         file,
         file_options,
@@ -2289,7 +2289,6 @@ symbols! {
         u128_legacy_fn_min_value,
         u128_legacy_mod,
         ub_checks,
-        unaligned_field_offset,
         unaligned_volatile_load,
         unaligned_volatile_store,
         unboxed_closures,
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -997,8 +997,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                         | LangItem::AsyncFn
                         | LangItem::AsyncFnMut
                         | LangItem::AsyncFnOnce
-                        | LangItem::Field
-                        | LangItem::UnalignedField,
+                        | LangItem::Field,
                     ) => true,
                     Some(LangItem::AsyncFnKindHelper) => {
                         // FIXME(async_closures): Validity constraints here could be cleaned up.
@@ -1555,16 +1554,16 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
             }
         });
         (metadata_ty.into(), obligations)
-    } else if tcx.is_lang_item(trait_def_id, LangItem::UnalignedField) {
+    } else if tcx.is_lang_item(trait_def_id, LangItem::Field) {
         let &ty::Field(container, field_path) = self_ty.kind() else {
-            bug!("only `field_of!()` can implement `UnalignedField`")
+            bug!("only `field_of!()` can implement `Field`")
         };
-        if tcx.is_lang_item(item_def_id, LangItem::UnalignedFieldBase) {
+        if tcx.is_lang_item(item_def_id, LangItem::FieldBase) {
             (container.into(), PredicateObligations::new())
-        } else if tcx.is_lang_item(item_def_id, LangItem::UnalignedFieldType) {
+        } else if tcx.is_lang_item(item_def_id, LangItem::FieldType) {
             (field_path.field_ty(tcx, container).into(), PredicateObligations::new())
         } else {
-            bug!("unexpected associated type {:?} in `UnalignedField`", obligation.predicate);
+            bug!("unexpected associated type {:?} in `Field`", obligation.predicate);
         }
     } else {
         bug!("unexpected builtin trait with associated type: {:?}", obligation.predicate);
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -131,12 +131,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Some(LangItem::Field) => {
                     self.assemble_builtin_candidates_for_field(obligation, &mut candidates);
                 }
-                Some(LangItem::UnalignedField) => {
-                    self.assemble_builtin_candidates_for_unaligned_field(
-                        obligation,
-                        &mut candidates,
-                    );
-                }
                 _ => {
                     // We re-match here for traits that can have both builtin impls and user written impls.
                     // After the builtin impls we need to also add user written impls, which we do not want to
@@ -1476,15 +1470,4 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             _ => {}
         }
     }
-
-    fn assemble_builtin_candidates_for_unaligned_field(
-        &mut self,
-        obligation: &PolyTraitObligation<'tcx>,
-        candidates: &mut SelectionCandidateSet<'tcx>,
-    ) {
-        match obligation.predicate.self_ty().skip_binder().kind() {
-            ty::Field(_, _) => candidates.vec.push(BuiltinCandidate),
-            _ => {}
-        }
-    }
 }
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -283,8 +283,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | LangItem::PointeeTrait
                 | LangItem::Tuple
                 | LangItem::Unpin
-                | LangItem::Field
-                | LangItem::UnalignedField,
+                | LangItem::Field,
             ) => ty::Binder::dummy(vec![]),
             other => bug!("unexpected builtin trait {trait_def:?} ({other:?})"),
         };
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
@@ -256,16 +256,16 @@ fn resolve_associated_item<'tcx>(
             }
         }
         traits::ImplSource::Builtin(BuiltinImplSource::Misc | BuiltinImplSource::Trivial, _) => {
-            if tcx.is_lang_item(trait_ref.def_id, LangItem::UnalignedField) {
-                if tcx.is_lang_item(trait_item_id, LangItem::UnalignedFieldOFFSET) {
+            if tcx.is_lang_item(trait_ref.def_id, LangItem::Field) {
+                if tcx.is_lang_item(trait_item_id, LangItem::FieldOffset) {
                     let self_ty = trait_ref.self_ty();
                     match self_ty.kind() {
                         ty::Field(_, _) => {}
                         _ => bug!("expected field representing type, found {self_ty}"),
                     }
                     Some(Instance {
                         def: ty::InstanceKind::Item(
-                            tcx.lang_items().get(LangItem::UnalignedFieldOFFSET).unwrap(),
+                            tcx.lang_items().get(LangItem::FieldOffset).unwrap(),
                         ),
                         args: rcvr_args,
                     })
diff --git a/compiler/rustc_type_ir/src/lang_items.rs b/compiler/rustc_type_ir/src/lang_items.rs
@@ -50,7 +50,6 @@ pub enum SolverTraitLangItem {
     Sized,
     TransmuteTrait,
     Tuple,
-    UnalignedField,
     Unpin,
     Unsize,
     // tidy-alphabetical-end
diff --git a/library/core/src/field.rs b/library/core/src/field.rs
@@ -1,41 +1,29 @@
 //! Field Reflection
 
-/// Type representing a (possibly unaligned) field of a `struct` or tuple.
+/// Type representing a field of a `struct` or tuple.
 ///
 /// # Safety
 ///
 /// Given a valid value of type `Self::Base`, there exists a valid value of type `Self::Type` at
 /// byte offset `OFFSET`.
-#[lang = "UnalignedField"]
+#[lang = "Field"]
 #[unstable(feature = "field_projections", issue = "145383")]
 #[rustc_deny_explicit_impl]
 #[rustc_do_not_implement_via_object]
-pub unsafe trait UnalignedField: Sized {
+pub unsafe trait Field: Sized {
     /// The type of the base where this field exists in.
-    #[lang = "UnalignedFieldBase"]
-    type Base: ?Sized;
+    #[lang = "FieldBase"]
+    type Base;
 
     /// The type of the field.
-    #[lang = "UnalignedFieldType"]
-    type Type: ?Sized;
+    #[lang = "FieldType"]
+    type Type;
 
     /// The offset of the field in bytes.
-    #[lang = "UnalignedFieldOFFSET"]
-    const OFFSET: usize = crate::intrinsics::unaligned_field_offset::<Self>();
+    #[lang = "FieldOffset"]
+    const OFFSET: usize = crate::intrinsics::field_offset::<Self>();
 }
 
-/// Type representing an aligned field of a `struct` or tuple.
-///
-/// # Safety
-///
-/// Given a well-aligned value of type `Self::Base`, the field at `Self::OFFSET` of type
-/// `Self::Type` is well-aligned.
-#[lang = "Field"]
-#[unstable(feature = "field_projections", issue = "145383")]
-#[rustc_deny_explicit_impl]
-#[rustc_do_not_implement_via_object]
-pub unsafe trait Field: UnalignedField {}
-
 /// Expands to the field representing type of the given field.
 ///
 /// The container type may be a `struct` or a tuple.
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
@@ -3326,4 +3326,4 @@ pub unsafe fn va_end(ap: &mut VaListImpl<'_>);
 #[rustc_intrinsic]
 #[unstable(feature = "field_projections", issue = "145383")]
 #[rustc_const_unstable(feature = "field_projections", issue = "145383")]
-pub const fn unaligned_field_offset<F: crate::field::UnalignedField>() -> usize;
+pub const fn field_offset<F: crate::field::Field>() -> usize;
diff --git a/library/std/tests/field-projections-basic.rs b/library/std/tests/field-projections-basic.rs
@@ -3,7 +3,7 @@
 #![allow(incomplete_features)]
 #![feature(field_projections)]
 
-use std::field::{Field, UnalignedField, field_of};
+use std::field::{Field, field_of};
 use std::mem::offset_of;
 use std::ptr;
 
diff --git a/tests/ui/field_projections/deny-drop-impl.rs b/tests/ui/field_projections/deny-drop-impl.rs
@@ -3,7 +3,7 @@
 #![allow(incomplete_features)]
 #![feature(field_projections)]
 
-use std::field::{Field, UnalignedField, field_of};
+use std::field::{Field, field_of};
 
 pub struct MyStruct(());
 
diff --git a/tests/ui/field_projections/deny-manual-impl.rs b/tests/ui/field_projections/deny-manual-impl.rs
@@ -3,18 +3,16 @@
 #![allow(incomplete_features)]
 #![feature(field_projections)]
 
-use std::field::{Field, UnalignedField, field_of};
+use std::field::Field;
 
 #[repr(packed)]
 pub struct MyStruct(usize);
 
-unsafe impl UnalignedField for MyStruct {
-    //~^ ERROR: explicit impls for the `UnalignedField` trait are not permitted [E0322]
+unsafe impl Field for MyStruct {
+    //~^ ERROR: explicit impls for the `Field` trait are not permitted [E0322]
     type Base = ();
     type Type = ();
     const OFFSET: usize = 0;
 }
 
-unsafe impl Field for field_of!(MyStruct, 0) {} //~ ERROR: explicit impls for the `Field` trait are not permitted [E0322]
-
 fn main() {}
diff --git a/tests/ui/field_projections/deny-private-field.rs b/tests/ui/field_projections/deny-private-field.rs
@@ -3,7 +3,7 @@
 #![allow(incomplete_features)]
 #![feature(field_projections)]
 
-use std::field::{Field, UnalignedField, field_of};
+use std::field::{Field, field_of};
 
 mod foo {
     pub struct A {
diff --git a/tests/ui/field_projections/enum.rs b/tests/ui/field_projections/enum.rs
@@ -4,7 +4,7 @@
 #![allow(incomplete_features)]
 #![feature(field_projections)]
 
-use std::field::{UnalignedField, field_of};
+use std::field::{Field, field_of};
 
 pub enum Foo {
     A { a: isize, b: usize },
diff --git a/tests/ui/field_projections/union.rs b/tests/ui/field_projections/union.rs
@@ -4,7 +4,7 @@
 #![allow(incomplete_features, dead_code)]
 #![feature(field_projections)]
 
-use std::field::{UnalignedField, field_of};
+use std::field::{Field, field_of};
 
 pub union Foo {
     a: isize,
