Update nightly Rust version

Code changes are:
- `static mut` now warns, so we introduce `SyncUnsafeCell` and use that
  instead.
- Rename of "object safe" to "dyn-compatible".
- The rest is Clippy.

UI test changes are:
- Removal of "which is required by ...", the end result is generally
  more readable, and hides more implementation details.
- Removal of "the token" in macro diagnostics. Sometimes use "keyword"
  instead. End result is cleaner.
- `dyn T` shows up in diagnostics without `+ 'static`, which is nice.
- A few more very minor changes.
- Due to Clippy suggesting `'_` instead of an explicit lifetime, a few
  uses of `&` in diagnostics are now cleaner.

There are no assembly test changes.

Author: madsmtm

.github/workflows/ci.yml

@@ -55,7 +55,7 @@ env:
   # END AUTOMATICALLY GENERATED
 
   # The current nightly Rust version. Keep this synced with `rust-toolchain.toml`
-  CURRENT_NIGHTLY: nightly-2024-09-05
+  CURRENT_NIGHTLY: nightly-2024-11-14
   # Various features that we'd usually want to test with
   #
   # Note: The `exception` feature is not enabled here, since it requires

crates/block2/src/stack.rs

@@ -71,7 +71,7 @@ where
 }
 
 // Basic constants and helpers.
-impl<'f, A, R, Closure> StackBlock<'f, A, R, Closure> {
+impl<A, R, Closure> StackBlock<'_, A, R, Closure> {
     /// The size of the block header and the trailing closure.
     ///
     /// This ensures that the closure that the block contains is also moved to
@@ -108,7 +108,7 @@ impl<'f, A, R, Closure> StackBlock<'f, A, R, Closure> {
 }
 
 // `StackBlock::new`
-impl<'f, A, R, Closure: Clone> StackBlock<'f, A, R, Closure> {
+impl<A, R, Closure: Clone> StackBlock<'_, A, R, Closure> {
     // Clone the closure from one block to another.
     unsafe extern "C-unwind" fn clone_closure(dst: *mut c_void, src: *const c_void) {
         let dst: *mut Self = dst.cast();
@@ -446,7 +446,7 @@ where
         };
 }
 
-impl<'f, A, R, Closure: Clone> Clone for StackBlock<'f, A, R, Closure> {
+impl<A, R, Closure: Clone> Clone for StackBlock<'_, A, R, Closure> {
     #[inline]
     fn clone(&self) -> Self {
         Self {
@@ -457,7 +457,7 @@ impl<'f, A, R, Closure: Clone> Clone for StackBlock<'f, A, R, Closure> {
     }
 }
 
-impl<'f, A, R, Closure: Copy> Copy for StackBlock<'f, A, R, Closure> {}
+impl<A, R, Closure: Copy> Copy for StackBlock<'_, A, R, Closure> {}
 
 impl<'f, A, R, Closure> Deref for StackBlock<'f, A, R, Closure>
 where
@@ -481,7 +481,7 @@ where
     }
 }
 
-impl<'f, A, R, Closure> fmt::Debug for StackBlock<'f, A, R, Closure> {
+impl<A, R, Closure> fmt::Debug for StackBlock<'_, A, R, Closure> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut f = f.debug_struct("StackBlock");
         debug_block_header(&self.header, &mut f);

crates/header-translator/src/config.rs

@@ -337,7 +337,7 @@ impl<'de> Deserialize<'de> for Counterpart {
 
         struct CounterpartVisitor;
 
-        impl<'de> de::Visitor<'de> for CounterpartVisitor {
+        impl de::Visitor<'_> for CounterpartVisitor {
             type Value = Counterpart;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

crates/header-translator/src/id.rs

@@ -59,7 +59,7 @@ pub enum LocationLibrary<'location, 'config> {
     },
 }
 
-impl<'location, 'config> LocationLibrary<'location, 'config> {
+impl<'config> LocationLibrary<'_, 'config> {
     pub fn krate(&self) -> Option<(&'config str, bool)> {
         match self {
             Self::System => None,

crates/objc2/src/__macro_helpers/mod.rs

@@ -23,6 +23,7 @@ mod module_info;
 mod msg_send;
 mod msg_send_retained;
 mod os_version;
+mod sync_unsafe_cell;
 mod writeback;
 
 pub use self::cache::{CachedClass, CachedSel};
@@ -41,6 +42,7 @@ pub use self::module_info::ModuleInfo;
 pub use self::msg_send::MsgSend;
 pub use self::msg_send_retained::{MaybeUnwrap, MsgSendId, MsgSendSuperId};
 pub use self::os_version::{is_available, AvailableVersion, OSVersion};
+pub use self::sync_unsafe_cell::SyncUnsafeCell;
 
 /// Disallow using this passed in value in const and statics for forwards
 /// compatibility (this function is not a `const` function).

crates/objc2/src/__macro_helpers/msg_send.rs

@@ -162,7 +162,7 @@ impl<T: MessageReceiver> MsgSend for T {
     }
 }
 
-impl<'a, T: ?Sized + Message> MsgSend for &'a Retained<T> {
+impl<T: ?Sized + Message> MsgSend for &Retained<T> {
     type Inner = T;
 
     #[inline]

crates/objc2/src/__macro_helpers/msg_send_retained.rs

@@ -464,7 +464,7 @@ impl<'a> MsgSendIdFailed<'a> for New {
     }
 }
 
-impl<'a> MsgSendIdFailed<'a> for Alloc {
+impl MsgSendIdFailed<'_> for Alloc {
     type Args = ();
 
     #[cold]

crates/objc2/src/__macro_helpers/sync_unsafe_cell.rs

@@ -0,0 +1,32 @@
+use core::cell::UnsafeCell;
+
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct SyncUnsafeCell<T: ?Sized> {
+    value: UnsafeCell<T>,
+}
+
+// SAFETY: This type is used for making `static`s which contain `UnsafeCell`.
+// The user upholds that such usage is correct.
+unsafe impl<T: ?Sized + Sync> Sync for SyncUnsafeCell<T> {}
+
+impl<T> SyncUnsafeCell<T> {
+    #[inline]
+    pub const fn new(value: T) -> Self {
+        Self {
+            value: UnsafeCell::new(value),
+        }
+    }
+
+    #[inline]
+    pub fn into_inner(self) -> T {
+        self.value.into_inner()
+    }
+}
+
+impl<T: ?Sized> SyncUnsafeCell<T> {
+    #[inline]
+    pub const fn get(&self) -> *mut T {
+        self.value.get()
+    }
+}

crates/objc2/src/encode.rs

@@ -817,8 +817,8 @@ encode_pointer_impls!(
 );
 
 // SAFETY: References and `NonNull` have a NULL niche
-unsafe impl<'a, T: RefEncode + ?Sized> OptionEncode for &'a T {}
-unsafe impl<'a, T: RefEncode + ?Sized> OptionEncode for &'a mut T {}
+unsafe impl<T: RefEncode + ?Sized> OptionEncode for &T {}
+unsafe impl<T: RefEncode + ?Sized> OptionEncode for &mut T {}
 unsafe impl<T: RefEncode + ?Sized> OptionEncode for NonNull<T> {}
 
 /// Helper for implementing [`Encode`]/[`RefEncode`] for function pointers

crates/objc2/src/macros/declare_class.rs

@@ -425,9 +425,15 @@ macro_rules! declare_class {
 
         // Anonymous block to hide the shared statics
         const _: () = {
-            static mut __OBJC2_CLASS: $crate::__macro_helpers::MaybeUninit<&'static $crate::runtime::AnyClass> = $crate::__macro_helpers::MaybeUninit::uninit();
-            static mut __OBJC2_IVAR_OFFSET: $crate::__macro_helpers::MaybeUninit<$crate::__macro_helpers::isize> = $crate::__macro_helpers::MaybeUninit::uninit();
-            static mut __OBJC2_DROP_FLAG_OFFSET: $crate::__macro_helpers::MaybeUninit<$crate::__macro_helpers::isize> = $crate::__macro_helpers::MaybeUninit::uninit();
+            static __OBJC2_CLASS: $crate::__macro_helpers::SyncUnsafeCell<
+                $crate::__macro_helpers::MaybeUninit<&'static $crate::runtime::AnyClass>
+            > = $crate::__macro_helpers::SyncUnsafeCell::new($crate::__macro_helpers::MaybeUninit::uninit());
+            static __OBJC2_IVAR_OFFSET: $crate::__macro_helpers::SyncUnsafeCell<
+                $crate::__macro_helpers::MaybeUninit<$crate::__macro_helpers::isize>
+            > = $crate::__macro_helpers::SyncUnsafeCell::new($crate::__macro_helpers::MaybeUninit::uninit());
+            static __OBJC2_DROP_FLAG_OFFSET: $crate::__macro_helpers::SyncUnsafeCell<
+                $crate::__macro_helpers::MaybeUninit<$crate::__macro_helpers::isize>
+            > = $crate::__macro_helpers::SyncUnsafeCell::new($crate::__macro_helpers::MaybeUninit::uninit());
 
             // Creation
             unsafe impl ClassType for $for_class {
@@ -458,18 +464,18 @@ macro_rules! declare_class {
                         // SAFETY: Modification is ensured by `Once` to happen
                         // before any access to the variables.
                         unsafe {
-                            __OBJC2_CLASS.write(__objc2_cls);
+                            __OBJC2_CLASS.get().write($crate::__macro_helpers::MaybeUninit::new(__objc2_cls));
                             if <Self as $crate::__macro_helpers::DeclaredIvarsHelper>::HAS_IVARS {
-                                __OBJC2_IVAR_OFFSET.write(__objc2_ivar_offset);
+                                __OBJC2_IVAR_OFFSET.get().write($crate::__macro_helpers::MaybeUninit::new(__objc2_ivar_offset));
                             }
                             if <Self as $crate::__macro_helpers::DeclaredIvarsHelper>::HAS_DROP_FLAG {
-                                __OBJC2_DROP_FLAG_OFFSET.write(__objc2_drop_flag_offset);
+                                __OBJC2_DROP_FLAG_OFFSET.get().write($crate::__macro_helpers::MaybeUninit::new(__objc2_drop_flag_offset));
                             }
                         }
                     });
 
                     // SAFETY: We just registered the class, so is now available
-                    unsafe { __OBJC2_CLASS.assume_init() }
+                    unsafe { __OBJC2_CLASS.get().read().assume_init() }
                 }
 
                 #[inline]
@@ -492,7 +498,7 @@ macro_rules! declare_class {
                     if <Self as $crate::__macro_helpers::DeclaredIvarsHelper>::HAS_IVARS {
                         // SAFETY: Accessing the offset is guaranteed to only be
                         // done after the class has been initialized.
-                        unsafe { __OBJC2_IVAR_OFFSET.assume_init() }
+                        unsafe { __OBJC2_IVAR_OFFSET.get().read().assume_init() }
                     } else {
                         // Fall back to an offset of zero.
                         //
@@ -506,7 +512,7 @@ macro_rules! declare_class {
                 fn __drop_flag_offset() -> $crate::__macro_helpers::isize {
                     if <Self as $crate::__macro_helpers::DeclaredIvarsHelper>::HAS_DROP_FLAG {
                         // SAFETY: Same as above.
-                        unsafe { __OBJC2_DROP_FLAG_OFFSET.assume_init() }
+                        unsafe { __OBJC2_DROP_FLAG_OFFSET.get().read().assume_init() }
                     } else {
                         // Fall back to an offset of zero.
                         //