Stabilize offset_of_nested

compiler/rustc_error_codes/src/error_codes/E0795.md

@@ -3,7 +3,7 @@ Invalid argument for the `offset_of!` macro.
 Erroneous code example:
 
 ```compile_fail,E0795
-#![feature(offset_of_enum, offset_of_nested)]
+#![feature(offset_of_enum)]
 
 let x = std::mem::offset_of!(Option<u8>, Some);
 ```
@@ -16,7 +16,7 @@ The offset of the contained `u8` in the `Option<u8>` can be found by specifying
 the field name `0`:
 
 ```
-#![feature(offset_of_enum, offset_of_nested)]
+#![feature(offset_of_enum)]
 
 let x: usize = std::mem::offset_of!(Option<u8>, Some.0);
 ```

compiler/rustc_feature/src/accepted.rs

@@ -292,6 +292,8 @@ declare_features! (
     (accepted, non_exhaustive, "1.40.0", Some(44109)),
     /// Allows `foo.rs` as an alternative to `foo/mod.rs`.
     (accepted, non_modrs_mods, "1.30.0", Some(44660)),
+    /// Allows using multiple nested field accesses in offset_of!
+    (accepted, offset_of_nested, "CURRENT_RUSTC_VERSION", Some(120140)),
     /// Allows the use of or-patterns (e.g., `0 | 1`).
     (accepted, or_patterns, "1.53.0", Some(54883)),
     /// Allows using `+bundle,+whole-archive` link modifiers with native libs.

compiler/rustc_feature/src/unstable.rs

@@ -560,8 +560,6 @@ declare_features! (
     (unstable, object_safe_for_dispatch, "1.40.0", Some(43561)),
     /// Allows using enums in offset_of!
     (unstable, offset_of_enum, "1.75.0", Some(120141)),
-    /// Allows using multiple nested field accesses in offset_of!
-    (unstable, offset_of_nested, "1.77.0", Some(120140)),
     /// Allows using fields with slice type in offset_of!
     (unstable, offset_of_slice, "CURRENT_RUSTC_VERSION", Some(126151)),
     /// Allows using `#[optimize(X)]`.

compiler/rustc_hir_typeck/src/expr.rs

@@ -3338,18 +3338,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> Ty<'tcx> {
         let container = self.lower_ty(container).normalized;
 
-        if let Some(ident_2) = fields.get(1)
-            && !self.tcx.features().offset_of_nested
-        {
-            rustc_session::parse::feature_err(
-                &self.tcx.sess,
-                sym::offset_of_nested,
-                ident_2.span,
-                "only a single ident or integer is stable as the field in offset_of",
-            )
-            .emit();
-        }
-
         let mut field_indices = Vec::with_capacity(fields.len());
         let mut current_container = container;
         let mut fields = fields.into_iter();

library/core/src/lib.rs

@@ -107,6 +107,7 @@
 //
 // Library features:
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(offset_of_nested))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(char_indices_offset)]
@@ -172,7 +173,6 @@
 #![feature(isqrt)]
 #![feature(link_cfg)]
 #![feature(offset_of_enum)]
-#![feature(offset_of_nested)]
 #![feature(panic_internals)]
 #![feature(ptr_alignment_type)]
 #![feature(ptr_metadata)]

library/core/src/mem/mod.rs

@@ -1321,7 +1321,8 @@ impl<T> SizedTypeProperties for T {}
 /// # Examples
 ///
 /// ```
-/// #![feature(offset_of_enum, offset_of_nested)]
+/// # #![cfg_attr(bootstrap, feature(offset_of_nested))]
+/// #![feature(offset_of_enum)]
 ///
 /// use std::mem;
 /// #[repr(C)]

library/core/tests/lib.rs

@@ -1,6 +1,11 @@
+// tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(offset_of_nested))]
+#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
+#![cfg_attr(test, feature(cfg_match))]
 #![feature(alloc_layout_extra)]
 #![feature(array_chunks)]
 #![feature(array_ptr_get)]
+#![feature(array_try_from_fn)]
 #![feature(array_windows)]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
@@ -9,112 +14,109 @@
 #![feature(bigint_helper_methods)]
 #![feature(cell_update)]
 #![feature(clone_to_uninit)]
-#![feature(const_align_offset)]
 #![feature(const_align_of_val_raw)]
+#![feature(const_align_offset)]
+#![feature(const_array_from_ref)]
 #![feature(const_black_box)]
 #![feature(const_cell_into_inner)]
 #![feature(const_hash)]
 #![feature(const_heap)]
 #![feature(const_intrinsic_copy)]
+#![feature(const_ip)]
+#![feature(const_ipv4)]
+#![feature(const_ipv6)]
+#![feature(const_likely)]
 #![feature(const_maybe_uninit_as_mut_ptr)]
+#![feature(const_mut_refs)]
 #![feature(const_nonnull_new)]
+#![feature(const_option)]
+#![feature(const_option_ext)]
+#![feature(const_pin)]
 #![feature(const_pointer_is_aligned)]
 #![feature(const_ptr_as_ref)]
 #![feature(const_ptr_write)]
+#![feature(const_result)]
+#![feature(const_slice_from_ref)]
 #![feature(const_three_way_compare)]
 #![feature(const_trait_impl)]
-#![feature(const_likely)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]
 #![feature(dec2flt)]
-#![feature(duration_consts_float)]
 #![feature(duration_constants)]
 #![feature(duration_constructors)]
+#![feature(duration_consts_float)]
+#![feature(error_generic_member_access)]
 #![feature(exact_size_is_empty)]
 #![feature(extern_types)]
-#![feature(freeze)]
+#![feature(float_minimum_maximum)]
 #![feature(flt2dec)]
 #![feature(fmt_internals)]
-#![feature(float_minimum_maximum)]
+#![feature(freeze)]
 #![feature(future_join)]
 #![feature(generic_assert_internals)]
-#![feature(array_try_from_fn)]
+#![feature(get_many_mut)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
-#![feature(try_find)]
-#![feature(layout_for_ptr)]
-#![feature(pattern)]
-#![feature(slice_take)]
-#![feature(slice_from_ptr_range)]
-#![feature(slice_split_once)]
-#![feature(split_as_slice)]
-#![feature(maybe_uninit_fill)]
-#![feature(maybe_uninit_write_slice)]
-#![feature(maybe_uninit_uninit_array_transpose)]
-#![feature(min_specialization)]
-#![feature(noop_waker)]
-#![feature(numfmt)]
-#![feature(num_midpoint)]
-#![feature(offset_of_nested)]
-#![feature(isqrt)]
-#![feature(unsigned_is_multiple_of)]
-#![feature(step_trait)]
-#![feature(str_internals)]
-#![feature(std_internals)]
-#![feature(test)]
-#![feature(trusted_len)]
-#![feature(try_blocks)]
-#![feature(try_trait_v2)]
-#![feature(slice_internals)]
-#![feature(slice_partition_dedup)]
+#![feature(int_roundings)]
 #![feature(ip)]
+#![feature(is_ascii_octdigit)]
+#![feature(isqrt)]
 #![feature(iter_advance_by)]
 #![feature(iter_array_chunks)]
 #![feature(iter_chain)]
 #![feature(iter_collect_into)]
-#![feature(iter_partition_in_place)]
 #![feature(iter_intersperse)]
 #![feature(iter_is_partitioned)]
+#![feature(iter_map_windows)]
 #![feature(iter_next_chunk)]
 #![feature(iter_order_by)]
+#![feature(iter_partition_in_place)]
 #![feature(iter_repeat_n)]
 #![feature(iterator_try_collect)]
 #![feature(iterator_try_reduce)]
-#![feature(const_ip)]
-#![feature(const_ipv4)]
-#![feature(const_ipv6)]
-#![feature(const_mut_refs)]
-#![feature(const_pin)]
+#![feature(layout_for_ptr)]
+#![feature(maybe_uninit_fill)]
+#![feature(maybe_uninit_uninit_array_transpose)]
+#![feature(maybe_uninit_write_slice)]
+#![feature(min_specialization)]
 #![feature(never_type)]
-#![feature(unwrap_infallible)]
+#![feature(noop_waker)]
+#![feature(num_midpoint)]
+#![feature(numfmt)]
+#![feature(pattern)]
 #![feature(pointer_is_aligned_to)]
 #![feature(portable_simd)]
 #![feature(ptr_metadata)]
-#![feature(unsized_tuple_coercion)]
-#![feature(const_option)]
-#![feature(const_option_ext)]
-#![feature(const_result)]
-#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
-#![cfg_attr(test, feature(cfg_match))]
-#![feature(int_roundings)]
+#![feature(slice_from_ptr_range)]
+#![feature(slice_internals)]
+#![feature(slice_partition_dedup)]
+#![feature(slice_split_once)]
+#![feature(slice_take)]
 #![feature(split_array)]
+#![feature(split_as_slice)]
+#![feature(std_internals)]
+#![feature(step_trait)]
+#![feature(str_internals)]
 #![feature(strict_provenance)]
 #![feature(strict_provenance_atomic_ptr)]
+#![feature(test)]
+#![feature(trait_upcasting)]
+#![feature(trusted_len)]
 #![feature(trusted_random_access)]
+#![feature(try_blocks)]
+#![feature(try_find)]
+#![feature(try_trait_v2)]
+#![feature(unsigned_is_multiple_of)]
 #![feature(unsize)]
-#![feature(const_array_from_ref)]
-#![feature(const_slice_from_ref)]
+#![feature(unsized_tuple_coercion)]
+#![feature(unwrap_infallible)]
 #![feature(waker_getters)]
-#![feature(error_generic_member_access)]
-#![feature(trait_upcasting)]
-#![feature(is_ascii_octdigit)]
-#![feature(get_many_mut)]
-#![feature(iter_map_windows)]
+// tidy-alphabetical-end
 #![allow(internal_features)]
-#![deny(unsafe_op_in_unsafe_fn)]
 #![deny(fuzzy_provenance_casts)]
+#![deny(unsafe_op_in_unsafe_fn)]
 
 mod alloc;
 mod any;

tests/mir-opt/const_prop/offset_of.rs

@@ -2,7 +2,7 @@
 //@ test-mir-pass: GVN
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 
-#![feature(offset_of_enum, offset_of_nested)]
+#![feature(offset_of_enum)]
 
 use std::marker::PhantomData;
 use std::mem::offset_of;

tests/mir-opt/dataflow-const-prop/offset_of.rs

@@ -1,8 +1,6 @@
 //@ test-mir-pass: DataflowConstProp
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 
-#![feature(offset_of_nested)]
-
 use std::marker::PhantomData;
 use std::mem::offset_of;
 

tests/ui/feature-gates/feature-gate-offset-of-enum.rs

@@ -1,5 +1,3 @@
-#![feature(offset_of_nested)]
-
 use std::mem::offset_of;
 
 enum Alpha {

tests/ui/feature-gates/feature-gate-offset-of-enum.stderr

@@ -1,5 +1,5 @@
 error[E0573]: expected type, found variant `Alpha::One`
-  --> $DIR/feature-gate-offset-of-enum.rs:11:16
+  --> $DIR/feature-gate-offset-of-enum.rs:9:16
    |
 LL |     offset_of!(Alpha::One, 0);
    |                ^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     offset_of!(Alpha::One, 0);
    |                help: try using the variant's enum: `Alpha`
 
 error[E0658]: using enums in offset_of is experimental
-  --> $DIR/feature-gate-offset-of-enum.rs:12:23
+  --> $DIR/feature-gate-offset-of-enum.rs:10:23
    |
 LL |     offset_of!(Alpha, One);
    |                       ^^^
@@ -18,13 +18,13 @@ LL |     offset_of!(Alpha, One);
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0795]: `One` is an enum variant; expected field at end of `offset_of`
-  --> $DIR/feature-gate-offset-of-enum.rs:12:23
+  --> $DIR/feature-gate-offset-of-enum.rs:10:23
    |
 LL |     offset_of!(Alpha, One);
    |                       ^^^ enum variant
 
 error[E0658]: using enums in offset_of is experimental
-  --> $DIR/feature-gate-offset-of-enum.rs:14:23
+  --> $DIR/feature-gate-offset-of-enum.rs:12:23
    |
 LL |     offset_of!(Alpha, Two.0);
    |                       ^^^