Clippy

src/bt.rs

@@ -709,7 +709,7 @@ where
     }
 }
 
-impl<'d, M> Drop for BtDriver<'d, M>
+impl<M> Drop for BtDriver<'_, M>
 where
     M: BtMode,
 {
@@ -724,5 +724,5 @@ where
     }
 }
 
-unsafe impl<'d, M> Send for BtDriver<'d, M> where M: BtMode {}
-unsafe impl<'d, M> Sync for BtDriver<'d, M> where M: BtMode {}
+unsafe impl<M> Send for BtDriver<'_, M> where M: BtMode {}
+unsafe impl<M> Sync for BtDriver<'_, M> where M: BtMode {}

src/bt/ble/gap.rs

@@ -182,7 +182,7 @@ pub struct AdvConfiguration<'a> {
     pub manufacturer_data: Option<&'a [u8]>,
 }
 
-impl<'a> Default for AdvConfiguration<'a> {
+impl Default for AdvConfiguration<'_> {
     fn default() -> Self {
         Self {
             set_scan_rsp: false,
@@ -231,7 +231,7 @@ impl<'a> From<&'a AdvConfiguration<'a>> for esp_ble_adv_data_t {
 
 pub struct EventRawData<'a>(pub &'a esp_ble_gap_cb_param_t);
 
-impl<'a> Debug for EventRawData<'a> {
+impl Debug for EventRawData<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("EventRawData").finish()
     }

src/bt/ble/gatt/server.rs

@@ -18,7 +18,7 @@ pub type TransferId = u32;
 
 pub struct EventRawData<'a>(pub &'a esp_ble_gatts_cb_param_t);
 
-impl<'a> Debug for EventRawData<'a> {
+impl Debug for EventRawData<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("EventRawData").finish()
     }

src/espnow.rs

@@ -241,7 +241,7 @@ impl<'a> EspNow<'a> {
     }
 }
 
-impl<'a> Drop for EspNow<'a> {
+impl Drop for EspNow<'_> {
     fn drop(&mut self) {
         let mut taken = TAKEN.lock();
 

src/eth.rs

@@ -1076,7 +1076,7 @@ impl<'d, T> EthDriver<'d, T> {
     }
 }
 
-impl<'d, T> Eth for EthDriver<'d, T> {
+impl<T> Eth for EthDriver<'_, T> {
     type Error = EspError;
 
     fn start(&mut self) -> Result<(), Self::Error> {
@@ -1096,17 +1096,17 @@ impl<'d, T> Eth for EthDriver<'d, T> {
     }
 }
 
-unsafe impl<'d, T> Send for EthDriver<'d, T> {}
+unsafe impl<T> Send for EthDriver<'_, T> {}
 
-impl<'d, T> Drop for EthDriver<'d, T> {
+impl<T> Drop for EthDriver<'_, T> {
     fn drop(&mut self) {
         self.clear_all().unwrap();
 
         info!("EthDriver dropped");
     }
 }
 
-impl<'d, T> RawHandle for EthDriver<'d, T> {
+impl<T> RawHandle for EthDriver<'_, T> {
     type Handle = esp_eth_handle_t;
 
     fn handle(&self) -> Self::Handle {
@@ -1261,7 +1261,7 @@ impl<'d, T> EspEth<'d, T> {
 }
 
 #[cfg(esp_idf_comp_esp_netif_enabled)]
-impl<'d, T> Drop for EspEth<'d, T> {
+impl<T> Drop for EspEth<'_, T> {
     fn drop(&mut self) {
         self.detach_netif().unwrap();
 
@@ -1270,10 +1270,10 @@ impl<'d, T> Drop for EspEth<'d, T> {
 }
 
 #[cfg(esp_idf_comp_esp_netif_enabled)]
-unsafe impl<'d, T> Send for EspEth<'d, T> {}
+unsafe impl<T> Send for EspEth<'_, T> {}
 
 #[cfg(esp_idf_comp_esp_netif_enabled)]
-impl<'d, T> RawHandle for EspEth<'d, T> {
+impl<T> RawHandle for EspEth<'_, T> {
     type Handle = *mut esp_eth_netif_glue_t;
 
     fn handle(&self) -> Self::Handle {
@@ -1282,7 +1282,7 @@ impl<'d, T> RawHandle for EspEth<'d, T> {
 }
 
 #[cfg(esp_idf_comp_esp_netif_enabled)]
-impl<'d, T> Eth for EspEth<'d, T> {
+impl<T> Eth for EspEth<'_, T> {
     type Error = EspError;
 
     fn start(&mut self) -> Result<(), Self::Error> {
@@ -1303,7 +1303,7 @@ impl<'d, T> Eth for EspEth<'d, T> {
 }
 
 #[cfg(esp_idf_comp_esp_netif_enabled)]
-impl<'d, T> NetifStatus for EspEth<'d, T> {
+impl<T> NetifStatus for EspEth<'_, T> {
     fn is_up(&self) -> Result<bool, EspError> {
         EspEth::is_up(self)
     }

src/eventloop.rs

@@ -49,7 +49,7 @@ pub struct BackgroundLoopConfiguration<'a> {
     pub task_pin_to_core: Core,
 }
 
-impl<'a> Default for BackgroundLoopConfiguration<'a> {
+impl Default for BackgroundLoopConfiguration<'_> {
     fn default() -> Self {
         Self {
             queue_size: 64,
@@ -217,13 +217,13 @@ impl<'a> EspEventPostData<'a> {
     }
 }
 
-unsafe impl<'a> EspEventSource for EspEventPostData<'a> {
+unsafe impl EspEventSource for EspEventPostData<'_> {
     fn source() -> Option<&'static ffi::CStr> {
         None
     }
 }
 
-impl<'a> EspEventSerializer for EspEventPostData<'a> {
+impl EspEventSerializer for EspEventPostData<'_> {
     type Data<'d> = EspEventPostData<'d>;
 
     fn serialize<F, R>(data: &Self::Data<'_>, f: F) -> R
@@ -268,13 +268,13 @@ impl<'a> EspEvent<'a> {
     }
 }
 
-unsafe impl<'a> EspEventSource for EspEvent<'a> {
+unsafe impl EspEventSource for EspEvent<'_> {
     fn source() -> Option<&'static ffi::CStr> {
         None
     }
 }
 
-impl<'a> EspEventDeserializer for EspEvent<'a> {
+impl EspEventDeserializer for EspEvent<'_> {
     type Data<'d> = EspEvent<'d>;
 
     fn deserialize<'d>(data: &EspEvent<'d>) -> Self::Data<'d> {
@@ -343,7 +343,7 @@ where
     _callback: Box<Box<dyn FnMut(EspEvent) + Send + 'a>>,
 }
 
-impl<'a, T> EspSubscription<'a, T>
+impl<T> EspSubscription<'_, T>
 where
     T: EspEventLoopType,
 {
@@ -369,9 +369,9 @@ where
     }
 }
 
-unsafe impl<'a, T> Send for EspSubscription<'a, T> where T: EspEventLoopType {}
+unsafe impl<T> Send for EspSubscription<'_, T> where T: EspEventLoopType {}
 
-impl<'a, T> Drop for EspSubscription<'a, T>
+impl<T> Drop for EspSubscription<'_, T>
 where
     T: EspEventLoopType,
 {
@@ -404,7 +404,7 @@ where
     }
 }
 
-impl<'a, T> RawHandle for EspSubscription<'a, User<T>>
+impl<T> RawHandle for EspSubscription<'_, User<T>>
 where
     T: EspEventLoopType,
 {

src/fs/fatfs.rs

@@ -80,7 +80,7 @@ pub struct MountedFatfs<'a, T> {
     fatfs: Box<FATFS>,
 }
 
-impl<'a, T> MountedFatfs<'a, T> {
+impl<T> MountedFatfs<'_, T> {
     /// Get the underlying FATFS instance.
     pub fn fatfs(&self) -> &FATFS {
         &self.fatfs
@@ -89,7 +89,7 @@ impl<'a, T> MountedFatfs<'a, T> {
     // TODO: Add safe methods to interact with the filesystem
 }
 
-impl<'a, T> Drop for MountedFatfs<'a, T> {
+impl<T> Drop for MountedFatfs<'_, T> {
     fn drop(&mut self) {
         let drive_path = self.fs.drive_path();
 

src/http/server.rs

@@ -670,13 +670,13 @@ impl<'a> EspHttpServer<'a> {
     }
 }
 
-impl<'a> Drop for EspHttpServer<'a> {
+impl Drop for EspHttpServer<'_> {
     fn drop(&mut self) {
         self.stop().expect("Unable to stop the server cleanly");
     }
 }
 
-impl<'a> RawHandle for EspHttpServer<'a> {
+impl RawHandle for EspHttpServer<'_> {
     type Handle = httpd_handle_t;
 
     fn handle(&self) -> Self::Handle {
@@ -740,7 +740,7 @@ impl<H, N> NonstaticChain<H, N> {
     }
 }
 
-unsafe impl<'a> EspHttpTraversableChainNonstatic<'a> for ChainRoot {}
+unsafe impl EspHttpTraversableChainNonstatic<'_> for ChainRoot {}
 
 impl<'a, H, N> EspHttpTraversableChain<'a> for NonstaticChain<H, N>
 where
@@ -767,7 +767,7 @@ where
 
 pub struct EspHttpRawConnection<'a>(&'a mut httpd_req_t);
 
-impl<'a> EspHttpRawConnection<'a> {
+impl EspHttpRawConnection<'_> {
     pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, EspError> {
         if !buf.is_empty() {
             let fd = unsafe { httpd_req_to_sockfd(self.0) };
@@ -801,25 +801,25 @@ impl<'a> EspHttpRawConnection<'a> {
     }
 }
 
-impl<'a> RawHandle for EspHttpRawConnection<'a> {
+impl RawHandle for EspHttpRawConnection<'_> {
     type Handle = *mut httpd_req_t;
 
     fn handle(&self) -> Self::Handle {
         self.0 as *const _ as *mut _
     }
 }
 
-impl<'a> ErrorType for EspHttpRawConnection<'a> {
+impl ErrorType for EspHttpRawConnection<'_> {
     type Error = EspIOError;
 }
 
-impl<'a> Read for EspHttpRawConnection<'a> {
+impl Read for EspHttpRawConnection<'_> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         EspHttpRawConnection::read(self, buf).map_err(EspIOError)
     }
 }
 
-impl<'a> Write for EspHttpRawConnection<'a> {
+impl Write for EspHttpRawConnection<'_> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         EspHttpRawConnection::write(self, buf).map_err(EspIOError)
     }
@@ -1130,15 +1130,15 @@ impl<'a> EspHttpConnection<'a> {
     }
 }
 
-impl<'a> RawHandle for EspHttpConnection<'a> {
+impl RawHandle for EspHttpConnection<'_> {
     type Handle = *mut httpd_req_t;
 
     fn handle(&self) -> Self::Handle {
         self.request.handle()
     }
 }
 
-impl<'a> Query for EspHttpConnection<'a> {
+impl Query for EspHttpConnection<'_> {
     fn uri(&self) -> &str {
         EspHttpConnection::uri(self)
     }
@@ -1148,23 +1148,23 @@ impl<'a> Query for EspHttpConnection<'a> {
     }
 }
 
-impl<'a> embedded_svc::http::Headers for EspHttpConnection<'a> {
+impl embedded_svc::http::Headers for EspHttpConnection<'_> {
     fn header(&self, name: &str) -> Option<&str> {
         EspHttpConnection::header(self, name)
     }
 }
 
-impl<'a> ErrorType for EspHttpConnection<'a> {
+impl ErrorType for EspHttpConnection<'_> {
     type Error = EspIOError;
 }
 
-impl<'a> Read for EspHttpConnection<'a> {
+impl Read for EspHttpConnection<'_> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
         EspHttpConnection::read(self, buf).map_err(EspIOError)
     }
 }
 
-impl<'a> Write for EspHttpConnection<'a> {
+impl Write for EspHttpConnection<'_> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
         EspHttpConnection::write(self, buf).map_err(EspIOError)
     }