Set all crates to 2021 edition

Cargo.toml

@@ -14,6 +14,7 @@ categories = ["development-tools::debugging"]
 keywords = ["logging"]
 exclude = ["rfcs/**/*"]
 rust-version = "1.60.0"
+edition = "2021"
 
 [package.metadata.docs.rs]
 features = ["std", "serde", "kv_unstable_std", "kv_unstable_sval", "kv_unstable_serde"]

benches/value.rs

@@ -1,9 +1,6 @@
 #![cfg(feature = "kv_unstable")]
 #![feature(test)]
 
-extern crate log;
-extern crate test;
-
 use log::kv::Value;
 
 #[bench]

src/kv/key.rs

@@ -103,11 +103,8 @@ mod std_support {
 mod sval_support {
     use super::*;
 
-    extern crate sval;
-    extern crate sval_ref;
-
-    use self::sval::Value;
-    use self::sval_ref::ValueRef;
+    use sval::Value;
+    use sval_ref::ValueRef;
 
     impl<'a> Value for Key<'a> {
         fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(
@@ -119,10 +116,7 @@ mod sval_support {
     }
 
     impl<'a> ValueRef<'a> for Key<'a> {
-        fn stream_ref<S: self::sval::Stream<'a> + ?Sized>(
-            &self,
-            stream: &mut S,
-        ) -> self::sval::Result {
+        fn stream_ref<S: sval::Stream<'a> + ?Sized>(&self, stream: &mut S) -> sval::Result {
             self.key.stream(stream)
         }
     }
@@ -132,9 +126,7 @@ mod sval_support {
 mod serde_support {
     use super::*;
 
-    extern crate serde;
-
-    use self::serde::{Serialize, Serializer};
+    use serde::{Serialize, Serializer};
 
     impl<'a> Serialize for Key<'a> {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

src/kv/source.rs

@@ -1,14 +1,6 @@
 //! Sources for key-value pairs.
 
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval;
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval_ref;
-
-#[cfg(feature = "kv_unstable_serde")]
-extern crate serde;
-
-use kv::{Error, Key, ToKey, ToValue, Value};
+use crate::kv::{Error, Key, ToKey, ToValue, Value};
 use std::fmt;
 
 /// A source of key-value pairs.
@@ -64,7 +56,7 @@ pub trait Source {
     fn count(&self) -> usize;
 }
 
-/// The default implemention of `Source::get`
+/// The default implementation of `Source::get`
 pub(crate) fn get_default<'v>(source: &'v (impl Source + ?Sized), key: Key) -> Option<Value<'v>> {
     struct Get<'k, 'v> {
         key: Key<'k>,
@@ -319,7 +311,7 @@ mod std_support {
             Ok(())
         }
 
-        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        fn get(&self, key: Key) -> Option<Value<'_>> {
             BTreeMap::get(self, key.as_str()).map(|v| v.to_value())
         }
 
@@ -330,10 +322,12 @@ mod std_support {
 
     #[cfg(test)]
     mod tests {
-        use super::*;
-        use kv::value::tests::Token;
         use std::collections::{BTreeMap, HashMap};
 
+        use crate::kv::value::tests::Token;
+
+        use super::*;
+
         #[test]
         fn count() {
             assert_eq!(1, Source::count(&Box::new(("a", 1))));
@@ -462,17 +456,17 @@ where
 mod sval_support {
     use super::*;
 
-    impl<S> self::sval::Value for AsMap<S>
+    impl<S> sval::Value for AsMap<S>
     where
         S: Source,
     {
-        fn stream<'sval, SV: self::sval::Stream<'sval> + ?Sized>(
+        fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>(
             &'sval self,
             stream: &mut SV,
-        ) -> self::sval::Result {
+        ) -> sval::Result {
             struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
 
-            impl<'a, 'kvs, V: self::sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
+            impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
                 fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
                     self.0
                         .map_key_begin()
@@ -498,31 +492,31 @@ mod sval_support {
 
             stream
                 .map_begin(Some(self.count()))
-                .map_err(|_| self::sval::Error::new())?;
+                .map_err(|_| sval::Error::new())?;
 
             self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::new())?;
+                .map_err(|_| sval::Error::new())?;
 
-            stream.map_end().map_err(|_| self::sval::Error::new())
+            stream.map_end().map_err(|_| sval::Error::new())
         }
     }
 
-    impl<S> self::sval::Value for AsList<S>
+    impl<S> sval::Value for AsList<S>
     where
         S: Source,
     {
-        fn stream<'sval, SV: self::sval::Stream<'sval> + ?Sized>(
+        fn stream<'sval, SV: sval::Stream<'sval> + ?Sized>(
             &'sval self,
             stream: &mut SV,
-        ) -> self::sval::Result {
+        ) -> sval::Result {
             struct StreamVisitor<'a, V: ?Sized>(&'a mut V);
 
-            impl<'a, 'kvs, V: self::sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
+            impl<'a, 'kvs, V: sval::Stream<'kvs> + ?Sized> Visitor<'kvs> for StreamVisitor<'a, V> {
                 fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
                     self.0
                         .seq_value_begin()
                         .map_err(|_| Error::msg("failed to stream seq value"))?;
-                    self::sval_ref::stream_ref(self.0, (key, value))
+                    sval_ref::stream_ref(self.0, (key, value))
                         .map_err(|_| Error::msg("failed to stream seq value"))?;
                     self.0
                         .seq_value_end()
@@ -534,24 +528,20 @@ mod sval_support {
 
             stream
                 .seq_begin(Some(self.count()))
-                .map_err(|_| self::sval::Error::new())?;
+                .map_err(|_| sval::Error::new())?;
 
             self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::new())?;
+                .map_err(|_| sval::Error::new())?;
 
-            stream.seq_end().map_err(|_| self::sval::Error::new())
+            stream.seq_end().map_err(|_| sval::Error::new())
         }
     }
 
     #[cfg(test)]
     mod tests {
-        extern crate sval_derive;
-
         use super::*;
-
-        use self::sval_derive::Value;
-
         use crate::kv::source;
+        use sval_derive::Value;
 
         #[test]
         fn derive_stream() {
@@ -575,8 +565,7 @@ pub mod as_map {
     //! `serde` adapters for serializing a `Source` as a map.
 
     use super::*;
-
-    use self::serde::{Serialize, Serializer};
+    use serde::{Serialize, Serializer};
 
     /// Serialize a `Source` as a map.
     pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
@@ -593,8 +582,7 @@ pub mod as_list {
     //! `serde` adapters for serializing a `Source` as a list.
 
     use super::*;
-
-    use self::serde::{Serialize, Serializer};
+    use serde::{Serialize, Serializer};
 
     /// Serialize a `Source` as a list.
     pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
@@ -609,8 +597,7 @@ pub mod as_list {
 #[cfg(feature = "kv_unstable_serde")]
 mod serde_support {
     use super::*;
-
-    use self::serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer};
+    use serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer};
 
     impl<T> Serialize for AsMap<T>
     where
@@ -677,10 +664,8 @@ mod serde_support {
     #[cfg(test)]
     mod tests {
         use super::*;
-
-        use self::serde::Serialize;
-
         use crate::kv::source;
+        use serde::Serialize;
 
         #[test]
         fn derive_serialize() {
@@ -705,8 +690,9 @@ mod serde_support {
 
 #[cfg(test)]
 mod tests {
+    use crate::kv::value::tests::Token;
+
     use super::*;
-    use kv::value::tests::Token;
 
     #[test]
     fn source_is_object_safe() {

src/kv/value.rs

@@ -2,19 +2,9 @@
 
 use std::fmt;
 
-extern crate value_bag;
+pub use crate::kv::Error;
 
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval;
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval_ref;
-
-#[cfg(feature = "kv_unstable_serde")]
-extern crate serde;
-
-use self::value_bag::ValueBag;
-
-pub use kv::Error;
+use value_bag::ValueBag;
 
 /// A type that can be converted into a [`Value`](struct.Value.html).
 pub trait ToValue {
@@ -199,7 +189,7 @@ impl<'v> Value<'v> {
     /// Get a value from a type implementing `serde::Serialize`.
     pub fn capture_serde<T>(value: &'v T) -> Self
     where
-        T: self::serde::Serialize + 'static,
+        T: serde::Serialize + 'static,
     {
         Value {
             inner: ValueBag::capture_serde1(value),
@@ -210,7 +200,7 @@ impl<'v> Value<'v> {
     #[cfg(feature = "kv_unstable_sval")]
     pub fn capture_sval<T>(value: &'v T) -> Self
     where
-        T: self::sval::Value + 'static,
+        T: sval::Value + 'static,
     {
         Value {
             inner: ValueBag::capture_sval2(value),
@@ -241,7 +231,7 @@ impl<'v> Value<'v> {
     #[cfg(feature = "kv_unstable_serde")]
     pub fn from_serde<T>(value: &'v T) -> Self
     where
-        T: self::serde::Serialize,
+        T: serde::Serialize,
     {
         Value {
             inner: ValueBag::from_serde1(value),
@@ -252,7 +242,7 @@ impl<'v> Value<'v> {
     #[cfg(feature = "kv_unstable_sval")]
     pub fn from_sval<T>(value: &'v T) -> Self
     where
-        T: self::sval::Value,
+        T: sval::Value,
     {
         Value {
             inner: ValueBag::from_sval2(value),
@@ -406,29 +396,26 @@ impl ToValue for dyn std::error::Error + 'static {
 }
 
 #[cfg(feature = "kv_unstable_serde")]
-impl<'v> self::serde::Serialize for Value<'v> {
+impl<'v> serde::Serialize for Value<'v> {
     fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
     where
-        S: self::serde::Serializer,
+        S: serde::Serializer,
     {
         self.inner.serialize(s)
     }
 }
 
 #[cfg(feature = "kv_unstable_sval")]
-impl<'v> self::sval::Value for Value<'v> {
-    fn stream<'sval, S: self::sval::Stream<'sval> + ?Sized>(
-        &'sval self,
-        stream: &mut S,
-    ) -> self::sval::Result {
-        self::sval::Value::stream(&self.inner, stream)
+impl<'v> sval::Value for Value<'v> {
+    fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> sval::Result {
+        sval::Value::stream(&self.inner, stream)
     }
 }
 
 #[cfg(feature = "kv_unstable_sval")]
-impl<'v> self::sval_ref::ValueRef<'v> for Value<'v> {
-    fn stream_ref<S: self::sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> self::sval::Result {
-        self::sval_ref::ValueRef::stream_ref(&self.inner, stream)
+impl<'v> sval_ref::ValueRef<'v> for Value<'v> {
+    fn stream_ref<S: sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> sval::Result {
+        sval_ref::ValueRef::stream_ref(&self.inner, stream)
     }
 }
 
@@ -601,10 +588,10 @@ impl<'v> Value<'v> {
 
 #[cfg(feature = "kv_unstable_std")]
 mod std_support {
-    use super::*;
-
     use std::borrow::Cow;
 
+    use super::*;
+
     impl<T> ToValue for Box<T>
     where
         T: ToValue + ?Sized,
@@ -773,8 +760,7 @@ where
 #[cfg(test)]
 pub(crate) mod tests {
     use super::*;
-
-    pub(crate) use super::value_bag::test::TestToken as Token;
+    pub(crate) use value_bag::test::TestToken as Token;
 
     impl<'v> Value<'v> {
         pub(crate) fn to_token(&self) -> Token {

src/lib.rs

@@ -334,12 +334,10 @@
 #[cfg(all(not(feature = "std"), not(test)))]
 extern crate core as std;
 
-use std::cmp;
 #[cfg(feature = "std")]
 use std::error;
-use std::fmt;
-use std::mem;
 use std::str::FromStr;
+use std::{cmp, fmt, mem};
 
 #[macro_use]
 mod macros;
@@ -1537,9 +1535,7 @@ const fn get_max_level_inner() -> LevelFilter {
 
 #[cfg(test)]
 mod tests {
-    extern crate std;
     use super::{Level, LevelFilter, ParseLevelError};
-    use tests::std::string::ToString;
 
     #[test]
     fn test_levelfilter_from_str() {
@@ -1748,7 +1744,7 @@ mod tests {
     #[cfg(feature = "kv_unstable")]
     fn test_record_key_values_builder() {
         use super::Record;
-        use kv::{self, Visitor};
+        use crate::kv::{self, Visitor};
 
         struct TestVisitor {
             seen_pairs: usize,