Suggestion: turn off "small heuristic" of rustfmt

.editorconfig

@@ -0,0 +1,5 @@
+# see https://editorconfig.org for more options, and setup instructions for yours editor
+
+[*.rs]
+indent_style = space
+indent_size = 4

.rustfmt.toml

@@ -0,0 +1 @@
+use_small_heuristics = "Off"

src/de.rs

@@ -266,23 +266,17 @@ where
 
     fn parse_u16(&mut self) -> Result<u16> {
         let mut buf = [0; 2];
-        self.read
-            .read_into(&mut buf)
-            .map(|()| u16::from_be_bytes(buf))
+        self.read.read_into(&mut buf).map(|()| u16::from_be_bytes(buf))
     }
 
     fn parse_u32(&mut self) -> Result<u32> {
         let mut buf = [0; 4];
-        self.read
-            .read_into(&mut buf)
-            .map(|()| u32::from_be_bytes(buf))
+        self.read.read_into(&mut buf).map(|()| u32::from_be_bytes(buf))
     }
 
     fn parse_u64(&mut self) -> Result<u64> {
         let mut buf = [0; 8];
-        self.read
-            .read_into(&mut buf)
-            .map(|()| u64::from_be_bytes(buf))
+        self.read.read_into(&mut buf).map(|()| u64::from_be_bytes(buf))
     }
 
     fn parse_bytes<V>(&mut self, len: usize, visitor: V) -> Result<V::Value>
@@ -355,10 +349,7 @@ where
             }
         } else {
             // An overflow would have occured.
-            Err(Error::syntax(
-                ErrorCode::LengthOutOfRange,
-                self.read.offset(),
-            ))
+            Err(Error::syntax(ErrorCode::LengthOutOfRange, self.read.offset()))
         }
     }
 
@@ -440,7 +431,10 @@ where
         V: de::Visitor<'de>,
     {
         self.recursion_checked(|de| {
-            let value = visitor.visit_seq(SeqAccess { de, len: &mut len })?;
+            let value = visitor.visit_seq(SeqAccess {
+                de,
+                len: &mut len,
+            })?;
 
             if len != 0 {
                 Err(de.error(ErrorCode::TrailingData))
@@ -455,7 +449,9 @@ where
         V: de::Visitor<'de>,
     {
         self.recursion_checked(|de| {
-            let value = visitor.visit_seq(IndefiniteSeqAccess { de })?;
+            let value = visitor.visit_seq(IndefiniteSeqAccess {
+                de,
+            })?;
             match de.next()? {
                 Some(0xff) => Ok(value),
                 Some(_) => Err(de.error(ErrorCode::TrailingData)),
@@ -512,7 +508,10 @@ where
     {
         self.recursion_checked(|de| {
             let value = visitor.visit_enum(VariantAccess {
-                seq: SeqAccess { de, len: &mut len },
+                seq: SeqAccess {
+                    de,
+                    len: &mut len,
+                },
             })?;
 
             if len != 0 {
@@ -554,7 +553,9 @@ where
     {
         self.recursion_checked(|de| {
             let value = visitor.visit_enum(VariantAccess {
-                seq: IndefiniteSeqAccess { de },
+                seq: IndefiniteSeqAccess {
+                    de,
+                },
             })?;
             match de.next()? {
                 Some(0xff) => Ok(value),
@@ -868,7 +869,9 @@ where
                 if !self.accept_standard_enums && !self.accept_legacy_enums {
                     return Err(self.error(ErrorCode::WrongEnumFormat));
                 }
-                visitor.visit_enum(UnitVariantAccess { de: self })
+                visitor.visit_enum(UnitVariantAccess {
+                    de: self,
+                })
             }
         }
     }
@@ -1103,30 +1106,21 @@ where
     where
         T: de::DeserializeSeed<'de>,
     {
-        Err(de::Error::invalid_type(
-            de::Unexpected::UnitVariant,
-            &"newtype variant",
-        ))
+        Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant"))
     }
 
     fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
-        Err(de::Error::invalid_type(
-            de::Unexpected::UnitVariant,
-            &"tuple variant",
-        ))
+        Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant"))
     }
 
     fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
-        Err(de::Error::invalid_type(
-            de::Unexpected::UnitVariant,
-            &"struct variant",
-        ))
+        Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant"))
     }
 }
 
@@ -1190,7 +1184,9 @@ where
     where
         V: de::Visitor<'de>,
     {
-        let seed = StructVariantSeed { visitor };
+        let seed = StructVariantSeed {
+            visitor,
+        };
         match self.seq.next_element_seed(seed) {
             Ok(Some(variant)) => Ok(variant),
             Ok(None) => Err(self.seq.error(ErrorCode::ArrayTooShort)),
@@ -1346,15 +1342,19 @@ where
     where
         V: de::Visitor<'de>,
     {
-        let seed = StructVariantSeed { visitor };
+        let seed = StructVariantSeed {
+            visitor,
+        };
         self.map.next_value_seed(seed)
     }
 
     fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
     where
         V: de::Visitor<'de>,
     {
-        let seed = StructVariantSeed { visitor };
+        let seed = StructVariantSeed {
+            visitor,
+        };
         self.map.next_value_seed(seed)
     }
 }

src/error.rs

@@ -35,7 +35,10 @@ impl Error {
     }
 
     pub(crate) fn syntax(code: ErrorCode, offset: u64) -> Error {
-        Error(ErrorImpl { code, offset })
+        Error(ErrorImpl {
+            code,
+            offset,
+        })
     }
 
     #[cfg(feature = "std")]

src/read.rs

@@ -153,7 +153,10 @@ where
     /// Creates a new CBOR input source to read from a std::io input stream.
     pub fn new(reader: R) -> IoRead<R> {
         IoRead {
-            reader: OffsetReader { reader, offset: 0 },
+            reader: OffsetReader {
+                reader,
+                offset: 0,
+            },
             scratch: vec![],
             ch: None,
         }
@@ -227,10 +230,7 @@ where
 
         match transfer_result {
             Ok(r) if r == n => Ok(()),
-            Ok(_) => Err(Error::syntax(
-                ErrorCode::EofWhileParsingValue,
-                self.offset(),
-            )),
+            Ok(_) => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.offset())),
             Err(e) => Err(Error::io(e)),
         }
     }
@@ -318,10 +318,7 @@ impl<'a> SliceRead<'a> {
     fn end(&self, n: usize) -> Result<usize> {
         match self.index.checked_add(n) {
             Some(end) if end <= self.slice.len() => Ok(end),
-            _ => Err(Error::syntax(
-                ErrorCode::EofWhileParsingValue,
-                self.slice.len() as u64,
-            )),
+            _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)),
         }
     }
 }
@@ -334,10 +331,7 @@ impl<'a> Offset for SliceRead<'a> {
     }
 }
 
-#[cfg(all(
-    any(feature = "std", feature = "alloc"),
-    not(feature = "unsealed_read_write")
-))]
+#[cfg(all(any(feature = "std", feature = "alloc"), not(feature = "unsealed_read_write")))]
 impl<'a> private::Sealed for SliceRead<'a> {}
 
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -431,10 +425,7 @@ impl<'a, 'b> SliceReadFixed<'a, 'b> {
     fn end(&self, n: usize) -> Result<usize> {
         match self.index.checked_add(n) {
             Some(end) if end <= self.slice.len() => Ok(end),
-            _ => Err(Error::syntax(
-                ErrorCode::EofWhileParsingValue,
-                self.slice.len() as u64,
-            )),
+            _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)),
         }
     }
 
@@ -551,10 +542,7 @@ impl<'a> MutSliceRead<'a> {
     fn end(&self, n: usize) -> Result<usize> {
         match self.index.checked_add(n) {
             Some(end) if end <= self.slice.len() => Ok(end),
-            _ => Err(Error::syntax(
-                ErrorCode::EofWhileParsingValue,
-                self.slice.len() as u64,
-            )),
+            _ => Err(Error::syntax(ErrorCode::EofWhileParsingValue, self.slice.len() as u64)),
         }
     }
 }

src/ser.rs

@@ -193,9 +193,7 @@ where
                 false
             }
             None => {
-                self.writer
-                    .write_all(&[major << 5 | 31])
-                    .map_err(|e| e.into())?;
+                self.writer.write_all(&[major << 5 | 31]).map_err(|e| e.into())?;
                 true
             }
         };
@@ -224,7 +222,11 @@ where
 
     #[inline]
     fn serialize_bool(self, value: bool) -> Result<()> {
-        let value = if value { 0xf5 } else { 0xf4 };
+        let value = if value {
+            0xf5
+        } else {
+            0xf4
+        };
         self.writer.write_all(&[value]).map_err(|e| e.into())
     }
 
@@ -352,9 +354,7 @@ where
     #[inline]
     fn serialize_str(self, value: &str) -> Result<()> {
         self.write_u64(3, value.len() as u64)?;
-        self.writer
-            .write_all(value.as_bytes())
-            .map_err(|e| e.into())
+        self.writer.write_all(value.as_bytes()).map_err(|e| e.into())
     }
 
     #[inline]
@@ -494,7 +494,10 @@ where
     #[inline]
     fn serialize_struct(self, _name: &'static str, len: usize) -> Result<StructSerializer<'a, W>> {
         self.write_u64(5, len as u64)?;
-        Ok(StructSerializer { ser: self, idx: 0 })
+        Ok(StructSerializer {
+            ser: self,
+            idx: 0,
+        })
     }
 
     #[inline]

src/tags.rs

@@ -23,7 +23,10 @@ pub struct Tagged<T> {
 impl<T> Tagged<T> {
     /// Create a new tagged value
     pub fn new(tag: Option<u64>, value: T) -> Self {
-        Self { tag, value }
+        Self {
+            tag,
+            value,
+        }
     }
 }
 
@@ -42,8 +45,7 @@ fn untagged<T>(value: T) -> Tagged<T> {
 
 macro_rules! delegate {
     ($name: ident, $type: ty) => {
-        fn $name<E: serde::de::Error>(self, v: $type) -> Result<Self::Value, E>
-        {
+        fn $name<E: serde::de::Error>(self, v: $type) -> Result<Self::Value, E> {
             T::deserialize(v.into_deserializer()).map(untagged)
         }
     };

src/value/ser.rs

@@ -392,8 +392,7 @@ impl serde::ser::SerializeStructVariant for SerializeStructVariant {
     where
         T: Serialize,
     {
-        self.map
-            .insert(Value::from(String::from(key)), to_value(&value)?);
+        self.map.insert(Value::from(String::from(key)), to_value(&value)?);
         Ok(())
     }
 

src/write.rs

@@ -102,10 +102,7 @@ impl Write for Vec<u8> {
     }
 }
 
-#[cfg(all(
-    any(feature = "std", feature = "alloc"),
-    not(feature = "unsealed_read_write")
-))]
+#[cfg(all(any(feature = "std", feature = "alloc"), not(feature = "unsealed_read_write")))]
 impl private::Sealed for Vec<u8> {}
 
 #[cfg(not(feature = "std"))]
@@ -142,7 +139,10 @@ pub struct SliceWrite<'a> {
 impl<'a> SliceWrite<'a> {
     /// Wraps a mutable slice so it can be used as a `Write`.
     pub fn new(slice: &'a mut [u8]) -> SliceWrite<'a> {
-        SliceWrite { slice, index: 0 }
+        SliceWrite {
+            slice,
+            index: 0,
+        }
     }
 
     /// Returns the number of bytes written to the underlying slice.

tests/canonical.rs

@@ -34,10 +34,8 @@ mod std_tests {
 
     #[test]
     fn string_canonical_sort_order() {
-        let expected = ["", "a", "b", "aa"]
-            .iter()
-            .map(|s| Value::Text(s.to_string()))
-            .collect::<Vec<_>>();
+        let expected =
+            ["", "a", "b", "aa"].iter().map(|s| Value::Text(s.to_string())).collect::<Vec<_>>();
 
         let mut sorted = expected.clone();
         sorted.sort();