Fix Cargo clippy

Signed-off-by: Folyd <[email protected]>

Author: Folyd

src/desc.rs

@@ -160,9 +160,10 @@ impl Desc {
         desc.dim_hash = lh.finish();
 
         for (key, value) in const_labels {
-            let mut label_pair = LabelPair::default();
-            label_pair.name = Some(key);
-            label_pair.value = Some(value);
+            let label_pair = LabelPair {
+                name: Some(key),
+                value: Some(value),
+            };
             desc.const_label_pairs.push(label_pair);
         }
 

src/histogram.rs

@@ -435,9 +435,11 @@ impl HistogramCore {
         // interfere with previous or upcoming collect calls.
         let cold_shard_sum = cold_shard.sum.swap(0.0, Ordering::AcqRel);
 
-        let mut h = proto::Histogram::default();
-        h.sample_sum = Some(cold_shard_sum);
-        h.sample_count = Some(overall_count);
+        let mut h = proto::Histogram {
+            sample_sum: Some(cold_shard_sum),
+            sample_count: Some(overall_count),
+            ..Default::default()
+        };
 
         let mut cumulative_count = 0;
         let mut buckets = Vec::with_capacity(self.upper_bounds.len());
@@ -450,10 +452,10 @@ impl HistogramCore {
             hot_shard.buckets[i].inc_by(cold_bucket_count);
 
             cumulative_count += cold_bucket_count;
-            let mut b = proto::Bucket::default();
-            b.cumulative_count = Some(cumulative_count);
-            b.upper_bound = Some(*upper_bound);
-            buckets.push(b);
+            buckets.push(proto::Bucket {
+                cumulative_count: Some(cumulative_count),
+                upper_bound: Some(*upper_bound),
+            });
         }
         h.bucket = buckets;
 
@@ -751,11 +753,11 @@ impl Histogram {
 
 impl Metric for Histogram {
     fn metric(&self) -> proto::Metric {
-        let mut m = proto::Metric::default();
-        m.label = self.core.label_pairs.clone();
-        m.histogram = Some(self.core.proto());
-
-        m
+        proto::Metric {
+            label: self.core.label_pairs.clone(),
+            histogram: Some(self.core.proto()),
+            ..Default::default()
+        }
     }
 }
 
@@ -765,11 +767,12 @@ impl Collector for Histogram {
     }
 
     fn collect(&self) -> Vec<proto::MetricFamily> {
-        let mut m = proto::MetricFamily::default();
-        m.name = Some(self.core.desc.fq_name.clone());
-        m.help = Some(self.core.desc.help.clone());
-        m.r#type = Some(proto::MetricType::Histogram.into());
-        m.metric = vec![self.metric()];
+        let m = proto::MetricFamily {
+            name: Some(self.core.desc.fq_name.clone()),
+            help: Some(self.core.desc.help.clone()),
+            r#type: Some(proto::MetricType::Histogram.into()),
+            metric: vec![self.metric()],
+        };
 
         vec![m]
     }

src/registry.rs

@@ -150,7 +150,7 @@ impl RegistryCore {
         // Now that MetricFamilies are all set, sort their Metrics
         // lexicographically by their label values.
         for mf in mf_by_name.values_mut() {
-            &mut mf.metric.sort_by(|m1, m2| {
+            mf.metric.sort_by(|m1, m2| {
                 let lps1 = &m1.label;
                 let lps2 = &m2.label;
 
@@ -194,11 +194,9 @@ impl RegistryCore {
                 if let Some(ref hmap) = self.labels {
                     let pairs: Vec<proto::LabelPair> = hmap
                         .iter()
-                        .map(|(k, v)| {
-                            let mut label = proto::LabelPair::default();
-                            label.name = Some(k.to_string());
-                            label.value = Some(v.to_string());
-                            label
+                        .map(|(k, v)| proto::LabelPair {
+                            name: Some(k.to_string()),
+                            value: Some(v.to_string()),
                         })
                         .collect();
 

src/value.rs

@@ -85,33 +85,35 @@ impl<P: Atomic> Value<P> {
     }
 
     pub fn metric(&self) -> Metric {
-        let mut m = Metric::default();
-        m.label = self.label_pairs.clone();
+        let mut m = Metric {
+            label: self.label_pairs.clone(),
+            ..Default::default()
+        };
 
         let val = self.get();
         match self.val_type {
             ValueType::Counter => {
-                let mut counter = Counter::default();
-                counter.value = Some(val.into_f64());
-                m.counter = Some(counter);
+                m.counter = Some(Counter {
+                    value: Some(val.into_f64()),
+                });
             }
             ValueType::Gauge => {
-                let mut gauge = Gauge::default();
-                gauge.value = Some(val.into_f64());
-                m.gauge = Some(gauge);
+                m.gauge = Some(Gauge {
+                    value: Some(val.into_f64()),
+                });
             }
         }
 
         m
     }
 
     pub fn collect(&self) -> MetricFamily {
-        let mut m = MetricFamily::default();
-        m.name = Some(self.desc.fq_name.clone());
-        m.help = Some(self.desc.help.clone());
-        m.r#type = Some(self.val_type.metric_type().into());
-        m.metric = vec![self.metric()];
-        m
+        MetricFamily {
+            name: Some(self.desc.fq_name.clone()),
+            help: Some(self.desc.help.clone()),
+            r#type: Some(self.val_type.metric_type().into()),
+            metric: vec![self.metric()],
+        }
     }
 }
 
@@ -134,10 +136,10 @@ pub fn make_label_pairs(desc: &Desc, label_values: &[&str]) -> Result<Vec<LabelP
 
     let mut label_pairs = Vec::with_capacity(total_len);
     for (i, n) in desc.variable_labels.iter().enumerate() {
-        let mut label_pair = LabelPair::default();
-        label_pair.name = Some(n.clone());
-        label_pair.value = Some(label_values[i].to_owned());
-        label_pairs.push(label_pair);
+        label_pairs.push(LabelPair {
+            name: Some(n.clone()),
+            value: Some(label_values[i].to_owned()),
+        });
     }
 
     for label_pair in &desc.const_label_pairs {

src/vec.rs

@@ -35,18 +35,17 @@ pub(crate) struct MetricVecCore<T: MetricVecBuilder> {
 
 impl<T: MetricVecBuilder> MetricVecCore<T> {
     pub fn collect(&self) -> MetricFamily {
-        let mut m = MetricFamily::default();
-        m.name = Some(self.desc.fq_name.clone());
-        m.help = Some(self.desc.help.clone());
-        m.r#type = Some(self.metric_type.into());
-
         let children = self.children.read();
         let mut metrics = Vec::with_capacity(children.len());
         for child in children.values() {
             metrics.push(child.metric());
         }
-        m.metric = metrics;
-        m
+        MetricFamily {
+            name: Some(self.desc.fq_name.clone()),
+            help: Some(self.desc.help.clone()),
+            r#type: Some(self.metric_type.into()),
+            metric: metrics,
+        }
     }
 
     pub fn get_metric_with_label_values(&self, vals: &[&str]) -> Result<T::M> {