clippy

src/a.rs

@@ -85,7 +85,7 @@ impl<'a> IntoIterator for &'a AResults {
     }
 }
 
-impl<'a> AResult<'a> {
+impl AResult<'_> {
     /// Returns the IPv4 address in this `AResult`.
     pub fn ipv4(self) -> Ipv4Addr {
         ipv4_from_in_addr(self.addrttl.ipaddr)
@@ -99,7 +99,7 @@ impl<'a> AResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for AResult<'a> {
+impl fmt::Display for AResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "IPv4: {}, ", self.ipv4())?;
         write!(fmt, "TTL: {}", self.ttl())

src/aaaa.rs

@@ -86,7 +86,7 @@ impl<'a> IntoIterator for &'a AAAAResults {
     }
 }
 
-impl<'a> AAAAResult<'a> {
+impl AAAAResult<'_> {
     /// Returns the IPv6 address in this `AAAAResult`.
     pub fn ipv6(self) -> Ipv6Addr {
         let bytes = unsafe { self.addr6ttl.ip6addr._S6_un._S6_u8 };
@@ -101,7 +101,7 @@ impl<'a> AAAAResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for AAAAResult<'a> {
+impl fmt::Display for AAAAResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "IPv6: {}, ", self.ipv6())?;
         write!(fmt, "TTL: {}", self.ttl())

src/caa.rs

@@ -91,10 +91,10 @@ impl Drop for CAAResults {
 
 unsafe impl Send for CAAResults {}
 unsafe impl Sync for CAAResults {}
-unsafe impl<'a> Send for CAAResult<'a> {}
-unsafe impl<'a> Sync for CAAResult<'a> {}
-unsafe impl<'a> Send for CAAResultsIter<'a> {}
-unsafe impl<'a> Sync for CAAResultsIter<'a> {}
+unsafe impl Send for CAAResult<'_> {}
+unsafe impl Sync for CAAResult<'_> {}
+unsafe impl Send for CAAResultsIter<'_> {}
+unsafe impl Sync for CAAResultsIter<'_> {}
 
 impl<'a> CAAResult<'a> {
     /// Is the 'critical' flag set in this `CAAResult`?
@@ -113,7 +113,7 @@ impl<'a> CAAResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for CAAResult<'a> {
+impl fmt::Display for CAAResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "Critical: {}, ", self.critical())?;
         write!(fmt, "Property: {}, ", self.property())?;

src/channel.rs

@@ -1281,7 +1281,7 @@ pub struct GetSockIter<'a> {
     getsock: &'a GetSock,
 }
 
-impl<'a> Iterator for GetSockIter<'a> {
+impl Iterator for GetSockIter<'_> {
     type Item = (Socket, bool, bool);
     fn next(&mut self) -> Option<Self::Item> {
         let index = self.next;

src/host.rs

@@ -34,7 +34,7 @@ impl<'a> HostResults<'a> {
     }
 }
 
-impl<'a> fmt::Display for HostResults<'a> {
+impl fmt::Display for HostResults<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         self.hostent.fmt(fmt)
     }

src/hostent.rs

@@ -109,15 +109,15 @@ impl<'a> HasHostent<'a> for HostentBorrowed<'a> {
     }
 }
 
-impl<'a> fmt::Display for HostentBorrowed<'a> {
+impl fmt::Display for HostentBorrowed<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let hostent = self.hostent();
         display(hostent, fmt)
     }
 }
 
-unsafe impl<'a> Send for HostentBorrowed<'a> {}
-unsafe impl<'a> Sync for HostentBorrowed<'a> {}
+unsafe impl Send for HostentBorrowed<'_> {}
+unsafe impl Sync for HostentBorrowed<'_> {}
 
 // Get an IpAddr from a family and an array of bytes, as found in a `hostent`.
 unsafe fn ip_address_from_bytes(family: AddressFamily, h_addr: *const u8) -> Option<IpAddr> {
@@ -145,7 +145,7 @@ pub struct HostAddressResultsIter<'a> {
     next: &'a *const c_char,
 }
 
-impl<'a> Iterator for HostAddressResultsIter<'a> {
+impl Iterator for HostAddressResultsIter<'_> {
     type Item = IpAddr;
     fn next(&mut self) -> Option<Self::Item> {
         let h_addr = *self.next;
@@ -161,8 +161,8 @@ impl<'a> Iterator for HostAddressResultsIter<'a> {
     }
 }
 
-unsafe impl<'a> Send for HostAddressResultsIter<'a> {}
-unsafe impl<'a> Sync for HostAddressResultsIter<'a> {}
+unsafe impl Send for HostAddressResultsIter<'_> {}
+unsafe impl Sync for HostAddressResultsIter<'_> {}
 
 /// Iterator of `&'a str`s.
 #[derive(Clone, Copy, Debug)]
@@ -184,5 +184,5 @@ impl<'a> Iterator for HostAliasResultsIter<'a> {
     }
 }
 
-unsafe impl<'a> Send for HostAliasResultsIter<'a> {}
-unsafe impl<'a> Sync for HostAliasResultsIter<'a> {}
+unsafe impl Send for HostAliasResultsIter<'_> {}
+unsafe impl Sync for HostAliasResultsIter<'_> {}

src/mx.rs

@@ -92,10 +92,10 @@ impl Drop for MXResults {
 
 unsafe impl Send for MXResults {}
 unsafe impl Sync for MXResults {}
-unsafe impl<'a> Send for MXResult<'a> {}
-unsafe impl<'a> Sync for MXResult<'a> {}
-unsafe impl<'a> Send for MXResultsIter<'a> {}
-unsafe impl<'a> Sync for MXResultsIter<'a> {}
+unsafe impl Send for MXResult<'_> {}
+unsafe impl Sync for MXResult<'_> {}
+unsafe impl Send for MXResultsIter<'_> {}
+unsafe impl Sync for MXResultsIter<'_> {}
 
 impl<'a> MXResult<'a> {
     /// Returns the hostname in this `MXResult`.
@@ -109,7 +109,7 @@ impl<'a> MXResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for MXResult<'a> {
+impl fmt::Display for MXResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "Hostname: {}, ", self.host())?;
         write!(fmt, "Priority: {}", self.priority())

src/nameinfo.rs

@@ -29,7 +29,7 @@ impl<'a> NameInfoResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for NameInfoResult<'a> {
+impl fmt::Display for NameInfoResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let node = self.node().unwrap_or("<None>");
         write!(fmt, "Node: {node}, ")?;
@@ -38,8 +38,8 @@ impl<'a> fmt::Display for NameInfoResult<'a> {
     }
 }
 
-unsafe impl<'a> Send for NameInfoResult<'a> {}
-unsafe impl<'a> Sync for NameInfoResult<'a> {}
+unsafe impl Send for NameInfoResult<'_> {}
+unsafe impl Sync for NameInfoResult<'_> {}
 
 pub(crate) unsafe extern "C" fn get_name_info_callback<F>(
     arg: *mut c_void,

src/naptr.rs

@@ -92,10 +92,10 @@ impl Drop for NAPTRResults {
 
 unsafe impl Send for NAPTRResults {}
 unsafe impl Sync for NAPTRResults {}
-unsafe impl<'a> Send for NAPTRResult<'a> {}
-unsafe impl<'a> Sync for NAPTRResult<'a> {}
-unsafe impl<'a> Send for NAPTRResultsIter<'a> {}
-unsafe impl<'a> Sync for NAPTRResultsIter<'a> {}
+unsafe impl Send for NAPTRResult<'_> {}
+unsafe impl Sync for NAPTRResult<'_> {}
+unsafe impl Send for NAPTRResultsIter<'_> {}
+unsafe impl Sync for NAPTRResultsIter<'_> {}
 
 impl<'a> NAPTRResult<'a> {
     /// Returns the flags in this `NAPTRResult`.
@@ -129,7 +129,7 @@ impl<'a> NAPTRResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for NAPTRResult<'a> {
+impl fmt::Display for NAPTRResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "Flags: {}, ", self.flags())?;
         write!(fmt, "Service name: {}, ", self.service_name())?;

src/srv.rs

@@ -93,10 +93,10 @@ impl Drop for SRVResults {
 
 unsafe impl Send for SRVResults {}
 unsafe impl Sync for SRVResults {}
-unsafe impl<'a> Send for SRVResult<'a> {}
-unsafe impl<'a> Sync for SRVResult<'a> {}
-unsafe impl<'a> Send for SRVResultsIter<'a> {}
-unsafe impl<'a> Sync for SRVResultsIter<'a> {}
+unsafe impl Send for SRVResult<'_> {}
+unsafe impl Sync for SRVResult<'_> {}
+unsafe impl Send for SRVResultsIter<'_> {}
+unsafe impl Sync for SRVResultsIter<'_> {}
 
 impl<'a> SRVResult<'a> {
     /// Returns the hostname in this `SRVResult`.
@@ -120,7 +120,7 @@ impl<'a> SRVResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for SRVResult<'a> {
+impl fmt::Display for SRVResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "Host: {}, ", self.host())?;
         write!(fmt, "Port: {}, ", self.port())?;

src/txt.rs

@@ -90,12 +90,12 @@ impl Drop for TXTResults {
     }
 }
 
-unsafe impl<'a> Send for TXTResult<'a> {}
-unsafe impl<'a> Sync for TXTResult<'a> {}
+unsafe impl Send for TXTResult<'_> {}
+unsafe impl Sync for TXTResult<'_> {}
 unsafe impl Send for TXTResults {}
 unsafe impl Sync for TXTResults {}
-unsafe impl<'a> Send for TXTResultsIter<'a> {}
-unsafe impl<'a> Sync for TXTResultsIter<'a> {}
+unsafe impl Send for TXTResultsIter<'_> {}
+unsafe impl Sync for TXTResultsIter<'_> {}
 
 impl<'a> TXTResult<'a> {
     /// Is this the start of a text record, or the continuation of a previous record?
@@ -111,7 +111,7 @@ impl<'a> TXTResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for TXTResult<'a> {
+impl fmt::Display for TXTResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let text = str::from_utf8(self.text()).unwrap_or("<binary>");
         write!(fmt, "Record start: {}, Text: {}", self.record_start(), text)

src/uri.rs

@@ -93,10 +93,10 @@ impl Drop for URIResults {
 
 unsafe impl Send for URIResults {}
 unsafe impl Sync for URIResults {}
-unsafe impl<'a> Send for URIResult<'a> {}
-unsafe impl<'a> Sync for URIResult<'a> {}
-unsafe impl<'a> Send for URIResultsIter<'a> {}
-unsafe impl<'a> Sync for URIResultsIter<'a> {}
+unsafe impl Send for URIResult<'_> {}
+unsafe impl Sync for URIResult<'_> {}
+unsafe impl Send for URIResultsIter<'_> {}
+unsafe impl Sync for URIResultsIter<'_> {}
 
 impl<'a> URIResult<'a> {
     /// Returns the weight in this `URIResult`.
@@ -122,7 +122,7 @@ impl<'a> URIResult<'a> {
     }
 }
 
-impl<'a> fmt::Display for URIResult<'a> {
+impl fmt::Display for URIResult<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "URI: {}, ", self.uri())?;
         write!(fmt, "Priority: {}, ", self.priority())?;