warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/urc.rs:53:26
   |
53 |           let digest_arm = if let Some(parse_fn) = parse {
   |  __________________________^
54 | |             quote! {
55 | |                 #parse_fn(&#code[..]),
...  |
61 | |         };
   | |_________^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
   |
53 ~         let digest_arm = parse.map_or_else(|| quote! {
54 +                 atat::digest::parser::urc_helper(&#code[..]),
55 +             }, |parse_fn| quote! {
56 +                 #parse_fn(&#code[..]),
57 ~             });
   |

warning: `iter` call on a collection with only one item
  --> atat_derive/src/helpers.rs:55:17
   |
55 |         bounds: [trait_bound].iter().cloned().collect(),
   |                 ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&trait_bound)`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#iter_on_single_items
   = note: `-W clippy::iter-on-single-items` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::iter_on_single_items)]`

warning: use Option::map_or_else instead of an if let/else
   --> atat_derive/src/cmd.rs:108:17
    |
108 |       let parse = if let Some(parse) = parse {
    |  _________________^
109 | |         quote! {
110 | |             #[inline]
111 | |             fn parse(&self, res: Result<&[u8], atat::InternalError>) -> core::result::Result<Self::Response, atat::Error> {
...   |
132 | |     };
    | |_____^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
    |
108 ~     let parse = parse.map_or_else(|| quote! {
109 +             #[inline]
110 +            fn parse(&self, res: Result<&[u8], atat::InternalError>) -> core::result::Result<Self::Response, atat::Error> {
111 +                match res {
112 +                    Ok(resp) => atat::serde_at::from_slice::<#resp>(resp).map_err(|e| {
113 +                        atat::Error::Parse
114 +                    }),
115 +                    Err(e) => Err(e.into())
116 +                }
117 +            }
118 +         }, |parse| quote! {
119 +             #[inline]
120 +             fn parse(&self, res: Result<&[u8], atat::InternalError>) -> core::result::Result<Self::Response, atat::Error> {
121 +                 match res {
122 +                     Ok(resp) => #parse(resp).map_err(|e| {
123 +                         atat::Error::Parse
124 +                     }),
125 +                     Err(e) => Err(e.into())
126 +                 }
127 +             }
128 ~         });
    |

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/cmd.rs:74:34
   |
74 |       let reattempt_on_parse_err = match reattempt_on_parse_err {
   |  __________________________________^
75 | |         Some(reattempt_on_parse_err) => {
76 | |             quote! {
77 | |                 const REATTEMPT_ON_PARSE_ERR: bool = #reattempt_on_parse_err;
...  |
80 | |         None => quote! {},
81 | |     };
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
   |
74 ~     let reattempt_on_parse_err = reattempt_on_parse_err.map_or_else(|| quote! {}, |reattempt_on_parse_err| quote! {
75 +                 const REATTEMPT_ON_PARSE_ERR: bool = #reattempt_on_parse_err;
76 ~             });
   |

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/cmd.rs:65:20
   |
65 |       let response = match response_code {
   |  ____________________^
66 | |         Some(is_resp) => {
67 | |             quote! {
68 | |                 const EXPECTS_RESPONSE_CODE: bool = #is_resp;
...  |
71 | |         None => quote! {},
72 | |     };
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
   |
65 ~     let response = response_code.map_or_else(|| quote! {}, |is_resp| quote! {
66 +                 const EXPECTS_RESPONSE_CODE: bool = #is_resp;
67 ~             });
   |

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/cmd.rs:56:20
   |
56 |       let attempts = match attempts {
   |  ____________________^
57 | |         Some(attempts) => {
58 | |             quote! {
59 | |                 const ATTEMPTS: u8 = #attempts;
...  |
62 | |         None => quote! {},
63 | |     };
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
   |
56 ~     let attempts = attempts.map_or_else(|| quote! {}, |attempts| quote! {
57 +                 const ATTEMPTS: u8 = #attempts;
58 ~             });
   |

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/cmd.rs:47:21
   |
47 |       let abortable = match abortable {
   |  _____________________^
48 | |         Some(abortable) => {
49 | |             quote! {
50 | |                 const CAN_ABORT: bool = #abortable;
...  |
53 | |         None => quote! {},
54 | |     };
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
help: try
   |
47 ~     let abortable = abortable.map_or_else(|| quote! {}, |abortable| quote! {
48 +                 const CAN_ABORT: bool = #abortable;
49 ~             });
   |

warning: use Option::map_or_else instead of an if let/else
  --> atat_derive/src/cmd.rs:38:19
   |
38 |       let timeout = match timeout_ms {
   |  ___________________^
39 | |         Some(timeout_ms) => {
40 | |             quote! {
41 | |                 const MAX_TIMEOUT_MS: u32 = #timeout_ms;
...  |
44 | |         None => quote! {},
45 | |     };
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#option_if_let_else
   = note: `-W clippy::option-if-let-else` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::option_if_let_else)]`
help: try
   |
38 ~     let timeout = timeout_ms.map_or_else(|| quote! {}, |timeout_ms| quote! {
39 +                 const MAX_TIMEOUT_MS: u32 = #timeout_ms;
40 ~             });
   |

warning: usage of wildcard import
 --> examples/src/common/general/mod.rs:6:5
  |
6 | use responses::*;
  |     ^^^^^^^^^^^^ help: try: `responses::{ManufacturerId, ModelId, SoftwareVersion, WifiMac}`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#wildcard_imports
  = note: `-W clippy::wildcard-imports` implied by `-W clippy::pedantic`
  = help: to override `-W clippy::pedantic` add `#[allow(clippy::wildcard_imports)]`

warning: multiple versions for dependency `nb`: 0.1.3, 1.1.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#multiple_crate_versions

warning: multiple versions for dependency `heapless-bytes`: 0.3.0, 0.4.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#multiple_crate_versions

warning: multiple versions for dependency `heapless`: 0.7.17, 0.8.0, 0.9.2
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#multiple_crate_versions

warning: multiple versions for dependency `hash32`: 0.2.1, 0.3.1
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#multiple_crate_versions

warning: multiple versions for dependency `embedded-hal`: 0.2.7, 1.0.0
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#multiple_crate_versions
  = note: `-W clippy::multiple-crate-versions` implied by `-W clippy::cargo`
  = help: to override `-W clippy::cargo` add `#[allow(clippy::multiple_crate_versions)]`

warning: this argument is a mutable reference, but not used mutably
  --> atat/src/blocking/client.rs:69:9
   |
69 |         &'guard mut self,
   |         ^^^^^^^^^^^^^^^^ help: consider changing to: `&self`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#needless_pass_by_ref_mut

warning: this argument is a mutable reference, but not used mutably
  --> atat/src/asynch/client.rs:69:9
   |
69 |         &'guard mut self,
   |         ^^^^^^^^^^^^^^^^ help: consider changing to: `&self`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#needless_pass_by_ref_mut
   = note: `-W clippy::needless-pass-by-ref-mut` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::needless_pass_by_ref_mut)]`

warning: unnecessary boolean `not` operation
   --> atat/src/blocking/client.rs:111:9
    |
111 | /         if !Cmd::EXPECTS_RESPONSE_CODE {
112 | |             cmd.parse(Ok(&[]))
113 | |         } else {
114 | |             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
115 | |             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
116 | |             cmd.parse(response.into())
117 | |         }
    | |_________^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#if_not_else
help: try
    |
111 ~         if Cmd::EXPECTS_RESPONSE_CODE {
112 +             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
113 +             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
114 +             cmd.parse(response.into())
115 +         } else {
116 +             cmd.parse(Ok(&[]))
117 +         }
    |

warning: temporary with significant `Drop` can be early dropped
   --> atat/src/blocking/client.rs:114:17
    |
113 |           } else {
    |  ________________-
114 | |             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?;
    | |                 ^^^^^^^^
115 | |             let response: &Response<INGRESS_BUF_SIZE> = &response.borrow();
116 | |             cmd.parse(response.into())
117 | |         }
    | |_________- temporary `response` is currently being dropped at the end of its contained scope
    |
    = note: this might lead to unnecessary resource contention
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#significant_drop_tightening
help: merge the temporary construction with its single usage
    |
114 ~             
115 +             let response = self.wait_response(Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()))?.;
116 ~             
    |

warning: the following explicit lifetimes could be elided: 'guard
  --> atat/src/blocking/client.rs:68:22
   |
68 |     fn wait_response<'guard>(
   |                      ^^^^^^
69 |         &'guard mut self,
   |          ^^^^^^
70 |         timeout: Duration,
71 |     ) -> Result<ResponseSlotGuard<'guard, INGRESS_BUF_SIZE>, Error> {
   |                                   ^^^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#elidable_lifetime_names
help: elide the lifetimes
   |
68 ~     fn wait_response(
69 ~         &mut self,
70 |         timeout: Duration,
71 ~     ) -> Result<ResponseSlotGuard<'_, INGRESS_BUF_SIZE>, Error> {
   |

warning: this could be a `const fn`
  --> atat/src/blocking/client.rs:31:5
   |
31 | /     pub fn new(
32 | |         writer: W,
33 | |         res_slot: &'a ResponseSlot<INGRESS_BUF_SIZE>,
34 | |         buf: &'a mut [u8],
...  |
44 | |     }
   | |_____^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#missing_const_for_fn
help: make the function `const`
   |
31 |     pub const fn new(
   |         +++++

warning: first doc comment paragraph is too long
  --> atat/src/blocking/client.rs:11:1
   |
11 | / /// Client responsible for handling send, receive and timeout from the
12 | | /// userfacing side. The client is decoupled from the ingress-manager through
13 | | /// some spsc queue consumers, where any received responses can be dequeued. The
14 | | /// Client also has an spsc producer, to allow signaling commands like
15 | | /// `reset` to the ingress-manager.
   | |_^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#too_long_first_doc_paragraph
   = note: `-W clippy::too-long-first-doc-paragraph` implied by `-W clippy::nursery`
   = help: to override `-W clippy::nursery` add `#[allow(clippy::too_long_first_doc_paragraph)]`

warning: future cannot be sent between threads safely
  --> atat/src/asynch/mod.rs:43:5
   |
43 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `send` is not `Send`
   |
note: future is not `Send` as it awaits another future which is not `Send`
  --> atat/src/asynch/mod.rs:44:9
   |
44 |         T::send(self, cmd).await
   |         ^^^^^^^^^^^^^^^^^^ await occurs here on type `impl futures::Future<Output = core::result::Result<<Cmd as traits::AtatCmd>::Response, error::Error>>`, which is not `Send`
   = note: `impl futures::Future<Output = core::result::Result<<Cmd as traits::AtatCmd>::Response, error::Error>>` doesn't implement `core::marker::Send`
note: captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
  --> atat/src/asynch/mod.rs:43:44
   |
43 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
   |                                            ^^^ has type `&Cmd` which is not `Send`, because `Cmd` is not `Sync`
   = note: `Cmd` doesn't implement `core::marker::Sync`
note: captured value is not `Send` because `&mut` references cannot be sent unless their referent is `Send`
  --> atat/src/asynch/mod.rs:43:33
   |
43 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
   |                                 ^^^^^^^^^ has type `&mut &mut T` which is not `Send`, because `&mut T` is not `Send`
   = note: `T` doesn't implement `core::marker::Send`
   = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#future_not_send

warning: unnecessary boolean `not` operation
   --> atat/src/asynch/simple_client.rs:149:9
    |
149 | /         if !Cmd::EXPECTS_RESPONSE_CODE {
150 | |             cmd.parse(Ok(&[]))
151 | |         } else {
152 | |             let response = embassy_time::with_timeout(
...   |
159 | |             cmd.parse((&response).into())
160 | |         }
    | |_________^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#if_not_else
help: try
    |
149 ~         if Cmd::EXPECTS_RESPONSE_CODE {
150 +             let response = embassy_time::with_timeout(
151 +                 Duration::from_millis(Cmd::MAX_TIMEOUT_MS.into()),
152 +                 self.wait_response(),
153 +             )
154 +             .await
155 +             .map_err(|_| Error::Timeout)??;
156 + 
157 +             cmd.parse((&response).into())
158 +         } else {
159 +             cmd.parse(Ok(&[]))
160 +         }
    |

warning: future cannot be sent between threads safely
   --> atat/src/asynch/simple_client.rs:145:5
    |
145 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `send` is not `Send`
    |
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:148:32
    |
145 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                            --- has type `&Cmd` which is not `Send`
...
148 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `cmd` maybe used later
    = note: `Cmd` doesn't implement `core::marker::Sync`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:148:32
    |
145 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                 --------- has type `&mut asynch::simple_client::SimpleClient<'_, RW, D>` which is not `Send`
...
148 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `&mut self` maybe used later
    = note: `RW` doesn't implement `core::marker::Send`
note: future is not `Send` as this value is used across an await
   --> atat/src/asynch/simple_client.rs:148:32
    |
145 |     async fn send<Cmd: AtatCmd>(&mut self, cmd: &Cmd) -> Result<Cmd::Response, Error> {
    |                                 --------- has type `&mut asynch::simple_client::SimpleClient<'_, RW, D>` which is not `Send`
...
148 |         self.send_request(len).await?;
    |                                ^^^^^ await occurs here, with `&mut self` maybe used later
    = note: `D` doesn't implement `core::marker::Send`
note: future is not `Send` as it awaits another future which is not `Send`
   --> atat/src/asynch/simple_client.rs:37:9
    |
 37 |         with_timeout(self.config.tx_timeout, self.rw.write_all(&self.buf[..len]))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here on type `embassy_time::timer::TimeoutFuture<impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>>`, which is not `Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
note: future is not `Send` as it awaits another future which is not `Send`
   --> atat/src/asynch/simple_client.rs:42:9
    |
 42 |         with_timeout(self.config.flush_timeout, self.rw.flush())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here on type `embassy_time::timer::TimeoutFuture<impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>>`, which is not `Send`
    = note: `impl futures::Future<Output = core::result::Result<(), <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
note: future is not `Send` as it awaits another future which is not `Send`
   --> atat/src/asynch/simple_client.rs:53:19
    |
 53 |             match self.rw.read(&mut self.buf[self.pos..]).await {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here on type `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>`, which is not `Send`
    = note: `impl futures::Future<Output = core::result::Result<usize, <RW as embedded_io::ErrorType>::Error>>` doesn't implement `core::marker::Send`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#future_not_send

warning: consider adding a `;` to the last statement for consistent formatting
   --> atat/src/asynch/simple_client.rs:139:13
    |
139 |             cooldown.await
    |             ^^^^^^^^^^^^^^ help: add a `;` here: `cooldown.await;`
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.93.0/index.html#semicolon_if_nothing_returned