fix(clippy/fmt): ran clippy + cargo fmt (#129)

src/document.rs

@@ -210,7 +210,7 @@ impl KdlDocument {
 
     /// Length of this document when rendered as a string.
     pub fn len(&self) -> usize {
-        format!("{}", self).len()
+        format!("{self}").len()
     }
 
     /// Returns true if this document is completely empty (including whitespace)
@@ -347,7 +347,7 @@ impl KdlDocument {
     pub fn parse(s: &str) -> Result<Self, KdlError> {
         #[cfg(not(feature = "v1-fallback"))]
         {
-            KdlDocument::parse_v2(s)
+            Self::parse_v2(s)
         }
         #[cfg(feature = "v1-fallback")]
         {
@@ -457,7 +457,7 @@ impl KdlDocument {
 #[cfg(feature = "v1")]
 impl From<kdlv1::KdlDocument> for KdlDocument {
     fn from(value: kdlv1::KdlDocument) -> Self {
-        KdlDocument {
+        Self {
             nodes: value.nodes().iter().map(|x| x.clone().into()).collect(),
             format: Some(KdlDocumentFormat {
                 leading: value.leading().unwrap_or("").into(),
@@ -522,7 +522,7 @@ impl std::str::FromStr for KdlDocument {
     type Err = KdlError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        KdlDocument::parse(s)
+        Self::parse(s)
     }
 }
 
@@ -539,13 +539,13 @@ impl KdlDocument {
         indent: usize,
     ) -> std::fmt::Result {
         if let Some(KdlDocumentFormat { leading, .. }) = self.format() {
-            write!(f, "{}", leading)?;
+            write!(f, "{leading}")?;
         }
         for node in &self.nodes {
             node.stringify(f, indent)?;
         }
         if let Some(KdlDocumentFormat { trailing, .. }) = self.format() {
-            write!(f, "{}", trailing)?;
+            write!(f, "{trailing}")?;
         }
         Ok(())
     }

src/entry.rs

@@ -41,7 +41,7 @@ impl std::hash::Hash for KdlEntry {
 impl KdlEntry {
     /// Creates a new Argument (positional) KdlEntry.
     pub fn new(value: impl Into<KdlValue>) -> Self {
-        KdlEntry {
+        Self {
             ty: None,
             value: value.into(),
             name: None,
@@ -129,7 +129,7 @@ impl KdlEntry {
 
     /// Creates a new Property (key/value) KdlEntry.
     pub fn new_prop(key: impl Into<KdlIdentifier>, value: impl Into<KdlValue>) -> Self {
-        KdlEntry {
+        Self {
             ty: None,
             value: value.into(),
             name: Some(key.into()),
@@ -153,7 +153,7 @@ impl KdlEntry {
 
     /// Length of this entry when rendered as a string.
     pub fn len(&self) -> usize {
-        format!("{}", self).len()
+        format!("{self}").len()
     }
 
     /// Returns true if this entry is completely empty (including whitespace).
@@ -385,7 +385,7 @@ impl KdlEntry {
 #[cfg(feature = "v1")]
 impl From<kdlv1::KdlEntry> for KdlEntry {
     fn from(value: kdlv1::KdlEntry) -> Self {
-        KdlEntry {
+        Self {
             ty: value.ty().map(|x| x.clone().into()),
             value: value.value().clone().into(),
             name: value.name().map(|x| x.clone().into()),
@@ -404,17 +404,17 @@ impl From<kdlv1::KdlEntry> for KdlEntry {
 impl Display for KdlEntry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(KdlEntryFormat { leading, .. }) = &self.format {
-            write!(f, "{}", leading)?;
+            write!(f, "{leading}")?;
         }
         if let Some(name) = &self.name {
-            write!(f, "{}", name)?;
+            write!(f, "{name}")?;
             if let Some(KdlEntryFormat {
                 after_key,
                 after_eq,
                 ..
             }) = &self.format
             {
-                write!(f, "{}={}", after_key, after_eq)?;
+                write!(f, "{after_key}={after_eq}")?;
             } else {
                 write!(f, "=")?;
             }
@@ -422,11 +422,11 @@ impl Display for KdlEntry {
         if let Some(ty) = &self.ty {
             write!(f, "(")?;
             if let Some(KdlEntryFormat { before_ty_name, .. }) = &self.format {
-                write!(f, "{}", before_ty_name)?;
+                write!(f, "{before_ty_name}")?;
             }
-            write!(f, "{}", ty)?;
+            write!(f, "{ty}")?;
             if let Some(KdlEntryFormat { after_ty_name, .. }) = &self.format {
-                write!(f, "{}", after_ty_name)?;
+                write!(f, "{after_ty_name}")?;
             }
             write!(f, ")")?;
         }
@@ -436,12 +436,12 @@ impl Display for KdlEntry {
             ..
         }) = &self.format
         {
-            write!(f, "{}{}", after_ty, value_repr)?;
+            write!(f, "{after_ty}{value_repr}")?;
         } else {
             write!(f, "{}", self.value)?;
         }
         if let Some(KdlEntryFormat { trailing, .. }) = &self.format {
-            write!(f, "{}", trailing)?;
+            write!(f, "{trailing}")?;
         }
         Ok(())
     }
@@ -452,7 +452,7 @@ where
     T: Into<KdlValue>,
 {
     fn from(value: T) -> Self {
-        KdlEntry::new(value)
+        Self::new(value)
     }
 }
 
@@ -462,7 +462,7 @@ where
     V: Into<KdlValue>,
 {
     fn from((key, value): (K, V)) -> Self {
-        KdlEntry::new_prop(key, value)
+        Self::new_prop(key, value)
     }
 }
 
@@ -470,7 +470,7 @@ impl FromStr for KdlEntry {
     type Err = KdlError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        KdlEntry::parse(s)
+        Self::parse(s)
     }
 }
 

src/error.rs

@@ -121,7 +121,7 @@ impl Diagnostic for KdlDiagnostic {
 impl From<kdlv1::KdlError> for KdlError {
     fn from(value: kdlv1::KdlError) -> Self {
         let input = Arc::new(value.input);
-        KdlError {
+        Self {
             input: input.clone(),
             diagnostics: vec![KdlDiagnostic {
                 input,

src/fmt.rs

@@ -43,7 +43,7 @@ pub struct FormatConfigBuilder<'a>(FormatConfig<'a>);
 impl<'a> FormatConfigBuilder<'a> {
     /// Creates a new [`FormatConfig`] builder with default configuration.
     pub const fn new() -> Self {
-        FormatConfigBuilder(FormatConfig {
+        Self(FormatConfig {
             indent_level: 0,
             indent: "    ",
             no_comments: false,
@@ -122,7 +122,7 @@ pub(crate) fn autoformat_leading(leading: &mut String, config: &FormatConfig<'_>
                     for _ in 0..config.indent_level {
                         result.push_str(config.indent);
                     }
-                    writeln!(result, "{}", trimmed).unwrap();
+                    writeln!(result, "{trimmed}").unwrap();
                 }
             }
         }

src/identifier.rs

@@ -68,7 +68,7 @@ impl KdlIdentifier {
 
     /// Length of this identifier when rendered as a string.
     pub fn len(&self) -> usize {
-        format!("{}", self).len()
+        format!("{self}").len()
     }
 
     /// Returns true if this identifier is completely empty.
@@ -117,7 +117,7 @@ impl KdlIdentifier {
 #[cfg(feature = "v1")]
 impl From<kdlv1::KdlIdentifier> for KdlIdentifier {
     fn from(value: kdlv1::KdlIdentifier) -> Self {
-        KdlIdentifier {
+        Self {
             value: value.value().into(),
             repr: value.repr().map(|x| x.into()),
             #[cfg(feature = "span")]
@@ -129,7 +129,7 @@ impl From<kdlv1::KdlIdentifier> for KdlIdentifier {
 impl Display for KdlIdentifier {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(repr) = &self.repr {
-            write!(f, "{}", repr)
+            write!(f, "{repr}")
         } else {
             write!(f, "{}", KdlValue::String(self.value().into()))
         }
@@ -138,7 +138,7 @@ impl Display for KdlIdentifier {
 
 impl From<&str> for KdlIdentifier {
     fn from(value: &str) -> Self {
-        KdlIdentifier {
+        Self {
             value: value.to_string(),
             repr: None,
             #[cfg(feature = "span")]
@@ -149,7 +149,7 @@ impl From<&str> for KdlIdentifier {
 
 impl From<String> for KdlIdentifier {
     fn from(value: String) -> Self {
-        KdlIdentifier {
+        Self {
             value,
             repr: None,
             #[cfg(feature = "span")]
@@ -168,7 +168,7 @@ impl FromStr for KdlIdentifier {
     type Err = KdlError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        KdlIdentifier::parse(s)
+        Self::parse(s)
     }
 }
 

src/node.rs

@@ -625,10 +625,7 @@ impl KdlNode {
                     }
                 }
                 if idx > current_idx {
-                    panic!(
+                    panic!("Insertion index (is {idx}) should be <= len (is {current_idx})");
-                        "Insertion index (is {}) should be <= len (is {})",
-                        idx, current_idx
-                    );
                 } else {
                     self.entries.push(entry);
                     None
@@ -720,8 +717,7 @@ impl KdlNode {
                     }
                 }
                 panic!(
-                    "removal index (is {}) should be < number of index entries (is {})",
+                    "removal index (is {idx}) should be < number of index entries (is {current_idx})"
-                    idx, current_idx
                 );
             }
         }
@@ -766,19 +762,19 @@ pub enum NodeKey {
 
 impl From<&str> for NodeKey {
     fn from(key: &str) -> Self {
-        NodeKey::Key(key.into())
+        Self::Key(key.into())
     }
 }
 
 impl From<String> for NodeKey {
     fn from(key: String) -> Self {
-        NodeKey::Key(key.into())
+        Self::Key(key.into())
     }
 }
 
 impl From<usize> for NodeKey {
     fn from(key: usize) -> Self {
-        NodeKey::Index(key)
+        Self::Index(key)
     }
 }
 
@@ -834,12 +830,12 @@ impl KdlNode {
         indent: usize,
     ) -> std::fmt::Result {
         if let Some(KdlNodeFormat { leading, .. }) = self.format() {
-            write!(f, "{}", leading)?;
+            write!(f, "{leading}")?;
         } else {
             write!(f, "{:indent$}", "", indent = indent)?;
         }
         if let Some(ty) = &self.ty {
-            write!(f, "({})", ty)?;
+            write!(f, "({ty})")?;
         }
         write!(f, "{}", self.name)?;
         let mut space_before_children = true;
@@ -847,7 +843,7 @@ impl KdlNode {
             if entry.format().is_none() {
                 write!(f, " ")?;
             }
-            write!(f, "{}", entry)?;
+            write!(f, "{entry}")?;
             space_before_children = entry.format().is_none();
         }
         if let Some(children) = &self.children {

src/v2_parser.rs

@@ -140,7 +140,7 @@ impl<I: Stream> AddContext<I, KdlParseContext> for KdlParseError {
 
 impl<'a> FromExternalError<Input<'a>, ParseIntError> for KdlParseError {
     fn from_external_error(_: &Input<'a>, _kind: ErrorKind, e: ParseIntError) -> Self {
-        KdlParseError {
+        Self {
             span: None,
             message: Some(format!("{e}")),
             label: Some("invalid integer".into()),
@@ -152,7 +152,7 @@ impl<'a> FromExternalError<Input<'a>, ParseIntError> for KdlParseError {
 
 impl<'a> FromExternalError<Input<'a>, ParseFloatError> for KdlParseError {
     fn from_external_error(_input: &Input<'a>, _kind: ErrorKind, e: ParseFloatError) -> Self {
-        KdlParseError {
+        Self {
             span: None,
             label: Some("invalid float".into()),
             help: None,
@@ -170,7 +170,7 @@ impl<'a> FromExternalError<Input<'a>, NegativeUnsignedError> for KdlParseError {
         _kind: ErrorKind,
         _e: NegativeUnsignedError,
     ) -> Self {
-        KdlParseError {
+        Self {
             span: None,
             message: Some("Tried to parse a negative number as an unsigned integer".into()),
             label: Some("negative unsigned int".into()),

src/value.rs

@@ -62,9 +62,9 @@ impl PartialEq for KdlValue {
 impl std::hash::Hash for KdlValue {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         match self {
-            KdlValue::String(val) => val.hash(state),
+            Self::String(val) => val.hash(state),
-            KdlValue::Integer(val) => val.hash(state),
+            Self::Integer(val) => val.hash(state),
-            KdlValue::Float(val) => {
+            Self::Float(val) => {
                 let val = if val == &f64::INFINITY {
                     f64::MAX
                 } else if val == &f64::NEG_INFINITY {
@@ -79,8 +79,8 @@ impl std::hash::Hash for KdlValue {
                 (val.trunc() as i128).hash(state);
                 (val.fract() as i128).hash(state);
             }
-            KdlValue::Bool(val) => val.hash(state),
+            Self::Bool(val) => val.hash(state),
-            KdlValue::Null => core::mem::discriminant(self).hash(state),
+            Self::Null => core::mem::discriminant(self).hash(state),
         }
     }
 }
@@ -154,7 +154,7 @@ impl Display for KdlValue {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::String(_) => self.write_string(f),
-            Self::Integer(value) => write!(f, "{:?}", value),
+            Self::Integer(value) => write!(f, "{value:?}"),
             Self::Float(value) => write!(
                 f,
                 "{}",
@@ -168,7 +168,7 @@ impl Display for KdlValue {
                     format!("{:?}", *value)
                 }
             ),
-            Self::Bool(value) => write!(f, "#{}", value),
+            Self::Bool(value) => write!(f, "#{value}"),
             Self::Null => write!(f, "#null"),
         }
     }
@@ -210,13 +210,13 @@ impl KdlValue {
             write!(f, "\"")?;
             for char in string.chars() {
                 match char {
-                    '\\' | '"' => write!(f, "\\{}", char)?,
+                    '\\' | '"' => write!(f, "\\{char}")?,
                     '\n' => write!(f, "\\n")?,
                     '\r' => write!(f, "\\r")?,
                     '\t' => write!(f, "\\t")?,
                     '\u{08}' => write!(f, "\\b")?,
                     '\u{0C}' => write!(f, "\\f")?,
-                    _ => write!(f, "{}", char)?,
+                    _ => write!(f, "{char}")?,
                 }
             }
             write!(f, "\"")?;
@@ -227,42 +227,42 @@ impl KdlValue {
 
 impl From<i128> for KdlValue {
     fn from(value: i128) -> Self {
-        KdlValue::Integer(value)
+        Self::Integer(value)
     }
 }
 
 impl From<f64> for KdlValue {
     fn from(value: f64) -> Self {
-        KdlValue::Float(value)
+        Self::Float(value)
     }
 }
 
 impl From<&str> for KdlValue {
     fn from(value: &str) -> Self {
-        KdlValue::String(value.to_string())
+        Self::String(value.to_string())
     }
 }
 
 impl From<String> for KdlValue {
     fn from(value: String) -> Self {
-        KdlValue::String(value)
+        Self::String(value)
     }
 }
 
 impl From<bool> for KdlValue {
     fn from(value: bool) -> Self {
-        KdlValue::Bool(value)
+        Self::Bool(value)
     }
 }
 
 impl<T> From<Option<T>> for KdlValue
 where
-    T: Into<KdlValue>,
+    T: Into<Self>,
 {
     fn from(value: Option<T>) -> Self {
         match value {
             Some(value) => value.into(),
-            None => KdlValue::Null,
+            None => Self::Null,
         }
     }
 }
@@ -271,15 +271,15 @@ where
 impl From<kdlv1::KdlValue> for KdlValue {
     fn from(value: kdlv1::KdlValue) -> Self {
         match value {
-            kdlv1::KdlValue::RawString(s) => KdlValue::String(s),
+            kdlv1::KdlValue::RawString(s) => Self::String(s),
-            kdlv1::KdlValue::String(s) => KdlValue::String(s),
+            kdlv1::KdlValue::String(s) => Self::String(s),
-            kdlv1::KdlValue::Base2(i) => KdlValue::Integer(i.into()),
+            kdlv1::KdlValue::Base2(i) => Self::Integer(i.into()),
-            kdlv1::KdlValue::Base8(i) => KdlValue::Integer(i.into()),
+            kdlv1::KdlValue::Base8(i) => Self::Integer(i.into()),
-            kdlv1::KdlValue::Base10(i) => KdlValue::Integer(i.into()),
+            kdlv1::KdlValue::Base10(i) => Self::Integer(i.into()),
-            kdlv1::KdlValue::Base10Float(f) => KdlValue::Float(f),
+            kdlv1::KdlValue::Base10Float(f) => Self::Float(f),
-            kdlv1::KdlValue::Base16(i) => KdlValue::Integer(i.into()),
+            kdlv1::KdlValue::Base16(i) => Self::Integer(i.into()),
-            kdlv1::KdlValue::Bool(b) => KdlValue::Bool(b),
+            kdlv1::KdlValue::Bool(b) => Self::Bool(b),
-            kdlv1::KdlValue::Null => KdlValue::Null,
+            kdlv1::KdlValue::Null => Self::Null,
         }
     }
 }