chore: clippy nursery

Author: StuartHarris

.github/workflows/build.yaml

@@ -42,7 +42,7 @@ jobs:
         shell: bash
         run: |
           cargo fmt --all --check
-          cargo clippy -- --no-deps -Dclippy::pedantic -Dwarnings
+          cargo clippy -- --no-deps -Dclippy::pedantic -Dclippy::nursery -Dwarnings
 
       - uses: pnpm/action-setup@v4
         with:

Cargo.lock

@@ -33,6 +33,7 @@ uniffi_bindgen = "=0.29.4"
 
 [workspace.lints.clippy]
 pedantic = "warn"
+nursery = "warn"
 
 [workspace.lints.rust]
 unsafe_code = "forbid"

Cargo.toml

@@ -13,7 +13,7 @@ check:
     @echo '{{ style("command") }}check:{{ NORMAL }}'
     cargo fmt --all --check
     cargo check --all-features
-    cargo clippy --all-targets -- --no-deps -Dclippy::pedantic -Dwarnings
+    cargo clippy --all-targets -- --no-deps -Dclippy::pedantic -Dclippy::nursery -Dwarnings
 
 # Clean build artefacts in the root workspace and all examples
 clean:

Justfile

@@ -38,8 +38,9 @@ pub trait FfiFormat: Debug + 'static {
     fn deserialize<'de, T: Deserialize<'de>>(bytes: &'de [u8]) -> Result<T, Self::Error>;
 }
 
-/// Request for a side-effect passed from the Core to the Shell. The `EffectId` links
-/// the `Request` with the corresponding call to [`Core::resolve`] to pass the data back
+/// Request for a side-effect passed from the Core to the Shell.
+///
+/// The `EffectId` links the `Request` with the corresponding call to [`Core::resolve`] to pass the data back
 /// to the [`App::update`] function (wrapped in the event provided to the capability originating the effect).
 // used in docs/internals/bridge.md
 // ANCHOR: request

crux_core/src/bridge/mod.rs

@@ -62,7 +62,7 @@ impl<T: FfiFormat> ResolveRegistry<T> {
 
         let resolved = entry.resolve(response);
 
-        if let ResolveSerialized::Never = entry {
+        if matches!(entry, ResolveSerialized::Never) {
             registry_lock.remove(id.0 as usize);
         }
 

crux_core/src/bridge/registry.rs

@@ -27,12 +27,11 @@ pub enum ResolveSerialized<T: FfiFormat> {
 impl<T: FfiFormat> ResolveSerialized<T> {
     pub(crate) fn resolve(&mut self, response: &[u8]) -> Result<(), BridgeError<T>> {
         match self {
-            ResolveSerialized::Never => Err(BridgeError::ProcessResponse(ResolveError::Never)),
-            ResolveSerialized::Many(f) => f(response),
-            ResolveSerialized::Once(_) => {
+            Self::Never => Err(BridgeError::ProcessResponse(ResolveError::Never)),
+            Self::Many(f) => f(response),
+            Self::Once(_) => {
                 // The resolve has been used, turn it into a Never
-                let ResolveSerialized::Once(f) = std::mem::replace(self, ResolveSerialized::Never)
-                else {
+                let Self::Once(f) = std::mem::replace(self, Self::Never) else {
                     unreachable!("already resolved");
                 };
 
@@ -77,13 +76,13 @@ impl<Out> RequestHandle<Out> {
         Out: 'static,
     {
         match self {
-            RequestHandle::Never => ResolveSerialized::Never,
-            RequestHandle::Once(resolve) => ResolveSerialized::Once(Box::new(move |response| {
+            Self::Never => ResolveSerialized::Never,
+            Self::Once(resolve) => ResolveSerialized::Once(Box::new(move |response| {
                 let out = func(response)?;
                 resolve(out);
                 Ok(())
             })),
-            RequestHandle::Many(resolve) => ResolveSerialized::Many(Box::new(move |response| {
+            Self::Many(resolve) => ResolveSerialized::Many(Box::new(move |response| {
                 let out = func(response)?;
                 resolve(out).map_err(|()| BridgeError::ProcessResponse(ResolveError::FinishedMany))
             })),

crux_core/src/bridge/request_serde.rs

@@ -30,7 +30,7 @@ where
     {
         let make_task = Box::new(make_task);
 
-        NotificationBuilder { make_task }
+        Self { make_task }
     }
 
     /// Convert the [`NotificationBuilder`] into a future to use in an async context
@@ -53,7 +53,7 @@ where
     Task: Future<Output = ()> + Send + 'static,
 {
     fn from(value: NotificationBuilder<Effect, Event, Task>) -> Self {
-        Command::new(|ctx| value.into_future(ctx))
+        Self::new(|ctx| value.into_future(ctx))
     }
 }
 
@@ -75,14 +75,14 @@ where
     {
         let make_task = Box::new(make_task);
 
-        RequestBuilder { make_task }
+        Self { make_task }
     }
 
     pub fn map<F, U>(self, map: F) -> RequestBuilder<Effect, Event, impl Future<Output = U>>
     where
         F: FnOnce(T) -> U + Send + 'static,
     {
-        RequestBuilder::new(|ctx| self.into_future(ctx.clone()).map(map))
+        RequestBuilder::new(|ctx| self.into_future(ctx).map(map))
     }
 
     /// Chain a [`NotificationBuilder`] to run after completion of this one,
@@ -409,7 +409,7 @@ where
     {
         let make_task = Box::new(make_task);
 
-        StreamBuilder {
+        Self {
             make_stream: make_task,
         }
     }
@@ -418,7 +418,7 @@ where
     where
         F: FnMut(T) -> U + Send + 'static,
     {
-        StreamBuilder::new(|ctx| self.into_stream(ctx.clone()).map(map))
+        StreamBuilder::new(|ctx| self.into_stream(ctx).map(map))
     }
 
     /// Chain a [`RequestBuilder`] to run after completion of this [`StreamBuilder`],

crux_core/src/command/builder.rs

@@ -145,7 +145,7 @@ impl<Effect, Event> CommandContext<Effect, Event> {
     // ANCHOR: spawn
     pub fn spawn<F, Fut>(&self, make_future: F) -> JoinHandle
     where
-        F: FnOnce(CommandContext<Effect, Event>) -> Fut,
+        F: FnOnce(Self) -> Fut,
         Fut: Future<Output = ()> + Send + 'static,
     {
         let (sender, receiver) = crossbeam_channel::unbounded();
@@ -185,22 +185,21 @@ impl<T: Unpin + Send> ShellStream<T> {
         send_request: impl FnOnce() + Send + 'static,
         output_receiver: mpsc::UnboundedReceiver<T>,
     ) -> Self {
-        ShellStream::ReadyToSend(Box::new(send_request), output_receiver)
+        Self::ReadyToSend(Box::new(send_request), output_receiver)
     }
 
     fn send(&mut self) {
         // Since neither part is Clone, we'll need to do an Indiana Jones
 
         // 1. take items out of self
-        let dummy = ShellStream::Sent(mpsc::unbounded().1);
-        let ShellStream::ReadyToSend(send_request, output_receiver) =
-            std::mem::replace(self, dummy)
+        let dummy = Self::Sent(mpsc::unbounded().1);
+        let Self::ReadyToSend(send_request, output_receiver) = std::mem::replace(self, dummy)
         else {
             unreachable!("cannot send");
         };
 
         // 2. replace self with with a Sent using the original receiver
-        *self = ShellStream::Sent(output_receiver);
+        *self = Self::Sent(output_receiver);
 
         send_request();
     }
@@ -211,15 +210,15 @@ impl<T: Unpin + Send> Stream for ShellStream<T> {
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         match *self {
-            ShellStream::ReadyToSend(_, ref mut output_receiver) => {
+            Self::ReadyToSend(_, ref mut output_receiver) => {
                 let poll = pin!(output_receiver).poll_next(cx);
                 assert!(matches!(poll, Poll::Pending)); // we have not sent the request yet
 
                 self.send();
 
                 Poll::Pending
             }
-            ShellStream::Sent(ref mut output_receiver) => pin!(output_receiver).poll_next(cx),
+            Self::Sent(ref mut output_receiver) => pin!(output_receiver).poll_next(cx),
         }
     }
 }

crux_core/src/command/context.rs

@@ -15,11 +15,11 @@ use futures::task::AtomicWaker;
 
 use std::sync::Arc;
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) struct TaskId(pub(crate) usize);
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TaskId(pub(crate) usize);
 
 // ANCHOR: task
-pub(crate) struct Task {
+pub struct Task {
     // Used to wake the join handle when the task concludes
     pub(crate) join_handle_wakers: Receiver<Waker>,
     // Set to true when the task finishes, used by the join handle
@@ -52,7 +52,7 @@ impl Task {
 // Waking a task also wakes the command itself, if it is being used as a Stream
 // inside another Command (or hosted with a CommandSink)
 // ANCHOR: command_waker
-pub(crate) struct CommandWaker {
+pub struct CommandWaker {
     pub(crate) task_id: TaskId,
     pub(crate) ready_queue: Sender<TaskId>,
     // Waker for the executor running this command as a Stream.
@@ -139,8 +139,8 @@ impl Future for JoinHandle {
     }
 }
 
-#[derive(Debug, PartialEq)]
-pub(crate) enum TaskState {
+#[derive(Debug, PartialEq, Eq)]
+pub enum TaskState {
     Missing,
     Suspended,
     Completed,