cleanup .clone() now that Level is Copy

Ideally, this would make `Metadata::Level` return `Level` instead of
`&Level`. However that's a breaking change, so I didn't make it here.

Author: jyn514

tracing-core/src/metadata.rs

@@ -864,7 +864,7 @@ mod tests {
                 // actual repr matches what we expect it to be --- we're testing
                 // that *other* unsafe code is sound using the transmuted value.
                 // We're not going to do anything with it that might be unsound.
-                mem::transmute::<_, usize>(filter.clone())
+                mem::transmute::<_, usize>(filter)
             };
             assert_eq!(expected, repr, "repr changed for {:?}", filter)
         }

tracing-log/src/lib.rs

@@ -310,8 +310,8 @@ lazy_static! {
     static ref ERROR_FIELDS: Fields = Fields::new(ERROR_CS);
 }
 
-fn level_to_cs(level: &Level) -> (&'static dyn Callsite, &'static Fields) {
-    match *level {
+fn level_to_cs(level: Level) -> (&'static dyn Callsite, &'static Fields) {
+    match level {
         Level::TRACE => (TRACE_CS, &*TRACE_FIELDS),
         Level::DEBUG => (DEBUG_CS, &*DEBUG_FIELDS),
         Level::INFO => (INFO_CS, &*INFO_FIELDS),
@@ -415,13 +415,13 @@ impl<'a> NormalizeEvent<'a> for Event<'a> {
     fn normalized_metadata(&'a self) -> Option<Metadata<'a>> {
         let original = self.metadata();
         if self.is_log() {
-            let mut fields = LogVisitor::new_for(self, level_to_cs(original.level()).1);
+            let mut fields = LogVisitor::new_for(self, level_to_cs(*original.level()).1);
             self.record(&mut fields);
 
             Some(Metadata::new(
                 "log event",
                 fields.target.unwrap_or("log"),
-                original.level().clone(),
+                *original.level(),
                 fields.file,
                 fields.line.map(|l| l as u32),
                 fields.module_path,
@@ -434,7 +434,7 @@ impl<'a> NormalizeEvent<'a> for Event<'a> {
     }
 
     fn is_log(&self) -> bool {
-        self.metadata().callsite() == identify_callsite!(level_to_cs(self.metadata().level()).0)
+        self.metadata().callsite() == identify_callsite!(level_to_cs(*self.metadata().level()).0)
     }
 }
 

tracing-subscriber/src/filter/env/directive.rs

@@ -85,7 +85,7 @@ impl Directive {
         Some(StaticDirective {
             target: self.target.clone(),
             field_names,
-            level: self.level.clone(),
+            level: self.level,
         })
     }
 
@@ -119,7 +119,7 @@ impl Directive {
             .ok()?;
         Some(field::CallsiteMatch {
             fields,
-            level: self.level.clone(),
+            level: self.level,
         })
     }
 
@@ -417,9 +417,9 @@ impl<T: Match + Ord> DirectiveSet<T> {
     pub(crate) fn add(&mut self, directive: T) {
         // does this directive enable a more verbose level than the current
         // max? if so, update the max level.
-        let level = directive.level();
-        if *level > self.max_level {
-            self.max_level = level.clone();
+        let level = *directive.level();
+        if level > self.max_level {
+            self.max_level = level;
         }
         // insert the directive into the vec of directives, ordered by
         // specificity (length of target + number of field filters). this
@@ -460,8 +460,8 @@ impl Dynamics {
                     return Some(f);
                 }
                 match base_level {
-                    Some(ref b) if d.level > *b => base_level = Some(d.level.clone()),
-                    None => base_level = Some(d.level.clone()),
+                    Some(ref b) if d.level > *b => base_level = Some(d.level),
+                    None => base_level = Some(d.level),
                     _ => {}
                 }
                 None
@@ -690,7 +690,7 @@ impl CallsiteMatcher {
             .collect();
         SpanMatcher {
             field_matches,
-            base_level: self.base_level.clone(),
+            base_level: self.base_level,
         }
     }
 }
@@ -702,7 +702,7 @@ impl SpanMatcher {
             .iter()
             .filter_map(field::SpanMatch::filter)
             .max()
-            .unwrap_or_else(|| self.base_level.clone())
+            .unwrap_or(self.base_level)
     }
 
     pub(crate) fn record_update(&self, record: &span::Record<'_>) {

tracing-subscriber/src/filter/env/field.rs

@@ -229,7 +229,7 @@ impl CallsiteMatch {
             .collect();
         SpanMatch {
             fields,
-            level: self.level.clone(),
+            level: self.level,
             has_matched: AtomicBool::new(false),
         }
     }
@@ -263,7 +263,7 @@ impl SpanMatch {
     #[inline]
     pub(crate) fn filter(&self) -> Option<LevelFilter> {
         if self.is_matched() {
-            Some(self.level.clone())
+            Some(self.level)
         } else {
             None
         }