chore(ci): fix clippy warnings when using rust 1.83 (#250)

koushiro · web-flow · commit d3e363728a40 · 2024-11-29T11:14:51.000+01:00
Signed-off-by: koushiro &lt;koushiro.cqx@gmail.com&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -29,6 +29,7 @@ prost-types = { version = "0.12.0", optional = true }
 async-std = { version = "1", features = ["attributes"] }
 axum = "0.7"
 criterion = "0.5"
+futures = "0.3"
 http-types = "2"
 pyo3 = "0.22"
 quickcheck = "1"
diff --git a/examples/hyper.rs b/examples/hyper.rs
@@ -1,3 +1,4 @@
+use futures::future::BoxFuture;
 use http_body_util::{combinators, BodyExt, Full};
 use hyper::{
     body::{Bytes, Incoming},
@@ -8,10 +9,8 @@ use hyper::{
 use hyper_util::rt::TokioIo;
 use prometheus_client::{encoding::text::encode, metrics::counter::Counter, registry::Registry};
 use std::{
-    future::Future,
     io,
     net::{IpAddr, Ipv4Addr, SocketAddr},
-    pin::Pin,
     sync::Arc,
 };
 use tokio::{
@@ -69,8 +68,7 @@ type BoxBody = combinators::BoxBody<Bytes, hyper::Error>;
 /// This function returns a HTTP handler (i.e. another function)
 pub fn make_handler(
     registry: Arc<Registry>,
-) -> impl Fn(Request<Incoming>) -> Pin<Box<dyn Future<Output = io::Result<Response<BoxBody>>> + Send>>
-{
+) -> impl Fn(Request<Incoming>) -> BoxFuture<'static, io::Result<Response<BoxBody>>> {
     // This closure accepts a request and responds with the OpenMetrics encoding of our metrics.
     move |_req: Request<Incoming>| {
         let reg = registry.clone();
diff --git a/src/encoding.rs b/src/encoding.rs
@@ -230,7 +230,7 @@ impl<'a> From<protobuf::LabelSetEncoder<'a>> for LabelSetEncoder<'a> {
     }
 }
 
-impl<'a> LabelSetEncoder<'a> {
+impl LabelSetEncoder<'_> {
     /// Encode the given label.
     pub fn encode_label(&mut self) -> LabelEncoder {
         for_both_mut!(self, LabelSetEncoderInner, e, e.encode_label().into())
@@ -271,7 +271,7 @@ impl<'a> From<protobuf::LabelEncoder<'a>> for LabelEncoder<'a> {
     }
 }
 
-impl<'a> LabelEncoder<'a> {
+impl LabelEncoder<'_> {
     /// Encode a label.
     pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {
         for_both_mut!(
@@ -313,7 +313,7 @@ impl<'a> From<protobuf::LabelKeyEncoder<'a>> for LabelKeyEncoder<'a> {
     }
 }
 
-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {
+impl std::fmt::Write for LabelKeyEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         for_both_mut!(self, LabelKeyEncoderInner, e, e.write_str(s))
     }
@@ -390,7 +390,7 @@ impl EncodeLabelKey for String {
     }
 }
 
-impl<'a> EncodeLabelKey for Cow<'a, str> {
+impl EncodeLabelKey for Cow<'_, str> {
     fn encode(&self, encoder: &mut LabelKeyEncoder) -> Result<(), std::fmt::Error> {
         EncodeLabelKey::encode(&self.as_ref(), encoder)
     }
@@ -453,14 +453,14 @@ enum LabelValueEncoderInner<'a> {
     Protobuf(protobuf::LabelValueEncoder<'a>),
 }
 
-impl<'a> LabelValueEncoder<'a> {
+impl LabelValueEncoder<'_> {
     /// Finish encoding the label value.
     pub fn finish(self) -> Result<(), std::fmt::Error> {
         for_both!(self, LabelValueEncoderInner, e, e.finish())
     }
 }
 
-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {
+impl std::fmt::Write for LabelValueEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         for_both_mut!(self, LabelValueEncoderInner, e, e.write_str(s))
     }
@@ -485,7 +485,7 @@ impl EncodeLabelValue for &String {
     }
 }
 
-impl<'a> EncodeLabelValue for Cow<'a, str> {
+impl EncodeLabelValue for Cow<'_, str> {
     fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
         EncodeLabelValue::encode(&self.as_ref(), encoder)
     }
@@ -610,7 +610,7 @@ enum GaugeValueEncoderInner<'a> {
     Protobuf(protobuf::GaugeValueEncoder<'a>),
 }
 
-impl<'a> GaugeValueEncoder<'a> {
+impl GaugeValueEncoder<'_> {
     fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {
         for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_u32(v))
     }
@@ -678,7 +678,7 @@ enum CounterValueEncoderInner<'a> {
     Protobuf(protobuf::CounterValueEncoder<'a>),
 }
 
-impl<'a> CounterValueEncoder<'a> {
+impl CounterValueEncoder<'_> {
     fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         for_both_mut!(self, CounterValueEncoderInner, e, e.encode_f64(v))
     }
@@ -742,7 +742,7 @@ enum ExemplarValueEncoderInner<'a> {
     Protobuf(protobuf::ExemplarValueEncoder<'a>),
 }
 
-impl<'a> ExemplarValueEncoder<'a> {
+impl ExemplarValueEncoder<'_> {
     fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         for_both_mut!(self, ExemplarValueEncoderInner, e, e.encode(v))
     }
diff --git a/src/encoding/protobuf.rs b/src/encoding/protobuf.rs
@@ -322,7 +322,7 @@ pub(crate) struct GaugeValueEncoder<'a> {
     value: &'a mut openmetrics_data_model::gauge_value::Value,
 }
 
-impl<'a> GaugeValueEncoder<'a> {
+impl GaugeValueEncoder<'_> {
     pub fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {
         self.encode_i64(v as i64)
     }
@@ -343,7 +343,7 @@ pub(crate) struct ExemplarValueEncoder<'a> {
     value: &'a mut f64,
 }
 
-impl<'a> ExemplarValueEncoder<'a> {
+impl ExemplarValueEncoder<'_> {
     pub fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         *self.value = v;
         Ok(())
@@ -364,7 +364,7 @@ pub(crate) struct CounterValueEncoder<'a> {
     value: &'a mut openmetrics_data_model::counter_value::Total,
 }
 
-impl<'a> CounterValueEncoder<'a> {
+impl CounterValueEncoder<'_> {
     pub fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         *self.value = openmetrics_data_model::counter_value::Total::DoubleValue(v);
         Ok(())
@@ -381,7 +381,7 @@ pub(crate) struct LabelSetEncoder<'a> {
     labels: &'a mut Vec<openmetrics_data_model::Label>,
 }
 
-impl<'a> LabelSetEncoder<'a> {
+impl LabelSetEncoder<'_> {
     pub fn encode_label(&mut self) -> LabelEncoder {
         LabelEncoder {
             labels: self.labels,
@@ -394,7 +394,7 @@ pub(crate) struct LabelEncoder<'a> {
     labels: &'a mut Vec<openmetrics_data_model::Label>,
 }
 
-impl<'a> LabelEncoder<'a> {
+impl LabelEncoder<'_> {
     pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {
         self.labels.push(openmetrics_data_model::Label::default());
 
@@ -409,7 +409,7 @@ pub(crate) struct LabelKeyEncoder<'a> {
     label: &'a mut openmetrics_data_model::Label,
 }
 
-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {
+impl std::fmt::Write for LabelKeyEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         self.label.name.write_str(s)
     }
@@ -428,13 +428,13 @@ pub(crate) struct LabelValueEncoder<'a> {
     label_value: &'a mut String,
 }
 
-impl<'a> LabelValueEncoder<'a> {
+impl LabelValueEncoder<'_> {
     pub fn finish(self) -> Result<(), std::fmt::Error> {
         Ok(())
     }
 }
 
-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {
+impl std::fmt::Write for LabelValueEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         self.label_value.write_str(s)
     }
diff --git a/src/encoding/text.rs b/src/encoding/text.rs
@@ -188,7 +188,7 @@ pub(crate) struct DescriptorEncoder<'a> {
     labels: &'a [(Cow<'static, str>, Cow<'static, str>)],
 }
 
-impl<'a> std::fmt::Debug for DescriptorEncoder<'a> {
+impl std::fmt::Debug for DescriptorEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("DescriptorEncoder").finish()
     }
@@ -293,7 +293,7 @@ pub(crate) struct MetricEncoder<'a> {
     family_labels: Option<&'a dyn super::EncodeLabelSet>,
 }
 
-impl<'a> std::fmt::Debug for MetricEncoder<'a> {
+impl std::fmt::Debug for MetricEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut labels = String::new();
         if let Some(l) = self.family_labels {
@@ -310,7 +310,7 @@ impl<'a> std::fmt::Debug for MetricEncoder<'a> {
     }
 }
 
-impl<'a> MetricEncoder<'a> {
+impl MetricEncoder<'_> {
     pub fn encode_counter<
         S: EncodeLabelSet,
         CounterValue: super::EncodeCounterValue,
@@ -555,13 +555,13 @@ pub(crate) struct CounterValueEncoder<'a> {
     writer: &'a mut dyn Write,
 }
 
-impl<'a> std::fmt::Debug for CounterValueEncoder<'a> {
+impl std::fmt::Debug for CounterValueEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CounterValueEncoder").finish()
     }
 }
 
-impl<'a> CounterValueEncoder<'a> {
+impl CounterValueEncoder<'_> {
     pub fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         self.writer.write_str(" ")?;
         self.writer.write_str(dtoa::Buffer::new().format(v))?;
@@ -579,13 +579,13 @@ pub(crate) struct GaugeValueEncoder<'a> {
     writer: &'a mut dyn Write,
 }
 
-impl<'a> std::fmt::Debug for GaugeValueEncoder<'a> {
+impl std::fmt::Debug for GaugeValueEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("GaugeValueEncoder").finish()
     }
 }
 
-impl<'a> GaugeValueEncoder<'a> {
+impl GaugeValueEncoder<'_> {
     pub fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {
         self.writer.write_str(" ")?;
         self.writer.write_str(itoa::Buffer::new().format(v))?;
@@ -609,13 +609,13 @@ pub(crate) struct ExemplarValueEncoder<'a> {
     writer: &'a mut dyn Write,
 }
 
-impl<'a> std::fmt::Debug for ExemplarValueEncoder<'a> {
+impl std::fmt::Debug for ExemplarValueEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ExemplarValueEncoder").finish()
     }
 }
 
-impl<'a> ExemplarValueEncoder<'a> {
+impl ExemplarValueEncoder<'_> {
     pub fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {
         self.writer.write_str(dtoa::Buffer::new().format(v))
     }
@@ -626,7 +626,7 @@ pub(crate) struct LabelSetEncoder<'a> {
     first: bool,
 }
 
-impl<'a> std::fmt::Debug for LabelSetEncoder<'a> {
+impl std::fmt::Debug for LabelSetEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LabelSetEncoder")
             .field("first", &self.first)
@@ -657,15 +657,15 @@ pub(crate) struct LabelEncoder<'a> {
     first: bool,
 }
 
-impl<'a> std::fmt::Debug for LabelEncoder<'a> {
+impl std::fmt::Debug for LabelEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LabelEncoder")
             .field("first", &self.first)
             .finish()
     }
 }
 
-impl<'a> LabelEncoder<'a> {
+impl LabelEncoder<'_> {
     pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {
         if !self.first {
             self.writer.write_str(",")?;
@@ -680,7 +680,7 @@ pub(crate) struct LabelKeyEncoder<'a> {
     writer: &'a mut dyn Write,
 }
 
-impl<'a> std::fmt::Debug for LabelKeyEncoder<'a> {
+impl std::fmt::Debug for LabelKeyEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LabelKeyEncoder").finish()
     }
@@ -695,7 +695,7 @@ impl<'a> LabelKeyEncoder<'a> {
     }
 }
 
-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {
+impl std::fmt::Write for LabelKeyEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         self.writer.write_str(s)
     }
@@ -705,19 +705,19 @@ pub(crate) struct LabelValueEncoder<'a> {
     writer: &'a mut dyn Write,
 }
 
-impl<'a> std::fmt::Debug for LabelValueEncoder<'a> {
+impl std::fmt::Debug for LabelValueEncoder<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("LabelValueEncoder").finish()
     }
 }
 
-impl<'a> LabelValueEncoder<'a> {
+impl LabelValueEncoder<'_> {
     pub fn finish(self) -> Result<(), std::fmt::Error> {
         self.writer.write_str("\"")
     }
 }
 
-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {
+impl std::fmt::Write for LabelValueEncoder<'_> {
     fn write_str(&mut self, s: &str) -> std::fmt::Result {
         self.writer.write_str(s)
     }

Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ impl<'a> From<protobuf::LabelSetEncoder<'a>> for LabelSetEncoder<'a> {`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`		`-impl<'a> LabelSetEncoder<'a> {`
	`233`	`+impl LabelSetEncoder<'_> {`
`234`	`234`	`/// Encode the given label.`
`235`	`235`	`pub fn encode_label(&mut self) -> LabelEncoder {`
`236`	`236`	`for_both_mut!(self, LabelSetEncoderInner, e, e.encode_label().into())`
`@@ -271,7 +271,7 @@ impl<'a> From<protobuf::LabelEncoder<'a>> for LabelEncoder<'a> {`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`274`		`-impl<'a> LabelEncoder<'a> {`
	`274`	`+impl LabelEncoder<'_> {`
`275`	`275`	`/// Encode a label.`
`276`	`276`	`pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {`
`277`	`277`	`for_both_mut!(`
`@@ -313,7 +313,7 @@ impl<'a> From<protobuf::LabelKeyEncoder<'a>> for LabelKeyEncoder<'a> {`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`
`316`		`-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {`
	`316`	`+impl std::fmt::Write for LabelKeyEncoder<'_> {`
`317`	`317`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`318`	`318`	`for_both_mut!(self, LabelKeyEncoderInner, e, e.write_str(s))`
`319`	`319`	`}`
`@@ -390,7 +390,7 @@ impl EncodeLabelKey for String {`
`390`	`390`	`}`
`391`	`391`	`}`
`392`	`392`
`393`		`-impl<'a> EncodeLabelKey for Cow<'a, str> {`
	`393`	`+impl EncodeLabelKey for Cow<'_, str> {`
`394`	`394`	`fn encode(&self, encoder: &mut LabelKeyEncoder) -> Result<(), std::fmt::Error> {`
`395`	`395`	`EncodeLabelKey::encode(&self.as_ref(), encoder)`
`396`	`396`	`}`
`@@ -453,14 +453,14 @@ enum LabelValueEncoderInner<'a> {`
`453`	`453`	`Protobuf(protobuf::LabelValueEncoder<'a>),`
`454`	`454`	`}`
`455`	`455`
`456`		`-impl<'a> LabelValueEncoder<'a> {`
	`456`	`+impl LabelValueEncoder<'_> {`
`457`	`457`	`/// Finish encoding the label value.`
`458`	`458`	`pub fn finish(self) -> Result<(), std::fmt::Error> {`
`459`	`459`	`for_both!(self, LabelValueEncoderInner, e, e.finish())`
`460`	`460`	`}`
`461`	`461`	`}`
`462`	`462`
`463`		`-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {`
	`463`	`+impl std::fmt::Write for LabelValueEncoder<'_> {`
`464`	`464`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`465`	`465`	`for_both_mut!(self, LabelValueEncoderInner, e, e.write_str(s))`
`466`	`466`	`}`
`@@ -485,7 +485,7 @@ impl EncodeLabelValue for &String {`
`485`	`485`	`}`
`486`	`486`	`}`
`487`	`487`
`488`		`-impl<'a> EncodeLabelValue for Cow<'a, str> {`
	`488`	`+impl EncodeLabelValue for Cow<'_, str> {`
`489`	`489`	`fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {`
`490`	`490`	`EncodeLabelValue::encode(&self.as_ref(), encoder)`
`491`	`491`	`}`
`@@ -610,7 +610,7 @@ enum GaugeValueEncoderInner<'a> {`
`610`	`610`	`Protobuf(protobuf::GaugeValueEncoder<'a>),`
`611`	`611`	`}`
`612`	`612`
`613`		`-impl<'a> GaugeValueEncoder<'a> {`
	`613`	`+impl GaugeValueEncoder<'_> {`
`614`	`614`	`fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {`
`615`	`615`	`for_both_mut!(self, GaugeValueEncoderInner, e, e.encode_u32(v))`
`616`	`616`	`}`
`@@ -678,7 +678,7 @@ enum CounterValueEncoderInner<'a> {`
`678`	`678`	`Protobuf(protobuf::CounterValueEncoder<'a>),`
`679`	`679`	`}`
`680`	`680`
`681`		`-impl<'a> CounterValueEncoder<'a> {`
	`681`	`+impl CounterValueEncoder<'_> {`
`682`	`682`	`fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`683`	`683`	`for_both_mut!(self, CounterValueEncoderInner, e, e.encode_f64(v))`
`684`	`684`	`}`
`@@ -742,7 +742,7 @@ enum ExemplarValueEncoderInner<'a> {`
`742`	`742`	`Protobuf(protobuf::ExemplarValueEncoder<'a>),`
`743`	`743`	`}`
`744`	`744`
`745`		`-impl<'a> ExemplarValueEncoder<'a> {`
	`745`	`+impl ExemplarValueEncoder<'_> {`
`746`	`746`	`fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`747`	`747`	`for_both_mut!(self, ExemplarValueEncoderInner, e, e.encode(v))`
`748`	`748`	`}`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ pub(crate) struct GaugeValueEncoder<'a> {`
`322`	`322`	`value: &'a mut openmetrics_data_model::gauge_value::Value,`
`323`	`323`	`}`
`324`	`324`
`325`		`-impl<'a> GaugeValueEncoder<'a> {`
	`325`	`+impl GaugeValueEncoder<'_> {`
`326`	`326`	`pub fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {`
`327`	`327`	`self.encode_i64(v as i64)`
`328`	`328`	`}`
`@@ -343,7 +343,7 @@ pub(crate) struct ExemplarValueEncoder<'a> {`
`343`	`343`	`value: &'a mut f64,`
`344`	`344`	`}`
`345`	`345`
`346`		`-impl<'a> ExemplarValueEncoder<'a> {`
	`346`	`+impl ExemplarValueEncoder<'_> {`
`347`	`347`	`pub fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`348`	`348`	`*self.value = v;`
`349`	`349`	`Ok(())`
`@@ -364,7 +364,7 @@ pub(crate) struct CounterValueEncoder<'a> {`
`364`	`364`	`value: &'a mut openmetrics_data_model::counter_value::Total,`
`365`	`365`	`}`
`366`	`366`
`367`		`-impl<'a> CounterValueEncoder<'a> {`
	`367`	`+impl CounterValueEncoder<'_> {`
`368`	`368`	`pub fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`369`	`369`	`*self.value = openmetrics_data_model::counter_value::Total::DoubleValue(v);`
`370`	`370`	`Ok(())`
`@@ -381,7 +381,7 @@ pub(crate) struct LabelSetEncoder<'a> {`
`381`	`381`	`labels: &'a mut Vec<openmetrics_data_model::Label>,`
`382`	`382`	`}`
`383`	`383`
`384`		`-impl<'a> LabelSetEncoder<'a> {`
	`384`	`+impl LabelSetEncoder<'_> {`
`385`	`385`	`pub fn encode_label(&mut self) -> LabelEncoder {`
`386`	`386`	`LabelEncoder {`
`387`	`387`	`labels: self.labels,`
`@@ -394,7 +394,7 @@ pub(crate) struct LabelEncoder<'a> {`
`394`	`394`	`labels: &'a mut Vec<openmetrics_data_model::Label>,`
`395`	`395`	`}`
`396`	`396`
`397`		`-impl<'a> LabelEncoder<'a> {`
	`397`	`+impl LabelEncoder<'_> {`
`398`	`398`	`pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {`
`399`	`399`	`self.labels.push(openmetrics_data_model::Label::default());`
`400`	`400`
`@@ -409,7 +409,7 @@ pub(crate) struct LabelKeyEncoder<'a> {`
`409`	`409`	`label: &'a mut openmetrics_data_model::Label,`
`410`	`410`	`}`
`411`	`411`
`412`		`-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {`
	`412`	`+impl std::fmt::Write for LabelKeyEncoder<'_> {`
`413`	`413`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`414`	`414`	`self.label.name.write_str(s)`
`415`	`415`	`}`
`@@ -428,13 +428,13 @@ pub(crate) struct LabelValueEncoder<'a> {`
`428`	`428`	`label_value: &'a mut String,`
`429`	`429`	`}`
`430`	`430`
`431`		`-impl<'a> LabelValueEncoder<'a> {`
	`431`	`+impl LabelValueEncoder<'_> {`
`432`	`432`	`pub fn finish(self) -> Result<(), std::fmt::Error> {`
`433`	`433`	`Ok(())`
`434`	`434`	`}`
`435`	`435`	`}`
`436`	`436`
`437`		`-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {`
	`437`	`+impl std::fmt::Write for LabelValueEncoder<'_> {`
`438`	`438`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`439`	`439`	`self.label_value.write_str(s)`
`440`	`440`	`}`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ pub(crate) struct DescriptorEncoder<'a> {`
`188`	`188`	`labels: &'a [(Cow<'static, str>, Cow<'static, str>)],`
`189`	`189`	`}`
`190`	`190`
`191`		`-impl<'a> std::fmt::Debug for DescriptorEncoder<'a> {`
	`191`	`+impl std::fmt::Debug for DescriptorEncoder<'_> {`
`192`	`192`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`193`	`193`	`f.debug_struct("DescriptorEncoder").finish()`
`194`	`194`	`}`
`@@ -293,7 +293,7 @@ pub(crate) struct MetricEncoder<'a> {`
`293`	`293`	`family_labels: Option<&'a dyn super::EncodeLabelSet>,`
`294`	`294`	`}`
`295`	`295`
`296`		`-impl<'a> std::fmt::Debug for MetricEncoder<'a> {`
	`296`	`+impl std::fmt::Debug for MetricEncoder<'_> {`
`297`	`297`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`298`	`298`	`let mut labels = String::new();`
`299`	`299`	`if let Some(l) = self.family_labels {`
`@@ -310,7 +310,7 @@ impl<'a> std::fmt::Debug for MetricEncoder<'a> {`
`310`	`310`	`}`
`311`	`311`	`}`
`312`	`312`
`313`		`-impl<'a> MetricEncoder<'a> {`
	`313`	`+impl MetricEncoder<'_> {`
`314`	`314`	`pub fn encode_counter<`
`315`	`315`	`S: EncodeLabelSet,`
`316`	`316`	`CounterValue: super::EncodeCounterValue,`
`@@ -555,13 +555,13 @@ pub(crate) struct CounterValueEncoder<'a> {`
`555`	`555`	`writer: &'a mut dyn Write,`
`556`	`556`	`}`
`557`	`557`
`558`		`-impl<'a> std::fmt::Debug for CounterValueEncoder<'a> {`
	`558`	`+impl std::fmt::Debug for CounterValueEncoder<'_> {`
`559`	`559`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`560`	`560`	`f.debug_struct("CounterValueEncoder").finish()`
`561`	`561`	`}`
`562`	`562`	`}`
`563`	`563`
`564`		`-impl<'a> CounterValueEncoder<'a> {`
	`564`	`+impl CounterValueEncoder<'_> {`
`565`	`565`	`pub fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`566`	`566`	`self.writer.write_str(" ")?;`
`567`	`567`	`self.writer.write_str(dtoa::Buffer::new().format(v))?;`
`@@ -579,13 +579,13 @@ pub(crate) struct GaugeValueEncoder<'a> {`
`579`	`579`	`writer: &'a mut dyn Write,`
`580`	`580`	`}`
`581`	`581`
`582`		`-impl<'a> std::fmt::Debug for GaugeValueEncoder<'a> {`
	`582`	`+impl std::fmt::Debug for GaugeValueEncoder<'_> {`
`583`	`583`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`584`	`584`	`f.debug_struct("GaugeValueEncoder").finish()`
`585`	`585`	`}`
`586`	`586`	`}`
`587`	`587`
`588`		`-impl<'a> GaugeValueEncoder<'a> {`
	`588`	`+impl GaugeValueEncoder<'_> {`
`589`	`589`	`pub fn encode_u32(&mut self, v: u32) -> Result<(), std::fmt::Error> {`
`590`	`590`	`self.writer.write_str(" ")?;`
`591`	`591`	`self.writer.write_str(itoa::Buffer::new().format(v))?;`
`@@ -609,13 +609,13 @@ pub(crate) struct ExemplarValueEncoder<'a> {`
`609`	`609`	`writer: &'a mut dyn Write,`
`610`	`610`	`}`
`611`	`611`
`612`		`-impl<'a> std::fmt::Debug for ExemplarValueEncoder<'a> {`
	`612`	`+impl std::fmt::Debug for ExemplarValueEncoder<'_> {`
`613`	`613`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`614`	`614`	`f.debug_struct("ExemplarValueEncoder").finish()`
`615`	`615`	`}`
`616`	`616`	`}`
`617`	`617`
`618`		`-impl<'a> ExemplarValueEncoder<'a> {`
	`618`	`+impl ExemplarValueEncoder<'_> {`
`619`	`619`	`pub fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {`
`620`	`620`	`self.writer.write_str(dtoa::Buffer::new().format(v))`
`621`	`621`	`}`
`@@ -626,7 +626,7 @@ pub(crate) struct LabelSetEncoder<'a> {`
`626`	`626`	`first: bool,`
`627`	`627`	`}`
`628`	`628`
`629`		`-impl<'a> std::fmt::Debug for LabelSetEncoder<'a> {`
	`629`	`+impl std::fmt::Debug for LabelSetEncoder<'_> {`
`630`	`630`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`631`	`631`	`f.debug_struct("LabelSetEncoder")`
`632`	`632`	`.field("first", &self.first)`
`@@ -657,15 +657,15 @@ pub(crate) struct LabelEncoder<'a> {`
`657`	`657`	`first: bool,`
`658`	`658`	`}`
`659`	`659`
`660`		`-impl<'a> std::fmt::Debug for LabelEncoder<'a> {`
	`660`	`+impl std::fmt::Debug for LabelEncoder<'_> {`
`661`	`661`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`662`	`662`	`f.debug_struct("LabelEncoder")`
`663`	`663`	`.field("first", &self.first)`
`664`	`664`	`.finish()`
`665`	`665`	`}`
`666`	`666`	`}`
`667`	`667`
`668`		`-impl<'a> LabelEncoder<'a> {`
	`668`	`+impl LabelEncoder<'_> {`
`669`	`669`	`pub fn encode_label_key(&mut self) -> Result<LabelKeyEncoder, std::fmt::Error> {`
`670`	`670`	`if !self.first {`
`671`	`671`	`self.writer.write_str(",")?;`
`@@ -680,7 +680,7 @@ pub(crate) struct LabelKeyEncoder<'a> {`
`680`	`680`	`writer: &'a mut dyn Write,`
`681`	`681`	`}`
`682`	`682`
`683`		`-impl<'a> std::fmt::Debug for LabelKeyEncoder<'a> {`
	`683`	`+impl std::fmt::Debug for LabelKeyEncoder<'_> {`
`684`	`684`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`685`	`685`	`f.debug_struct("LabelKeyEncoder").finish()`
`686`	`686`	`}`
`@@ -695,7 +695,7 @@ impl<'a> LabelKeyEncoder<'a> {`
`695`	`695`	`}`
`696`	`696`	`}`
`697`	`697`
`698`		`-impl<'a> std::fmt::Write for LabelKeyEncoder<'a> {`
	`698`	`+impl std::fmt::Write for LabelKeyEncoder<'_> {`
`699`	`699`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`700`	`700`	`self.writer.write_str(s)`
`701`	`701`	`}`
`@@ -705,19 +705,19 @@ pub(crate) struct LabelValueEncoder<'a> {`
`705`	`705`	`writer: &'a mut dyn Write,`
`706`	`706`	`}`
`707`	`707`
`708`		`-impl<'a> std::fmt::Debug for LabelValueEncoder<'a> {`
	`708`	`+impl std::fmt::Debug for LabelValueEncoder<'_> {`
`709`	`709`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`710`	`710`	`f.debug_struct("LabelValueEncoder").finish()`
`711`	`711`	`}`
`712`	`712`	`}`
`713`	`713`
`714`		`-impl<'a> LabelValueEncoder<'a> {`
	`714`	`+impl LabelValueEncoder<'_> {`
`715`	`715`	`pub fn finish(self) -> Result<(), std::fmt::Error> {`
`716`	`716`	`self.writer.write_str("\"")`
`717`	`717`	`}`
`718`	`718`	`}`
`719`	`719`
`720`		`-impl<'a> std::fmt::Write for LabelValueEncoder<'a> {`
	`720`	`+impl std::fmt::Write for LabelValueEncoder<'_> {`
`721`	`721`	`fn write_str(&mut self, s: &str) -> std::fmt::Result {`
`722`	`722`	`self.writer.write_str(s)`
`723`	`723`	`}`