chore: update nightly to 2024-01-20

bitfield/src/from_bits.rs

@@ -150,7 +150,7 @@ macro_rules! enum_from_bits {
         }
 
         impl $Type {
-            const VARIANTS: &[Self] = &[
+            const VARIANTS: &'static [Self] = &[
                 Self::$Variant1,
                 $(
                     Self::$Variant,

bitfield/src/pack.rs

@@ -703,11 +703,7 @@ macro_rules! make_packers {
 
             impl<T, F> Clone for $Pack<T, F> {
                 fn clone(&self) -> Self {
-                    Self {
-                        mask: self.mask,
-                        shift: self.shift,
-                        _dst_ty: PhantomData,
-                    }
+                   *self
                 }
             }
 
@@ -773,14 +769,14 @@ macro_rules! make_packers {
             impl<A, B, F> PartialEq<&'_ $Pack<B, F>> for $Pack<A, F> {
                 #[inline]
                 fn eq(&self, other: &&'_ $Pack<B, F>) -> bool {
-                    self.eq(*other)
+                    <Self as PartialEq<$Pack<B, F>>>::eq(self, *other)
                 }
             }
 
             impl<A, B, F> PartialEq<$Pack<B, F>> for &'_ $Pack<A, F> {
                 #[inline]
                 fn eq(&self, other: &$Pack<B, F>) -> bool {
-                    (*self).eq(other)
+                    <$Pack<A, F> as PartialEq<$Pack<B, F>>>::eq(*self, other)
                 }
             }
 
@@ -992,12 +988,7 @@ macro_rules! make_packers {
 
             impl<T> Clone for $Pair<T> {
                 fn clone(&self) -> Self {
-                    Self {
-                        src: self.src,
-                        dst: self.dst,
-                        dst_shl: self.dst_shl,
-                        dst_shr: self.dst_shr,
-                    }
+                    *self
                 }
             }
 
@@ -1061,14 +1052,14 @@ macro_rules! make_packers {
             impl<A, B> PartialEq<&'_ $Pair<B>> for $Pair<A> {
                 #[inline]
                 fn eq(&self, other: &&'_ $Pair<B>) -> bool {
-                    self.eq(*other)
+                    <Self as PartialEq<$Pair<B>>>::eq(self, *other)
                 }
             }
 
             impl<A, B> PartialEq<$Pair<B>> for &'_ $Pair<A> {
                 #[inline]
                 fn eq(&self, other: &$Pair<B>) -> bool {
-                    (*self).eq(other)
+                    <$Pair<A> as PartialEq<$Pair<B>>>::eq(*self, other)
                 }
             }
 

cordyceps/src/list.rs

@@ -365,7 +365,7 @@ impl<T: Linked<Links<T>> + ?Sized> List<T> {
         let split_idx = match at {
             // trying to split at the 0th index. we can just return the whole
             // list, leaving `self` empty.
-            at if at == 0 => return Some(mem::replace(self, Self::new())),
+            0 => return Some(mem::replace(self, Self::new())),
             // trying to split at the last index. the new list will be empty.
             at if at == len => return Some(Self::new()),
             // we cannot split at an index that is greater than the length of
@@ -901,12 +901,9 @@ impl<T: Linked<Links<T>> + ?Sized> List<T> {
     /// If the closure returns `false`, the element will remain in the list and
     /// will not be yielded by the iterator.
     ///
-    /// Note that *unlike* the [`drain_filter` method][std-filter] on
-    /// [`std::collections::LinkedList`], the closure is *not* permitted to
-    /// mutate the elements of the list, as a mutable reference could be used to
-    /// improperly unlink list nodes.
-    ///
-    /// [std-filter]: std::collections::LinkedList::drain_filter
+    /// Note that the closure is *not* permitted to mutate the elements of the
+    /// list, as a mutable reference could be used to improperly unlink list
+    /// nodes.
     #[must_use]
     pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, T, F>
     where

cordyceps/src/loom.rs

@@ -63,7 +63,7 @@ mod inner {
 
 #[cfg(not(loom))]
 mod inner {
-    #![allow(dead_code)]
+    #![allow(dead_code, unused_imports)]
     pub(crate) mod sync {
         pub use core::sync::*;
 
@@ -229,7 +229,7 @@ mod inner {
             }
 
             thread_local! {
-                static REGISTRY: RefCell<Option<Registry>> = RefCell::new(None);
+                static REGISTRY: RefCell<Option<Registry>> = const { RefCell::new(None) };
             }
 
             impl Registry {

cordyceps/src/mpsc_queue.rs

@@ -1516,7 +1516,7 @@ mod tests {
 mod test_util {
     use super::*;
     use crate::loom::alloc;
-    pub use std::{boxed::Box, pin::Pin, println, ptr, vec, vec::Vec};
+    pub use std::{boxed::Box, pin::Pin, ptr, vec::Vec};
 
     pub(super) struct Entry {
         links: Links<Entry>,

hal-x86_64/src/cpu/msr.rs

@@ -309,11 +309,7 @@ impl<V> Msr<V> {
 impl<V> Clone for Msr<V> {
     #[inline]
     fn clone(&self) -> Self {
-        Self {
-            num: self.num,
-            name: self.name,
-            _ty: PhantomData,
-        }
+        *self
     }
 }
 

hal-x86_64/src/interrupt/apic/io.rs

@@ -280,6 +280,7 @@ impl Default for DeliveryMode {
     }
 }
 
+#[cfg(test)]
 mod test {
     use super::*;
 

hal-x86_64/src/serial.rs

@@ -243,7 +243,7 @@ impl<'a> Lock<'a> {
     }
 }
 
-impl<'a, B> Lock<'a, B> {
+impl<B> Lock<'_, B> {
     /// Set the serial port's baud rate for this `Lock`.
     ///
     /// When the `Lock` is dropped, the baud rate will be set to the previous value.
@@ -281,7 +281,7 @@ impl<'a, B> Lock<'a, B> {
     }
 }
 
-impl<'a> io::Read for Lock<'a, Blocking> {
+impl io::Read for Lock<'_, Blocking> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         for byte in buf.iter_mut() {
             *byte = self.inner.read_blocking();
@@ -290,7 +290,7 @@ impl<'a> io::Read for Lock<'a, Blocking> {
     }
 }
 
-impl<'a> io::Read for Lock<'a, Nonblocking> {
+impl io::Read for Lock<'_, Nonblocking> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         for byte in buf.iter_mut() {
             *byte = self.inner.read_nonblocking()?;
@@ -299,7 +299,7 @@ impl<'a> io::Read for Lock<'a, Nonblocking> {
     }
 }
 
-impl<'a> io::Write for Lock<'a, Blocking> {
+impl io::Write for Lock<'_, Blocking> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         for &byte in buf.iter() {
             self.inner.write_blocking(byte)
@@ -313,7 +313,7 @@ impl<'a> io::Write for Lock<'a, Blocking> {
     }
 }
 
-impl<'a> fmt::Write for Lock<'a, Blocking> {
+impl fmt::Write for Lock<'_, Blocking> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         for byte in s.bytes() {
             self.inner.write_blocking(byte)
@@ -322,7 +322,7 @@ impl<'a> fmt::Write for Lock<'a, Blocking> {
     }
 }
 
-impl<'a> io::Write for Lock<'a, Nonblocking> {
+impl io::Write for Lock<'_, Nonblocking> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         for &byte in buf.iter() {
             self.inner.write_nonblocking(byte)?;
@@ -336,7 +336,7 @@ impl<'a> io::Write for Lock<'a, Nonblocking> {
     }
 }
 
-impl<'a> LockInner<'a> {
+impl LockInner<'_> {
     #[inline(always)]
     fn is_write_ready(&self) -> bool {
         self.inner.is_write_ready()
@@ -373,7 +373,7 @@ impl<'a> LockInner<'a> {
     }
 }
 
-impl<'a> Drop for LockInner<'a> {
+impl Drop for LockInner<'_> {
     fn drop(&mut self) {
         if let Some(divisor) = self.prev_divisor {
             // Disable IRQs.
@@ -385,7 +385,7 @@ impl<'a> Drop for LockInner<'a> {
     }
 }
 
-impl<'a> mycelium_trace::writer::MakeWriter<'a> for &'static Port {
+impl<'a> mycelium_trace::writer::MakeWriter<'a> for &Port {
     type Writer = Lock<'a, Blocking>;
     fn make_writer(&'a self) -> Self::Writer {
         self.lock()

inoculate/src/lib.rs

@@ -301,7 +301,7 @@ impl Paths {
 // === impl BootloaderOptions ===
 
 impl BootloaderOptions {
-    const ARG_GROUP: &str = "boot-opts";
+    const ARG_GROUP: &'static str = "boot-opts";
 
     fn boot_config(&self) -> bootloader_boot_config::BootConfig {
         let mut bootcfg = bootloader::BootConfig::default();

maitake-sync/src/loom.rs

@@ -287,7 +287,7 @@ mod inner {
             }
 
             thread_local! {
-                static REGISTRY: RefCell<Option<Registry>> = RefCell::new(None);
+                static REGISTRY: RefCell<Option<Registry>> = const { RefCell::new(None) };
             }
 
             impl Registry {

maitake-sync/src/rwlock/owned.rs

@@ -101,7 +101,7 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// This method is identical to [`RwLock::read`], execept that it requires
     /// the `RwLock` to be wrapped in an [`Arc`], and returns an
-    /// [`OwnedRwLockReadGuard`][guard] that clones the [`Arc`] rather than
+    /// [`OwnedRwLockReadGuard`] that clones the [`Arc`] rather than
     /// borrowing the lock. Therefore, the returned guard is valid for the
     /// `'static` lifetime.
     ///
@@ -171,7 +171,7 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// This method is identical to [`RwLock::write`], execept that it requires
     /// the `RwLock` to be wrapped in an [`Arc`], and returns an
-    /// [`OwnedRwLockWriteGuard`][guard] that clones the [`Arc`] rather than
+    /// [`OwnedRwLockWriteGuard`] that clones the [`Arc`] rather than
     /// borrowing the lock. Therefore, the returned guard is valid for the
     /// `'static` lifetime.
     ///
@@ -226,7 +226,7 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// This method is identical to [`RwLock::try_read`], execept that it requires
     /// the `RwLock` to be wrapped in an [`Arc`], and returns an
-    /// [`OwnedRwLockReadGuard`][guard] that clones the [`Arc`] rather than
+    /// [`OwnedRwLockReadGuard`] that clones the [`Arc`] rather than
     /// borrowing the lock. Therefore, the returned guard is valid for the
     /// `'static` lifetime.
     ///
@@ -273,7 +273,7 @@ impl<T: ?Sized> RwLock<T> {
     ///
     /// This method is identical to [`RwLock::try_write`], execept that it requires
     /// the `RwLock` to be wrapped in an [`Arc`], and returns an
-    /// [`OwnedRwLockWriteGuard`][guard] that clones the [`Arc`] rather than
+    /// [`OwnedRwLockWriteGuard`] that clones the [`Arc`] rather than
     /// borrowing the lock. Therefore, the returned guard is valid for the
     /// `'static` lifetime.
     ///

maitake-sync/src/wait_map/tests/alloc_tests.rs

@@ -205,7 +205,7 @@ struct CountDropKey {
 
 impl PartialEq for CountDropKey {
     fn eq(&self, other: &Self) -> bool {
-        self.idx.eq(&other.idx)
+        self.idx == other.idx
     }
 }
 

maitake/src/loom.rs

@@ -284,7 +284,7 @@ mod inner {
             }
 
             thread_local! {
-                static REGISTRY: RefCell<Option<Registry>> = RefCell::new(None);
+                static REGISTRY: RefCell<Option<Registry>> = const { RefCell::new(None) };
             }
 
             impl Registry {

rust-toolchain.toml

@@ -1,5 +1,5 @@
 [toolchain]
-channel = "nightly-2023-03-06"
+channel = "nightly-2024-01-20"
 components = [
     "clippy",
     "rustfmt",

src/arch/x86_64/boot.rs

@@ -112,9 +112,9 @@ impl BootInfo for BootloaderApiBootInfo {
                 let com1 = AnsiEscapes::new(com1);
                 com1.with_filter(serial_filter as for<'a, 'b> fn(&'a tracing::Metadata<'b>) -> bool)
             });
-            Subscriber::display_only(display_writer).with_serial(serial)
+            Subscriber::<_, Option<FilteredSerial>>::display_only(display_writer)
+                .with_serial(serial)
         });
-
         Some(tracing::Dispatch::from_static(collector))
     }
 

src/arch/x86_64/interrupt.rs

@@ -46,7 +46,8 @@ static TSS: sync::Lazy<task::StateSegment> = sync::Lazy::new(|| {
     let mut tss = task::StateSegment::empty();
     tss.interrupt_stacks[Idt::DOUBLE_FAULT_IST_OFFSET] = unsafe {
         // safety: asdf
-        VAddr::of(&DOUBLE_FAULT_STACK).offset(DOUBLE_FAULT_STACK_SIZE as i32)
+        VAddr::from_usize_unchecked(core::ptr::addr_of!(DOUBLE_FAULT_STACK) as usize)
+            .offset(DOUBLE_FAULT_STACK_SIZE as i32)
     };
     tracing::debug!(?tss, "TSS initialized");
     tss

trace/src/color.rs

@@ -236,7 +236,7 @@ where
 }
 
 impl<W> AnsiEscapes<W> {
-    const ANSI_FG_COLOR_TABLE: [&str; 17] = [
+    const ANSI_FG_COLOR_TABLE: [&'static str; 17] = [
         "30", // black
         "31", // red
         "32", // green

trace/src/embedded_graphics.rs

@@ -45,7 +45,7 @@
     Point { x, y }
 }
 
-impl<'mk, D> fmt::Write for TextWriter<'mk, D>
+impl<D> fmt::Write for TextWriter<'_, D>
 where
     D: Draw,
 {
@@ -129,7 +129,7 @@
             Ordering::Relaxed,
         ) {
             Ok(_) => Ok(()),
             Err(actual_point) => unsafe {
                 mycelium_util::unreachable_unchecked!(
                     "lock should guard this, could actually be totally unsync; curr_point={}; actual_point={}",
                     unpack_point(curr_packed),

trace/src/lib.rs

@@ -77,7 +77,8 @@ struct Visitor<'writer, W> {
 
 impl<D> Default for Subscriber<D>
 where
-    for<'a> D: MakeWriter<'a>,
+    for<'a> D: MakeWriter<'a> + 'static,
+    for<'a> <D as MakeWriter<'a>>::Writer: SetColor,
     D: Default,
 {
     fn default() -> Self {
@@ -92,8 +93,10 @@ const _ACTUAL_ID_BITS: u64 = !(SERIAL_BIT | VGA_BIT);
 impl<D, S> Subscriber<D, S> {
     pub fn display_only(display: D) -> Self
     where
-        for<'a> D: MakeWriter<'a>,
-        for<'a> S: MakeWriter<'a>,
+        for<'a> D: MakeWriter<'a> + 'static,
+        // for<'a> <D as MakeWriter<'a>>::Writer: SetColor,
+        for<'a> S: MakeWriter<'a> + 'static,
+        // for<'a> <S as MakeWriter<'a>>::Writer: SetColor,
         S: Default,
     {
         Self {
@@ -103,9 +106,10 @@ impl<D, S> Subscriber<D, S> {
         }
     }
 
-    pub fn with_serial(self, port: S) -> Subscriber<D, S>
+    pub fn with_serial<S2>(self, port: S2) -> Subscriber<D, S2>
     where
-        for<'a> S: MakeWriter<'a>,
+        for<'a> S2: MakeWriter<'a> + 'static,
+        // for<'a> <S2 as MakeWriter<'a>>::Writer: SetColor,
     {
         Subscriber {
             serial: Output::new(port, Self::SERIAL_INDENT_CFG),
@@ -139,12 +143,12 @@ impl<D, S> Subscriber<D, S> {
     }
 }
 
-impl<D, S, DW, SW> tracing_core::Collect for Subscriber<D, S>
+impl<D, S> tracing_core::Collect for Subscriber<D, S>
 where
-    for<'a> D: MakeWriter<'a, Writer = DW> + 'static,
-    DW: Write + SetColor,
-    for<'a> S: MakeWriter<'a, Writer = SW> + 'static,
-    SW: Write + SetColor,
+    for<'a> D: MakeWriter<'a> + 'static,
+    for<'a> <D as MakeWriter<'a>>::Writer: SetColor,
+    for<'a> S: MakeWriter<'a> + 'static,
+    for<'a> <S as MakeWriter<'a>>::Writer: SetColor,
 {
     fn enabled(&self, meta: &Metadata) -> bool {
         self.display.enabled(meta) || self.serial.enabled(meta)