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

adamnemecek · web-flow · commit c95d6ba1017e · 2025-09-04T10:49:59.000-07:00
diff --git a/src/document.rs b/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(())
     }
diff --git a/src/entry.rs b/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,29 +404,29 @@ 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, "=")?;
             }
         }
         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,15 +462,15 @@ where
     V: Into<KdlValue>,
 {
     fn from((key, value): (K, V)) -> Self {
-        KdlEntry::new_prop(key, value)
+        Self::new_prop(key, value)
     }
 }
 
 impl FromStr for KdlEntry {
     type Err = KdlError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        KdlEntry::parse(s)
+        Self::parse(s)
     }
 }
 
diff --git a/src/error.rs b/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,
diff --git a/src/fmt.rs b/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();
                 }
             }
         }
diff --git a/src/identifier.rs b/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)
     }
 }
 
diff --git a/src/node.rs b/src/node.rs
@@ -625,10 +625,7 @@ impl KdlNode {
                     }
                 }
                 if idx > current_idx {
-                    panic!(
-                        "Insertion index (is {}) should be <= len (is {})",
-                        idx, current_idx
-                    );
+                    panic!("Insertion index (is {idx}) should be <= len (is {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 {})",
-                    idx, current_idx
+                    "removal index (is {idx}) should be < number of index entries (is {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,20 +830,20 @@ 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;
         for entry in &self.entries {
             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 {
diff --git a/src/v2_parser.rs b/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()),
diff --git a/src/value.rs b/src/value.rs

Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ impl KdlDocument {`
`210`	`210`
`211`	`211`	`/// Length of this document when rendered as a string.`
`212`	`212`	`pub fn len(&self) -> usize {`
`213`		`- format!("{}", self).len()`
	`213`	`+ format!("{self}").len()`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`/// Returns true if this document is completely empty (including whitespace)`
`@@ -347,7 +347,7 @@ impl KdlDocument {`
`347`	`347`	`pub fn parse(s: &str) -> Result<Self, KdlError> {`
`348`	`348`	`#[cfg(not(feature = "v1-fallback"))]`
`349`	`349`	`{`
`350`		`- KdlDocument::parse_v2(s)`
	`350`	`+ Self::parse_v2(s)`
`351`	`351`	`}`
`352`	`352`	`#[cfg(feature = "v1-fallback")]`
`353`	`353`	`{`
`@@ -457,7 +457,7 @@ impl KdlDocument {`
`457`	`457`	`#[cfg(feature = "v1")]`
`458`	`458`	`impl From<kdlv1::KdlDocument> for KdlDocument {`
`459`	`459`	`fn from(value: kdlv1::KdlDocument) -> Self {`
`460`		`- KdlDocument {`
	`460`	`+ Self {`
`461`	`461`	`nodes: value.nodes().iter().map(\|x\| x.clone().into()).collect(),`
`462`	`462`	`format: Some(KdlDocumentFormat {`
`463`	`463`	`leading: value.leading().unwrap_or("").into(),`
`@@ -522,7 +522,7 @@ impl std::str::FromStr for KdlDocument {`
`522`	`522`	`type Err = KdlError;`
`523`	`523`
`524`	`524`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`525`		`- KdlDocument::parse(s)`
	`525`	`+ Self::parse(s)`
`526`	`526`	`}`
`527`	`527`	`}`
`528`	`528`
`@@ -539,13 +539,13 @@ impl KdlDocument {`
`539`	`539`	`indent: usize,`
`540`	`540`	`) -> std::fmt::Result {`
`541`	`541`	`if let Some(KdlDocumentFormat { leading, .. }) = self.format() {`
`542`		`- write!(f, "{}", leading)?;`
	`542`	`+ write!(f, "{leading}")?;`
`543`	`543`	`}`
`544`	`544`	`for node in &self.nodes {`
`545`	`545`	`node.stringify(f, indent)?;`
`546`	`546`	`}`
`547`	`547`	`if let Some(KdlDocumentFormat { trailing, .. }) = self.format() {`
`548`		`- write!(f, "{}", trailing)?;`
	`548`	`+ write!(f, "{trailing}")?;`
`549`	`549`	`}`
`550`	`550`	`Ok(())`
`551`	`551`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ impl std::hash::Hash for KdlEntry {`
`41`	`41`	`impl KdlEntry {`
`42`	`42`	`/// Creates a new Argument (positional) KdlEntry.`
`43`	`43`	`pub fn new(value: impl Into<KdlValue>) -> Self {`
`44`		`- KdlEntry {`
	`44`	`+ Self {`
`45`	`45`	`ty: None,`
`46`	`46`	`value: value.into(),`
`47`	`47`	`name: None,`
`@@ -129,7 +129,7 @@ impl KdlEntry {`
`129`	`129`
`130`	`130`	`/// Creates a new Property (key/value) KdlEntry.`
`131`	`131`	`pub fn new_prop(key: impl Into<KdlIdentifier>, value: impl Into<KdlValue>) -> Self {`
`132`		`- KdlEntry {`
	`132`	`+ Self {`
`133`	`133`	`ty: None,`
`134`	`134`	`value: value.into(),`
`135`	`135`	`name: Some(key.into()),`
`@@ -153,7 +153,7 @@ impl KdlEntry {`
`153`	`153`
`154`	`154`	`/// Length of this entry when rendered as a string.`
`155`	`155`	`pub fn len(&self) -> usize {`
`156`		`- format!("{}", self).len()`
	`156`	`+ format!("{self}").len()`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`/// Returns true if this entry is completely empty (including whitespace).`
`@@ -385,7 +385,7 @@ impl KdlEntry {`
`385`	`385`	`#[cfg(feature = "v1")]`
`386`	`386`	`impl From<kdlv1::KdlEntry> for KdlEntry {`
`387`	`387`	`fn from(value: kdlv1::KdlEntry) -> Self {`
`388`		`- KdlEntry {`
	`388`	`+ Self {`
`389`	`389`	`ty: value.ty().map(\|x\| x.clone().into()),`
`390`	`390`	`value: value.value().clone().into(),`
`391`	`391`	`name: value.name().map(\|x\| x.clone().into()),`
`@@ -404,29 +404,29 @@ impl From<kdlv1::KdlEntry> for KdlEntry {`
`404`	`404`	`impl Display for KdlEntry {`
`405`	`405`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`406`	`406`	`if let Some(KdlEntryFormat { leading, .. }) = &self.format {`
`407`		`- write!(f, "{}", leading)?;`
	`407`	`+ write!(f, "{leading}")?;`
`408`	`408`	`}`
`409`	`409`	`if let Some(name) = &self.name {`
`410`		`- write!(f, "{}", name)?;`
	`410`	`+ write!(f, "{name}")?;`
`411`	`411`	`if let Some(KdlEntryFormat {`
`412`	`412`	`after_key,`
`413`	`413`	`after_eq,`
`414`	`414`	`..`
`415`	`415`	`}) = &self.format`
`416`	`416`	`{`
`417`		`- write!(f, "{}={}", after_key, after_eq)?;`
	`417`	`+ write!(f, "{after_key}={after_eq}")?;`
`418`	`418`	`} else {`
`419`	`419`	`write!(f, "=")?;`
`420`	`420`	`}`
`421`	`421`	`}`
`422`	`422`	`if let Some(ty) = &self.ty {`
`423`	`423`	`write!(f, "(")?;`
`424`	`424`	`if let Some(KdlEntryFormat { before_ty_name, .. }) = &self.format {`
`425`		`- write!(f, "{}", before_ty_name)?;`
	`425`	`+ write!(f, "{before_ty_name}")?;`
`426`	`426`	`}`
`427`		`- write!(f, "{}", ty)?;`
	`427`	`+ write!(f, "{ty}")?;`
`428`	`428`	`if let Some(KdlEntryFormat { after_ty_name, .. }) = &self.format {`
`429`		`- write!(f, "{}", after_ty_name)?;`
	`429`	`+ write!(f, "{after_ty_name}")?;`
`430`	`430`	`}`
`431`	`431`	`write!(f, ")")?;`
`432`	`432`	`}`
`@@ -436,12 +436,12 @@ impl Display for KdlEntry {`
`436`	`436`	`..`
`437`	`437`	`}) = &self.format`
`438`	`438`	`{`
`439`		`- write!(f, "{}{}", after_ty, value_repr)?;`
	`439`	`+ write!(f, "{after_ty}{value_repr}")?;`
`440`	`440`	`} else {`
`441`	`441`	`write!(f, "{}", self.value)?;`
`442`	`442`	`}`
`443`	`443`	`if let Some(KdlEntryFormat { trailing, .. }) = &self.format {`
`444`		`- write!(f, "{}", trailing)?;`
	`444`	`+ write!(f, "{trailing}")?;`
`445`	`445`	`}`
`446`	`446`	`Ok(())`
`447`	`447`	`}`
`@@ -452,7 +452,7 @@ where`
`452`	`452`	`T: Into<KdlValue>,`
`453`	`453`	`{`
`454`	`454`	`fn from(value: T) -> Self {`
`455`		`- KdlEntry::new(value)`
	`455`	`+ Self::new(value)`
`456`	`456`	`}`
`457`	`457`	`}`
`458`	`458`
`@@ -462,15 +462,15 @@ where`
`462`	`462`	`V: Into<KdlValue>,`
`463`	`463`	`{`
`464`	`464`	`fn from((key, value): (K, V)) -> Self {`
`465`		`- KdlEntry::new_prop(key, value)`
	`465`	`+ Self::new_prop(key, value)`
`466`	`466`	`}`
`467`	`467`	`}`
`468`	`468`
`469`	`469`	`impl FromStr for KdlEntry {`
`470`	`470`	`type Err = KdlError;`
`471`	`471`
`472`	`472`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`473`		`- KdlEntry::parse(s)`
	`473`	`+ Self::parse(s)`
`474`	`474`	`}`
`475`	`475`	`}`
`476`	`476`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ pub struct FormatConfigBuilder<'a>(FormatConfig<'a>);`
`43`	`43`	`impl<'a> FormatConfigBuilder<'a> {`
`44`	`44`	/// Creates a new [`FormatConfig`] builder with default configuration.
`45`	`45`	`pub const fn new() -> Self {`
`46`		`- FormatConfigBuilder(FormatConfig {`
	`46`	`+ Self(FormatConfig {`
`47`	`47`	`indent_level: 0,`
`48`	`48`	`indent: " ",`
`49`	`49`	`no_comments: false,`
`@@ -122,7 +122,7 @@ pub(crate) fn autoformat_leading(leading: &mut String, config: &FormatConfig<'_>`
`122`	`122`	`for _ in 0..config.indent_level {`
`123`	`123`	`result.push_str(config.indent);`
`124`	`124`	`}`
`125`		`- writeln!(result, "{}", trimmed).unwrap();`
	`125`	`+ writeln!(result, "{trimmed}").unwrap();`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -625,10 +625,7 @@ impl KdlNode {`
`625`	`625`	`}`
`626`	`626`	`}`
`627`	`627`	`if idx > current_idx {`
`628`		`- panic!(`
`629`		`- "Insertion index (is {}) should be <= len (is {})",`
`630`		`- idx, current_idx`
`631`		`- );`
	`628`	`+ panic!("Insertion index (is {idx}) should be <= len (is {current_idx})");`
`632`	`629`	`} else {`
`633`	`630`	`self.entries.push(entry);`
`634`	`631`	`None`
`@@ -720,8 +717,7 @@ impl KdlNode {`
`720`	`717`	`}`
`721`	`718`	`}`
`722`	`719`	`panic!(`
`723`		`- "removal index (is {}) should be < number of index entries (is {})",`
`724`		`- idx, current_idx`
	`720`	`+ "removal index (is {idx}) should be < number of index entries (is {current_idx})"`
`725`	`721`	`);`
`726`	`722`	`}`
`727`	`723`	`}`
`@@ -766,19 +762,19 @@ pub enum NodeKey {`
`766`	`762`
`767`	`763`	`impl From<&str> for NodeKey {`
`768`	`764`	`fn from(key: &str) -> Self {`
`769`		`- NodeKey::Key(key.into())`
	`765`	`+ Self::Key(key.into())`
`770`	`766`	`}`
`771`	`767`	`}`
`772`	`768`
`773`	`769`	`impl From<String> for NodeKey {`
`774`	`770`	`fn from(key: String) -> Self {`
`775`		`- NodeKey::Key(key.into())`
	`771`	`+ Self::Key(key.into())`
`776`	`772`	`}`
`777`	`773`	`}`
`778`	`774`
`779`	`775`	`impl From<usize> for NodeKey {`
`780`	`776`	`fn from(key: usize) -> Self {`
`781`		`- NodeKey::Index(key)`
	`777`	`+ Self::Index(key)`
`782`	`778`	`}`
`783`	`779`	`}`
`784`	`780`
`@@ -834,20 +830,20 @@ impl KdlNode {`
`834`	`830`	`indent: usize,`
`835`	`831`	`) -> std::fmt::Result {`
`836`	`832`	`if let Some(KdlNodeFormat { leading, .. }) = self.format() {`
`837`		`- write!(f, "{}", leading)?;`
	`833`	`+ write!(f, "{leading}")?;`
`838`	`834`	`} else {`
`839`	`835`	`write!(f, "{:indent$}", "", indent = indent)?;`
`840`	`836`	`}`
`841`	`837`	`if let Some(ty) = &self.ty {`
`842`		`- write!(f, "({})", ty)?;`
	`838`	`+ write!(f, "({ty})")?;`
`843`	`839`	`}`
`844`	`840`	`write!(f, "{}", self.name)?;`
`845`	`841`	`let mut space_before_children = true;`
`846`	`842`	`for entry in &self.entries {`
`847`	`843`	`if entry.format().is_none() {`
`848`	`844`	`write!(f, " ")?;`
`849`	`845`	`}`
`850`		`- write!(f, "{}", entry)?;`
	`846`	`+ write!(f, "{entry}")?;`
`851`	`847`	`space_before_children = entry.format().is_none();`
`852`	`848`	`}`
`853`	`849`	`if let Some(children) = &self.children {`