Fix all clippy lints

Author: Techcable

libs/context/src/collector.rs

@@ -1,4 +1,5 @@
 //! The interface to a collector
+#![allow(clippy::missing_safety_doc)]
 
 use core::fmt::{self, Debug, Formatter};
 use core::ptr::NonNull;
@@ -142,10 +143,7 @@ pub unsafe trait CollectorPtr<C: RawCollectorImpl<Ptr=Self>>: Copy + Eq
     fn upgrade_weak_raw(weak: &Self::Weak) -> Option<Self>;
     #[inline]
     fn upgrade_weak(weak: &Self::Weak) -> Option<CollectorRef<C>> {
-        match Self::upgrade_weak_raw(weak) {
-            Some(ptr) => Some(CollectorRef { ptr }),
-            None => None
-        }
+        Self::upgrade_weak_raw(weak).map(|ptr| CollectorRef { ptr })
     }
     unsafe fn assume_weak_valid(weak: &Self::Weak) -> Self;
     unsafe fn create_weak(&self) -> Self::Weak;
@@ -182,14 +180,9 @@ unsafe impl<C: RawCollectorImpl<Ptr=Self>> CollectorPtr<C> for NonNull<C> {
 
     #[inline]
     fn upgrade_weak_raw(weak: &Self::Weak) -> Option<Self> {
-        match weak.upgrade() {
-            Some(arc) => {
-                Some(unsafe {
-                    Self::from_raw(Arc::into_raw(arc) as *mut _)
-                })
-            },
-            None => None
-        }
+        weak.upgrade().map(|arc| unsafe {
+            Self::from_raw(Arc::into_raw(arc) as *mut _)
+        })
     }
 
     #[inline]
@@ -496,7 +489,7 @@ impl<C: SyncCollector> CollectorRef<C> {
     /// Warning: Only one collector should be created per thread.
     /// Doing otherwise can cause deadlocks/panics.
     pub fn create_context(&self) -> CollectorContext<C> {
-        unsafe { CollectorContext::register_root(&self) }
+        unsafe { CollectorContext::register_root(self) }
     }
 }
 impl<C: RawCollectorImpl> Drop for CollectorRef<C> {

libs/context/src/handle.rs

@@ -40,6 +40,7 @@ pub struct GcHandleList<C: RawHandleImpl> {
     /// If the list is empty, this is null
     last_free_slot: AtomicPtr<HandleSlot<C>>
 }
+#[allow(clippy::new_without_default)]
 impl<C: RawHandleImpl> GcHandleList<C> {
     pub fn new() -> Self {
         use core::ptr::null_mut;

libs/context/src/lib.rs

@@ -3,6 +3,9 @@
     untagged_unions, // I want to avoid ManuallyDrop in unions
     const_fn_trait_bound, // So generics + const fn are unstable, huh?
 )]
+#![allow(
+    clippy::missing_safety_doc, // Entirely internal code
+)]
 #![cfg_attr(not(feature = "std"), no_std)]
 //! The implementation of (GcContext)[`::zerogc::GcContext`] that is
 //! shared among both thread-safe and thread-unsafe code.
@@ -119,14 +122,14 @@ impl<C: RawCollectorImpl> CollectorContext<C> {
     pub(crate) unsafe fn register_root(collector: &CollectorRef<C>) -> Self {
         CollectorContext {
             raw: Box::into_raw(ManuallyDrop::into_inner(
-                C::RawContext::register_new(&collector)
+                C::RawContext::register_new(collector)
             )),
             root: true, // We are responsible for unregistering
         }
     }
     #[inline]
     pub fn collector(&self) -> &C {
-        unsafe { &(*self.raw).collector() }
+        unsafe { (*self.raw).collector() }
     }
     #[inline(always)]
     unsafe fn with_shadow_stack<R, T: Trace>(

libs/context/src/state/mod.rs

@@ -21,7 +21,15 @@ pub unsafe trait CollectionManager<C>: self::sealed::Sealed
     fn new() -> Self;
     fn is_collecting(&self) -> bool;
     fn should_trigger_collection(&self) -> bool;
+    /// Freeze this context
+    ///
+    /// ## Safety
+    /// See [GcContext::free_context]
     unsafe fn freeze_context(&self, context: &Self::Context);
+    /// Unfreeze the context
+    ///
+    /// ## Safety
+    /// See [GcContext::unfreeze_context]
     unsafe fn unfreeze_context(&self, context: &Self::Context);
 
     //
@@ -54,12 +62,19 @@ pub unsafe trait RawContext<C>: Debug + self::sealed::Sealed
     /// potentially blocking until completion..
     ///
     /// Undefined behavior if mutated during collection
+    ///
+    /// ## Safety
+    /// See [GcContext::unchecked_safepoint]
     unsafe fn trigger_safepoint(&self);
     /// Borrow a reference to the shadow stack,
     /// assuming this context is valid (not active).
     ///
     /// A context is valid if it is either frozen
     /// or paused at a safepoint.
+    ///
+    /// ## Safety
+    /// The context must be "inactive",
+    /// either frozen or paused at a safepoint.
     #[inline]
     unsafe fn assume_valid_shadow_stack(&self) -> &ShadowStack<C> {
         match self.state() {
@@ -72,6 +87,10 @@ pub unsafe trait RawContext<C>: Debug + self::sealed::Sealed
     fn shadow_stack_ptr(&self) -> *mut ShadowStack<C>;
     /// Get a reference to the collector,
     /// assuming that it's valid
+    ///
+    /// ## Safety
+    /// Assumes that the underlying collector
+    /// is still valid.
     unsafe fn collector(&self) -> &C;
     fn state(&self) -> ContextState;
 }

libs/context/src/state/nosync.rs

@@ -207,6 +207,7 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
 pub struct CollectorState {
     next_pending_id: u64
 }
+#[allow(clippy::new_without_default)]
 impl CollectorState {
     pub fn new() -> Self {
         CollectorState {

libs/context/src/state/sync.rs

@@ -328,6 +328,7 @@ pub struct CollectorState<C: RawCollectorImpl> {
     known_contexts: Mutex<HashSet<*mut RawContext<C>>>,
     next_pending_id: u64
 }
+#[allow(clippy::new_without_default)]
 impl<C: RawCollectorImpl> CollectorState<C> {
     pub fn new() -> Self {
         CollectorState {
@@ -494,10 +495,7 @@ pub(crate) trait SyncCollectorImpl: RawCollectorImpl<Manager=CollectionManager<S
                                 pending.valid_contexts.clone()
                             } else {
                                 // Otherwise we might as well be done with it
-                                mem::replace(
-                                    &mut pending.valid_contexts,
-                                    Vec::new()
-                                )
+                                mem::take(&mut pending.valid_contexts)
                             };
                             perform_collection(&mut *lock, contexts);
                             drop(lock);

libs/derive/src/lib.rs

@@ -200,7 +200,7 @@ impl TypeAttrs {
         });
         match (iter.next(), iter.next()) {
             (Some(_), Some((dup_attr, _))) => {
-                return Err(Error::new(dup_attr.path.span(), "Duplicate #[zerogc] attribute"))
+                Err(Error::new(dup_attr.path.span(), "Duplicate #[zerogc] attribute"))
             },
             (Some((_, parsed)), None) => {
                 parsed
@@ -495,22 +495,22 @@ pub fn derive_trace(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
 fn impl_derive_trace(input: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, syn::Error> {
     let trace_impl = if info.config.nop_trace {
-        impl_nop_trace(&input, &info)?
+        impl_nop_trace(input, info)?
     } else {
-        impl_trace(&input, &info)?
+        impl_trace(input, info)?
     };
     let rebrand_impl = if info.config.nop_trace {
-        impl_rebrand_nop(&input, &info)?
+        impl_rebrand_nop(input, info)?
     } else {
-        impl_rebrand(&input, &info)?
+        impl_rebrand(input, info)?
     };
     let erase_impl = if info.config.nop_trace {
-        impl_erase_nop(&input, &info)?
+        impl_erase_nop(input, info)?
     } else {
-        impl_erase(&input, &info)?
+        impl_erase(input, info)?
     };
-    let gc_safe_impl = impl_gc_safe(&input, &info)?;
-    let extra_impls = impl_extras(&input, &info)?;
+    let gc_safe_impl = impl_gc_safe(input, info)?;
+    let extra_impls = impl_extras(input, info)?;
     Ok(quote! {
         #trace_impl
         #rebrand_impl
@@ -755,7 +755,7 @@ fn impl_erase(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream, Er
                             Ok(parse_quote!('new_gc))
                         },
                         TypeParamBound::Lifetime(ref lt) => {
-                            return Err(unsupported_lifetime_param(lt))
+                            Err(unsupported_lifetime_param(lt))
                         }
                     }
                 }
@@ -922,7 +922,7 @@ fn impl_rebrand(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
                             Ok(parse_quote!('new_gc))
                         },
                         TypeParamBound::Lifetime(ref lt) => {
-                            return Err(unsupported_lifetime_param(lt))
+                            Err(unsupported_lifetime_param(lt))
                         }
                     }
                 }
@@ -1126,6 +1126,7 @@ fn impl_gc_safe(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
     )?;
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     let target_fields = collect_fields(target)?;
+    #[allow(clippy::if_same_then_else)] // Only necessary because of detailed comments
     let fake_drop_impl = if info.config.is_copy {
         /*
          * If this type can be proven to implement Copy,
@@ -1134,27 +1135,27 @@ fn impl_gc_safe(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream,
          * In fact, adding one would prevent it from being Copy
          * in the first place.
          */
-        quote!()
+        None
     } else if info.config.unsafe_skip_drop {
-        quote!() // Skip generating drop at user's request
+        None // Skip generating drop at user's request
     } else if info.config.nop_trace {
         /*
          * A NullTrace type is implicitly drop safe.
          *
          * No tracing needed implies there are no reachable GC references.
          * Therefore there is nothing to fear about finalizers resurrecting things
          */
-        quote!()
+        None
     } else {
-        quote!(impl #impl_generics Drop for #name #ty_generics #where_clause {
+        Some(quote!(impl #impl_generics Drop for #name #ty_generics #where_clause {
             #[inline]
             fn drop(&mut self) {
                 /*
                  * This is only here to prevent the user
                  * from implementing their own Drop functionality.
                  */
             }
-        })
+        }))
     };
     let verify_gc_safe = if info.config.is_copy {
         quote!(#zerogc_crate::assert_copy::<Self>())
@@ -1215,13 +1216,13 @@ fn impl_nop_trace(target: &DeriveInput, info: &GcTypeInfo) -> Result<TokenStream
                 return Ok(quote!());
             }
             let ty_span = t.span();
-            Ok(quote_spanned! { ty_span =>
+            Ok(quote_spanned! { ty_span => #[allow(clippy::assertions_on_constants)] /* Not actually a constant */ {
                 assert!(
                     !<#t as #zerogc_crate::Trace>::NEEDS_TRACE,
                     "Can't #[derive(NullTrace) with {}",
                     stringify!(#t)
                 );
-            })
+            } })
         }).collect::<Result<Vec<_>, Error>>()?;
     let needs_drop = needs_drop(info, &*target_fields);
     Ok(quote! {
@@ -1259,7 +1260,7 @@ fn add_trait_bounds_except(
 ) -> Result<Generics, Error> {
     let mut actually_ignored_args = HashSet::<Ident>::new();
     let generics = add_trait_bounds(
-        &generics, bound,
+        generics, bound,
         &mut |param: &TypeParam| {
             if let Some(ref mut extra) = extra_ignore {
                 if extra(&param.ident) {
@@ -1321,9 +1322,9 @@ fn debug_derive(key: &str, target: &dyn ToString, message: &dyn Display, value:
         Ok(ref var) if var == "0" => { return /* disabled */ }
         Ok(var) => {
             let target_parts = std::iter::once(key)
-                .chain(target.split(":")).collect::<Vec<_>>();
-            for pattern in var.split_terminator(",") {
-                let pattern_parts = pattern.split(":").collect::<Vec<_>>();
+                .chain(target.split(':')).collect::<Vec<_>>();
+            for pattern in var.split_terminator(',') {
+                let pattern_parts = pattern.split(':').collect::<Vec<_>>();
                 if pattern_parts.len() > target_parts.len() { continue }
                 for (&pattern_part, &target_part) in pattern_parts.iter()
                     .chain(std::iter::repeat(&"*")).zip(&target_parts) {