refactor to use &raw mut (alternative version)

Cargo.toml

@@ -37,6 +37,7 @@ macrotest = "1.0"
 prettyplease = { version = "0.2.37", features = ["verbatim"] }
 
 [lints.rust]
+stable_features = "allow"
 non_ascii_idents = "deny"
 unexpected_cfgs = { level = "warn", check-cfg = [
     'cfg(UI_TESTS)',

README.md

@@ -160,7 +160,6 @@ actually does the initialization in the correct way. Here are the things to look
 ```rust
 use pin_init::{pin_data, pinned_drop, PinInit, PinnedDrop, pin_init_from_closure};
 use core::{
-    ptr::addr_of_mut,
     marker::PhantomPinned,
     cell::UnsafeCell,
     pin::Pin,
@@ -199,7 +198,7 @@ impl RawFoo {
         unsafe {
             pin_init_from_closure(move |slot: *mut Self| {
                 // `slot` contains uninit memory, avoid creating a reference.
-                let foo = addr_of_mut!((*slot).foo);
+                let foo = &raw mut (*slot).foo;
                 let foo = UnsafeCell::raw_get(foo).cast::<bindings::foo>();
 
                 // Initialize the `foo`

build.rs

@@ -1,18 +1,21 @@
-use rustc_version::{version, Version};
+use rustc_version::{version_meta, Channel, Version};
 
 fn main() {
-    println!("cargo::rustc-check-cfg=cfg(RUSTC_LINT_REASONS_IS_STABLE)");
-    println!("cargo::rustc-check-cfg=cfg(RUSTC_NEW_UNINIT_IS_STABLE)");
+    println!("cargo::rustc-check-cfg=cfg(RUSTC_USE_FEATURE)");
     println!("cargo::rustc-check-cfg=cfg(CONFIG_RUSTC_HAS_UNSAFE_PINNED)");
-    if version().unwrap() >= Version::parse("1.81.0").unwrap()
-        || version().unwrap() >= Version::parse("1.81.0-nightly").unwrap()
-    {
-        println!("cargo:rustc-cfg=RUSTC_LINT_REASONS_IS_STABLE");
-    }
-    if version().unwrap() >= Version::parse("1.82.0").unwrap() {
-        println!("cargo:rustc-cfg=RUSTC_NEW_UNINIT_IS_STABLE");
+    println!("cargo:rustc-check-cfg=cfg(RUSTC_RAW_REF_OP_IS_STABLE)");
+
+    let meta = version_meta().unwrap();
+
+    let use_feature = meta.channel == Channel::Nightly || std::env::var("RUSTC_BOOTSTRAP").is_ok();
+    if use_feature {
+        println!("cargo:rustc-cfg=RUSTC_USE_FEATURE");
     }
-    if version().unwrap() >= Version::parse("1.89.0-nightly").unwrap() {
+
+    if meta.semver >= Version::parse("1.89.0-nightly").unwrap() && use_feature {
         println!("cargo:rustc-cfg=CONFIG_RUSTC_HAS_UNSAFE_PINNED");
     }
+    if meta.semver >= Version::parse("1.82.0").unwrap() && use_feature {
+        println!("cargo:rustc-cfg=RUSTC_RAW_REF_OP_IS_STABLE");
+    }
 }

examples/big_struct_in_place.rs

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+#![cfg_attr(not(RUSTC_RAW_REF_OP_IS_STABLE), feature(raw_ref_op))]
+
 use pin_init::*;
 
 // Struct with size over 1GiB

examples/linked_list.rs

@@ -2,7 +2,8 @@
 
 #![allow(clippy::undocumented_unsafe_blocks)]
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
 use core::{
     cell::Cell,

examples/mutex.rs

@@ -2,7 +2,8 @@
 
 #![allow(clippy::undocumented_unsafe_blocks)]
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 #![allow(clippy::missing_safety_doc)]
 
 use core::{

examples/pthread_mutex.rs

@@ -3,7 +3,8 @@
 // inspired by <https://github.com/nbdd0121/pin-init/blob/trunk/examples/pthread_mutex.rs>
 #![allow(clippy::undocumented_unsafe_blocks)]
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
 #[cfg(not(windows))]
 mod pthread_mtx {

examples/static_init.rs

@@ -2,7 +2,8 @@
 
 #![allow(clippy::undocumented_unsafe_blocks)]
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 #![allow(unused_imports)]
 
 use core::{

internal/Cargo.toml

@@ -21,4 +21,5 @@ syn = { version = "2.0.86", features = ["full", "parsing", "visit-mut"] }
 rustc_version = "0.4"
 
 [lints.rust]
+stable_features = "allow"
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(kernel)'] }

internal/build.rs

@@ -1,10 +1,12 @@
-use rustc_version::{version, Version};
+use rustc_version::{version_meta, Channel};
 
 fn main() {
-    println!("cargo::rustc-check-cfg=cfg(RUSTC_LINT_REASONS_IS_STABLE)");
-    if version().unwrap() >= Version::parse("1.81.0").unwrap()
-        || version().unwrap() >= Version::parse("1.81.0-nightly").unwrap()
-    {
-        println!("cargo:rustc-cfg=RUSTC_LINT_REASONS_IS_STABLE");
+    println!("cargo::rustc-check-cfg=cfg(RUSTC_USE_FEATURE)");
+
+    let meta = version_meta().unwrap();
+
+    let use_feature = meta.channel == Channel::Nightly || std::env::var("RUSTC_BOOTSTRAP").is_ok();
+    if use_feature {
+        println!("cargo:rustc-cfg=RUSTC_USE_FEATURE");
     }
 }

internal/src/init.rs

@@ -284,7 +284,7 @@ fn init_fields(
                     {
                         #value_prep
                         // SAFETY: TODO
-                        unsafe { #write(::core::ptr::addr_of_mut!((*#slot).#ident), #value_ident) };
+                        unsafe { #write(&raw mut (*#slot).#ident, #value_ident) };
                     }
                     #accessor
                 }
@@ -301,7 +301,7 @@ fn init_fields(
                             //   return when an error/panic occurs.
                             // - We also use `#data` to require the correct trait (`Init` or `PinInit`)
                             //   for `#ident`.
-                            unsafe { #data.#ident(::core::ptr::addr_of_mut!((*#slot).#ident), #init)? };
+                            unsafe { #data.#ident(&raw mut (*#slot).#ident, #init)? };
                         },
                         quote! {
                             // SAFETY: TODO
@@ -316,7 +316,7 @@ fn init_fields(
                             unsafe {
                                 ::pin_init::Init::__init(
                                     #init,
-                                    ::core::ptr::addr_of_mut!((*#slot).#ident),
+                                    &raw mut (*#slot).#ident,
                                 )?
                             };
                         },
@@ -361,7 +361,7 @@ fn init_fields(
                 // SAFETY: We forget the guard later when initialization has succeeded.
                 let #guard = unsafe {
                     ::pin_init::__internal::DropGuard::new(
-                        ::core::ptr::addr_of_mut!((*slot).#ident)
+                        &raw mut (*slot).#ident
                     )
                 };
             });

internal/src/lib.rs

@@ -6,7 +6,7 @@
 
 //! `pin-init` proc macros.
 
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
 // Documentation is done in the pin-init crate instead.
 #![allow(missing_docs)]
 

src/lib.rs

@@ -172,7 +172,6 @@
 //! # #![feature(extern_types)]
 //! use pin_init::{pin_data, pinned_drop, PinInit, PinnedDrop, pin_init_from_closure};
 //! use core::{
-//!     ptr::addr_of_mut,
 //!     marker::PhantomPinned,
 //!     cell::UnsafeCell,
 //!     pin::Pin,
@@ -211,7 +210,7 @@
 //!         unsafe {
 //!             pin_init_from_closure(move |slot: *mut Self| {
 //!                 // `slot` contains uninit memory, avoid creating a reference.
-//!                 let foo = addr_of_mut!((*slot).foo);
+//!                 let foo = &raw mut (*slot).foo;
 //!                 let foo = UnsafeCell::raw_get(foo).cast::<bindings::foo>();
 //!
 //!                 // Initialize the `foo`
@@ -264,12 +263,10 @@
 //! [`impl Init<T, E>`]: crate::Init
 //! [Rust-for-Linux]: https://rust-for-linux.com/
 
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 #![cfg_attr(
-    all(
-        any(feature = "alloc", feature = "std"),
-        not(RUSTC_NEW_UNINIT_IS_STABLE)
-    ),
+    all(any(feature = "alloc", feature = "std"), RUSTC_USE_FEATURE),
     feature(new_uninit)
 )]
 #![forbid(missing_docs, unsafe_op_in_unsafe_fn)]
@@ -755,7 +752,7 @@ macro_rules! stack_try_pin_init {
 ///
 /// ```rust
 /// # use pin_init::*;
-/// # use core::{ptr::addr_of_mut, marker::PhantomPinned};
+/// # use core::marker::PhantomPinned;
 /// #[pin_data]
 /// #[derive(Zeroable)]
 /// struct Buf {
@@ -769,7 +766,7 @@ macro_rules! stack_try_pin_init {
 /// let init = pin_init!(&this in Buf {
 ///     buf: [0; 64],
 ///     // SAFETY: TODO.
-///     ptr: unsafe { addr_of_mut!((*this.as_ptr()).buf).cast() },
+///     ptr: unsafe { (&raw mut (*this.as_ptr()).buf).cast() },
 ///     pin: PhantomPinned,
 /// });
 /// let init = pin_init!(Buf {

tests/alloc_fail.rs

@@ -1,5 +1,5 @@
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
 
 #[test]
 #[cfg(feature = "alloc")]

tests/cfgs.rs

@@ -1,4 +1,5 @@
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
 use pin_init::{pin_data, pin_init, PinInit};
 

tests/const-generic-default.rs

@@ -1,4 +1,5 @@
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
 use pin_init::*;
 

tests/init-scope.rs

@@ -1,5 +1,6 @@
 #![allow(dead_code)]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
 use pin_init::*;
 

tests/many_generics.rs

@@ -1,4 +1,4 @@
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
 #![allow(dead_code)]
 
 use core::{marker::PhantomPinned, pin::Pin};

tests/ring_buf.rs

@@ -1,16 +1,11 @@
 #![allow(clippy::undocumented_unsafe_blocks)]
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 #![cfg_attr(feature = "alloc", feature(allocator_api))]
 
 #[cfg(all(not(feature = "std"), feature = "alloc"))]
 use alloc::sync::Arc;
-use core::{
-    convert::Infallible,
-    marker::PhantomPinned,
-    mem::MaybeUninit,
-    pin::Pin,
-    ptr::{self, addr_of_mut},
-};
+use core::{convert::Infallible, marker::PhantomPinned, mem::MaybeUninit, pin::Pin, ptr};
 use pin_init::*;
 #[cfg(feature = "std")]
 use std::sync::Arc;
@@ -50,8 +45,8 @@ impl<T, const SIZE: usize> RingBuffer<T, SIZE> {
             // SAFETY: The elements of the array can be uninitialized.
             buffer <- unsafe { init_from_closure(|_| Ok::<_, Infallible>(())) },
             // SAFETY: `this` is a valid pointer.
-            head: unsafe { addr_of_mut!((*this.as_ptr()).buffer).cast::<T>() },
-            tail: unsafe { addr_of_mut!((*this.as_ptr()).buffer).cast::<T>() },
+            head: unsafe { (&raw mut (*this.as_ptr()).buffer).cast::<T>() },
+            tail: unsafe { (&raw mut (*this.as_ptr()).buffer).cast::<T>() },
             _pin: PhantomPinned,
         })
     }
@@ -112,7 +107,7 @@ impl<T, const SIZE: usize> RingBuffer<T, SIZE> {
     unsafe fn advance(&mut self, ptr: *mut T) -> *mut T {
         // SAFETY: ptr's offset from buffer is < SIZE
         let ptr = unsafe { ptr.add(1) };
-        let origin: *mut _ = addr_of_mut!(self.buffer);
+        let origin: *mut _ = &raw mut (self.buffer);
         let origin = origin.cast::<T>();
         let offset = unsafe { ptr.offset_from(origin) };
         if offset >= SIZE as isize {

tests/ui.rs

@@ -1,4 +1,4 @@
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
 
 #[test]
 #[cfg_attr(not(UI_TESTS), ignore)]

tests/ui/compile-fail/pin_data/no_pin_on_phantompinned.stderr

@@ -21,26 +21,3 @@ error: The field `pin4` of type `PhantomPinned` only has an effect if it has the
   |
 9 |     pin4: ::core::marker::PhantomPinned,
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0425]: cannot find type `PhantomPinned` in this scope
- --> tests/ui/compile-fail/pin_data/no_pin_on_phantompinned.rs:6:11
-  |
-6 |     pin1: PhantomPinned,
-  |           ^^^^^^^^^^^^^ not found in this scope
-  |
-help: consider importing this struct
-  |
-1 + use std::marker::PhantomPinned;
-  |
-
-error[E0433]: failed to resolve: use of unresolved module or unlinked crate `marker`
- --> tests/ui/compile-fail/pin_data/no_pin_on_phantompinned.rs:7:11
-  |
-7 |     pin2: marker::PhantomPinned,
-  |           ^^^^^^ use of unresolved module or unlinked crate `marker`
-  |
-  = help: if you wanted to use a crate named `marker`, use `cargo add marker` to add it to your `Cargo.toml`
-help: consider importing this module
-  |
-1 + use std::marker;
-  |

tests/ui/expand/many_generics.expanded.rs

@@ -1,4 +1,3 @@
-#![feature(lint_reasons)]
 #![allow(dead_code)]
 use core::{marker::PhantomPinned, pin::Pin};
 use pin_init::*;

tests/underscore.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(not(RUSTC_RAW_REF_OP_IS_STABLE), feature(raw_ref_op))]
+
 use pin_init::{init, Init};
 
 pub struct Foo {

tests/zeroing.rs

@@ -1,6 +1,7 @@
-#![cfg_attr(not(RUSTC_LINT_REASONS_IS_STABLE), feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(lint_reasons))]
+#![cfg_attr(RUSTC_USE_FEATURE, feature(raw_ref_op))]
 
-use core::{marker::PhantomPinned, ptr::addr_of_mut};
+use std::marker::PhantomPinned;
 
 use pin_init::*;
 
@@ -22,7 +23,7 @@ impl Foo {
             marks: {
                 let ptr = this.as_ptr();
                 // SAFETY: project from the NonNull<Foo> to the buf field
-                let ptr = unsafe { addr_of_mut!((*ptr).buf) }.cast::<u8>();
+                let ptr = unsafe { &raw mut (*ptr).buf }.cast::<u8>();
                 [ptr; MARKS]},
             ..Zeroable::init_zeroed()
         })