Clippy and rust lint fixes

Author: rnijveld

Cargo.toml

@@ -20,12 +20,11 @@ authors = [
     "Folkert de Vries <[email protected]>",
     "Dion Dokter <[email protected]>",
     "Ruben Nijveld <[email protected]>",
-    "David Venhoek <[email protected]>",
     "Bram Bruines <[email protected]>",
     "Marlon Peeters <[email protected]>",
     "Rick van der Wal <[email protected]>"
 ]
-rust-version = "1.67" # MSRV
+rust-version = "1.69" # MSRV
 
 [workspace.dependencies]
 arrayvec = { version = "0.7.4", default-features = false }

statime-linux/src/tlvforwarder.rs

@@ -51,7 +51,7 @@ impl TlvForwarder {
 }
 
 impl ForwardedTLVProvider for TlvForwarder {
-    fn next_if_smaller(&mut self, max_size: usize) -> Option<statime::port::ForwardedTLV> {
+    fn next_if_smaller(&mut self, max_size: usize) -> Option<statime::port::ForwardedTLV<'_>> {
         use tokio::sync::broadcast::error::TryRecvError;
 
         while self.peek.is_none() {

statime/src/bmc/bmca.rs

@@ -295,7 +295,6 @@ pub(crate) enum RecommendedState {
 }
 
 #[cfg(test)]
-
 mod tests {
     use super::*;
     use crate::{
@@ -540,8 +539,10 @@ mod tests {
         let slave_only = false;
         let sdo_id = Default::default();
         let path_trace = false;
-        let mut clock_quality = ClockQuality::default();
-        clock_quality.clock_class = 1;
+        let clock_quality = ClockQuality {
+            clock_class: 1,
+            ..Default::default()
+        };
         assert!((1..=127).contains(&clock_quality.clock_class));
 
         let own_data = InternalDefaultDS::new(InstanceConfig {
@@ -673,9 +674,6 @@ mod tests {
             )
         );
 
-        // D0 is NOT better than E_best
-        let mut own_data = own_data;
-
         let mut global_message = default_best_announce_message();
 
         own_data.clock_identity = ClockIdentity([0; 8]);

statime/src/port/actions.rs

@@ -33,15 +33,15 @@ impl ForwardedTLV<'_> {
 /// Source of TLVs that need to be forwarded, provided to announce sender.
 pub trait ForwardedTLVProvider {
     /// Should provide the next available TLV, unless it is larger than max_size
-    fn next_if_smaller(&mut self, max_size: usize) -> Option<ForwardedTLV>;
+    fn next_if_smaller(&mut self, max_size: usize) -> Option<ForwardedTLV<'_>>;
 }
 
 /// Simple implementation when
 #[derive(Debug, Copy, Clone)]
 pub struct NoForwardedTLVs;
 
 impl ForwardedTLVProvider for NoForwardedTLVs {
-    fn next_if_smaller(&mut self, _max_size: usize) -> Option<ForwardedTLV> {
+    fn next_if_smaller(&mut self, _max_size: usize) -> Option<ForwardedTLV<'_>> {
         None
     }
 }

statime/src/port/master.rs

@@ -13,7 +13,7 @@ use crate::{
 };
 
 impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F, S> {
-    pub(super) fn send_sync(&mut self) -> PortActionIterator {
+    pub(super) fn send_sync(&mut self) -> PortActionIterator<'_> {
         if matches!(self.port_state, PortState::Master) {
             log::trace!("sending sync message");
 
@@ -54,7 +54,11 @@ impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F,
         }
     }
 
-    pub(super) fn handle_sync_timestamp(&mut self, id: u16, timestamp: Time) -> PortActionIterator {
+    pub(super) fn handle_sync_timestamp(
+        &mut self,
+        id: u16,
+        timestamp: Time,
+    ) -> PortActionIterator<'_> {
         if matches!(self.port_state, PortState::Master) {
             let packet_length = match self
                 .instance_state
@@ -91,7 +95,7 @@ impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F,
     pub(super) fn send_announce(
         &mut self,
         tlv_provider: &mut impl ForwardedTLVProvider,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         if matches!(self.port_state, PortState::Master) {
             log::trace!("sending announce message");
 
@@ -189,7 +193,7 @@ impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F,
         header: Header,
         message: DelayReqMessage,
         timestamp: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         if matches!(self.port_state, PortState::Master) {
             log::debug!("Received DelayReq");
             let delay_resp_message = Message::delay_resp(
@@ -221,7 +225,7 @@ impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F,
         &mut self,
         header: Header,
         timestamp: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         log::debug!("Received PDelayReq");
         let pdelay_resp_message = self.instance_state.with_ref(|state| {
             Message::pdelay_resp(
@@ -258,7 +262,7 @@ impl<A, C, F: Filter, R, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F,
         id: u16,
         requestor_identity: PortIdentity,
         timestamp: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         let pdelay_resp_follow_up_messgae = self.instance_state.with_ref(|state| {
             Message::pdelay_resp_follow_up(
                 &state.default_ds,
@@ -718,7 +722,6 @@ mod tests {
             response_body.request_receive_timestamp,
             Time::from_micros(500).into()
         );
-        drop(response);
         assert!(actions.next().is_none());
         drop(actions);
 
@@ -740,7 +743,6 @@ mod tests {
             response_body.response_origin_timestamp,
             Time::from_micros(550).into()
         );
-        drop(response);
         assert!(actions.next().is_none());
         drop(actions);
     }

statime/src/port/mod.rs

@@ -414,7 +414,7 @@ impl<'a, A: AcceptableMasterList, C: Clock, F: Filter, R: Rng, S: PtpInstanceSta
     }
 
     /// Handle the filter update timer going off
-    pub fn handle_filter_update_timer(&mut self) -> PortActionIterator {
+    pub fn handle_filter_update_timer(&mut self) -> PortActionIterator<'_> {
         let update = self.filter.update(&mut self.clock);
         if update.mean_delay.is_some() {
             self.mean_delay = update.mean_delay;
@@ -779,7 +779,7 @@ mod tests {
         port_identity: PortIdentity,
     ) -> Port<'_, Running, AcceptAnyMaster, rand::rngs::mock::StepRng, TestClock, BasicFilter> {
         let port = Port::<_, _, _, _, BasicFilter>::new(
-            &state,
+            state,
             PortConfig {
                 acceptable_master_list: AcceptAnyMaster,
                 delay_mechanism: DelayMechanism::E2E {
@@ -844,13 +844,12 @@ mod tests {
 
         let parent_ds = InternalParentDS::new(default_ds);
 
-        let state = RefCell::new(PtpInstanceState {
+        RefCell::new(PtpInstanceState {
             default_ds,
             current_ds: Default::default(),
             parent_ds,
             time_properties_ds: Default::default(),
             path_trace_ds: PathTraceDS::new(false),
-        });
-        state
+        })
     }
 }

statime/src/port/slave.rs

@@ -36,7 +36,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         &mut self,
         timestamp_id: u16,
         timestamp: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.port_state {
             PortState::Slave(ref mut state) => match state.delay_state {
                 DelayState::Measuring {
@@ -68,7 +68,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         &mut self,
         timestamp_id: u16,
         timestamp: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.peer_delay_state {
             PeerDelayState::Measuring {
                 id,
@@ -98,7 +98,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         header: Header,
         message: SyncMessage,
         recv_time: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.port_state {
             PortState::Slave(ref mut state) => {
                 log::debug!("Received sync {:?}", header.sequence_id);
@@ -164,7 +164,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         &mut self,
         header: Header,
         message: FollowUpMessage,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.port_state {
             PortState::Slave(ref mut state) => {
                 log::debug!("Received FollowUp {:?}", header.sequence_id);
@@ -211,7 +211,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         &mut self,
         header: Header,
         message: DelayRespMessage,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.port_state {
             PortState::Slave(ref mut state) => {
                 log::debug!("Received DelayResp");
@@ -258,7 +258,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         header: Header,
         message: PDelayRespMessage,
         recv_time: Time,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         if self.port_identity != message.requesting_port_identity {
             return actions![];
         }
@@ -321,7 +321,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
         &mut self,
         header: Header,
         message: PDelayRespFollowUpMessage,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         if self.port_identity != message.requesting_port_identity {
             return actions![];
         }
@@ -457,7 +457,7 @@ impl<A, C: Clock, F: Filter, R, S> Port<'_, Running, A, R, C, F, S> {
 }
 
 impl<A, C: Clock, F: Filter, R: Rng, S: PtpInstanceStateMutex> Port<'_, Running, A, R, C, F, S> {
-    pub(super) fn send_delay_request(&mut self) -> PortActionIterator {
+    pub(super) fn send_delay_request(&mut self) -> PortActionIterator<'_> {
         match self.config.delay_mechanism {
             DelayMechanism::E2E { interval } => self.send_e2e_delay_request(interval),
             DelayMechanism::P2P { interval } => self.send_p2p_delay_request(interval),
@@ -467,7 +467,7 @@ impl<A, C: Clock, F: Filter, R: Rng, S: PtpInstanceStateMutex> Port<'_, Running,
     fn send_p2p_delay_request(
         &mut self,
         log_min_pdelay_req_interval: Interval,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         let pdelay_id = self.pdelay_seq_ids.generate();
 
         let pdelay_req = self.instance_state.with_ref(|state| {
@@ -516,7 +516,7 @@ impl<A, C: Clock, F: Filter, R: Rng, S: PtpInstanceStateMutex> Port<'_, Running,
     fn send_e2e_delay_request(
         &mut self,
         log_min_delay_req_interval: Interval,
-    ) -> PortActionIterator {
+    ) -> PortActionIterator<'_> {
         match self.port_state {
             PortState::Slave(ref mut state) => {
                 log::debug!("Starting new delay measurement");