From 3bfd41d6249abdf2696d56fa5b3d1ba9cb2f5660 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 6 Jul 2023 15:42:15 -0700 Subject: [PATCH] Format doctests using rustfmt's format_code_in_doc_comments cargo fmt -- --config format_code_in_doc_comments=true --- serde/src/de/mod.rs | 15 ++- serde/src/de/value.rs | 4 +- serde/src/ser/mod.rs | 22 ++-- serde_test/src/assert.rs | 69 ++++++++----- serde_test/src/lib.rs | 38 +++---- serde_test/src/token.rs | 214 +++++++++++++++++++++++---------------- 6 files changed, 209 insertions(+), 153 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 966be0cfe..9ee6b768a 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -465,7 +465,10 @@ impl<'a> fmt::Display for Unexpected<'a> { /// # E: de::Error, /// # { /// # let v = true; -/// return Err(de::Error::invalid_type(Unexpected::Bool(v), &"a negative integer")); +/// return Err(de::Error::invalid_type( +/// Unexpected::Bool(v), +/// &"a negative integer", +/// )); /// # } /// ``` pub trait Expected { @@ -709,7 +712,7 @@ impl DeserializeOwned for T where T: for<'de> Deserialize<'de> {} /// { /// // Decrease the number of reallocations if there are many elements /// if let Some(size_hint) = seq.size_hint() { -/// self.0.reserve(size_hint); +/// self.0.reserve(size_hint); /// } /// /// // Visit each element in the inner array and push it onto @@ -2148,11 +2151,7 @@ pub trait VariantAccess<'de>: Sized { /// # T: DeserializeSeed<'de>, /// # { unimplemented!() } /// # - /// fn tuple_variant( - /// self, - /// _len: usize, - /// _visitor: V, - /// ) -> Result + /// fn tuple_variant(self, _len: usize, _visitor: V) -> Result /// where /// V: Visitor<'de>, /// { @@ -2239,9 +2238,9 @@ pub trait VariantAccess<'de>: Sized { /// # Example /// /// ```edition2021 -/// use std::str::FromStr; /// use serde::de::{value, Deserialize, IntoDeserializer}; /// use serde_derive::Deserialize; +/// use std::str::FromStr; /// /// #[derive(Deserialize)] /// enum Setting { diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index c3d326889..392f8a239 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -2,9 +2,9 @@ //! trait. //! //! ```edition2021 -//! use std::str::FromStr; -//! use serde_derive::Deserialize; //! use serde::de::{value, Deserialize, IntoDeserializer}; +//! use serde_derive::Deserialize; +//! use std::str::FromStr; //! //! #[derive(Deserialize)] //! enum Setting { diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 7538ba1f5..e1f38444d 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -969,7 +969,7 @@ pub trait Serializer: Sized { /// # } /// # } /// # - /// use serde::ser::{Serialize, Serializer, SerializeSeq}; + /// use serde::ser::{Serialize, SerializeSeq, Serializer}; /// /// impl Serialize for Vec /// where @@ -995,7 +995,7 @@ pub trait Serializer: Sized { /// then a call to `end`. /// /// ```edition2021 - /// use serde::ser::{Serialize, Serializer, SerializeTuple}; + /// use serde::ser::{Serialize, SerializeTuple, Serializer}; /// /// # mod fool { /// # trait Serialize {} @@ -1150,7 +1150,7 @@ pub trait Serializer: Sized { /// # } /// # } /// # - /// use serde::ser::{Serialize, Serializer, SerializeMap}; + /// use serde::ser::{Serialize, SerializeMap, Serializer}; /// /// impl Serialize for HashMap /// where @@ -1370,9 +1370,7 @@ pub trait Serializer: Sized { /// where /// S: Serializer, /// { - /// serializer.collect_str(&format_args!("{:?}{:?}", - /// self.naive_local(), - /// self.offset())) + /// serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset())) /// } /// } /// ``` @@ -1408,9 +1406,7 @@ pub trait Serializer: Sized { /// where /// S: Serializer, /// { - /// serializer.collect_str(&format_args!("{:?}{:?}", - /// self.naive_local(), - /// self.offset())) + /// serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset())) /// } /// } /// ``` @@ -1496,7 +1492,7 @@ pub trait Serializer: Sized { /// # } /// # } /// # -/// use serde::ser::{Serialize, Serializer, SerializeSeq}; +/// use serde::ser::{Serialize, SerializeSeq, Serializer}; /// /// impl Serialize for Vec /// where @@ -1542,7 +1538,7 @@ pub trait SerializeSeq { /// # Example use /// /// ```edition2021 -/// use serde::ser::{Serialize, Serializer, SerializeTuple}; +/// use serde::ser::{Serialize, SerializeTuple, Serializer}; /// /// # mod fool { /// # trait Serialize {} @@ -1590,7 +1586,7 @@ pub trait SerializeSeq { /// # } /// # } /// # -/// use serde::ser::{Serialize, Serializer, SerializeTuple}; +/// use serde::ser::{Serialize, SerializeTuple, Serializer}; /// /// # mod fool { /// # trait Serialize {} @@ -1764,7 +1760,7 @@ pub trait SerializeTupleVariant { /// # } /// # } /// # -/// use serde::ser::{Serialize, Serializer, SerializeMap}; +/// use serde::ser::{Serialize, SerializeMap, Serializer}; /// /// impl Serialize for HashMap /// where diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 606bfdcc2..047a9a30e 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -19,14 +19,17 @@ use std::fmt::Debug; /// } /// /// let s = S { a: 0, b: 0 }; -/// assert_tokens(&s, &[ -/// Token::Struct { name: "S", len: 2 }, -/// Token::Str("a"), -/// Token::U8(0), -/// Token::Str("b"), -/// Token::U8(0), -/// Token::StructEnd, -/// ]); +/// assert_tokens( +/// &s, +/// &[ +/// Token::Struct { name: "S", len: 2 }, +/// Token::Str("a"), +/// Token::U8(0), +/// Token::Str("b"), +/// Token::U8(0), +/// Token::StructEnd, +/// ], +/// ); /// ``` #[cfg_attr(not(no_track_caller), track_caller)] pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token]) @@ -50,14 +53,17 @@ where /// } /// /// let s = S { a: 0, b: 0 }; -/// assert_ser_tokens(&s, &[ -/// Token::Struct { name: "S", len: 2 }, -/// Token::Str("a"), -/// Token::U8(0), -/// Token::Str("b"), -/// Token::U8(0), -/// Token::StructEnd, -/// ]); +/// assert_ser_tokens( +/// &s, +/// &[ +/// Token::Struct { name: "S", len: 2 }, +/// Token::Str("a"), +/// Token::U8(0), +/// Token::Str("b"), +/// Token::U8(0), +/// Token::StructEnd, +/// ], +/// ); /// ``` #[cfg_attr(not(no_track_caller), track_caller)] pub fn assert_ser_tokens(value: &T, tokens: &[Token]) @@ -91,7 +97,9 @@ where /// } /// /// fn main() { -/// let example = Example { lock: Arc::new(Mutex::new(0)) }; +/// let example = Example { +/// lock: Arc::new(Mutex::new(0)), +/// }; /// let lock = example.lock.clone(); /// /// let _ = thread::spawn(move || { @@ -102,10 +110,14 @@ where /// // This panic while holding the lock (`_guard` is in scope) will /// // poison the mutex. /// panic!() -/// }).join(); +/// }) +/// .join(); /// /// let expected = &[ -/// Token::Struct { name: "Example", len: 1 }, +/// Token::Struct { +/// name: "Example", +/// len: 1, +/// }, /// Token::Str("lock"), /// ]; /// let error = "lock poison error while serializing"; @@ -141,14 +153,17 @@ where /// } /// /// let s = S { a: 0, b: 0 }; -/// assert_de_tokens(&s, &[ -/// Token::Struct { name: "S", len: 2 }, -/// Token::Str("a"), -/// Token::U8(0), -/// Token::Str("b"), -/// Token::U8(0), -/// Token::StructEnd, -/// ]); +/// assert_de_tokens( +/// &s, +/// &[ +/// Token::Struct { name: "S", len: 2 }, +/// Token::Str("a"), +/// Token::U8(0), +/// Token::Str("b"), +/// Token::U8(0), +/// Token::StructEnd, +/// ], +/// ); /// ``` #[cfg_attr(not(no_track_caller), track_caller)] pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token]) diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index 8474420e6..313cb4f0f 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -24,7 +24,7 @@ //! # const IGNORE: &str = stringify! { //! use linked_hash_map::LinkedHashMap; //! # }; -//! use serde_test::{Token, assert_tokens}; +//! use serde_test::{assert_tokens, Token}; //! //! # use std::fmt; //! # use std::marker::PhantomData; @@ -106,10 +106,13 @@ //! fn test_ser_de_empty() { //! let map = LinkedHashMap::::new(); //! -//! assert_tokens(&map, &[ -//! Token::Map { len: Some(0) }, -//! Token::MapEnd, -//! ]); +//! assert_tokens( +//! &map, +//! &[ +//! Token::Map { len: Some(0) }, +//! Token::MapEnd, +//! ], +//! ); //! } //! //! #[test] @@ -120,18 +123,19 @@ //! map.insert('a', 10); //! map.insert('c', 30); //! -//! assert_tokens(&map, &[ -//! Token::Map { len: Some(3) }, -//! Token::Char('b'), -//! Token::I32(20), -//! -//! Token::Char('a'), -//! Token::I32(10), -//! -//! Token::Char('c'), -//! Token::I32(30), -//! Token::MapEnd, -//! ]); +//! assert_tokens( +//! &map, +//! &[ +//! Token::Map { len: Some(3) }, +//! Token::Char('b'), +//! Token::I32(20), +//! Token::Char('a'), +//! Token::I32(10), +//! Token::Char('c'), +//! Token::I32(30), +//! Token::MapEnd, +//! ], +//! ); //! } //! # //! # fn main() { diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs index d467d549c..b486d73d9 100644 --- a/serde_test/src/token.rs +++ b/serde_test/src/token.rs @@ -167,10 +167,7 @@ pub enum Token { /// # use serde_test::{assert_tokens, Token}; /// # /// let opt = Some('c'); - /// assert_tokens(&opt, &[ - /// Token::Some, - /// Token::Char('c'), - /// ]); + /// assert_tokens(&opt, &[Token::Some, Token::Char('c')]); /// ``` Some, @@ -211,7 +208,13 @@ pub enum Token { /// } /// /// let a = E::A; - /// assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]); + /// assert_tokens( + /// &a, + /// &[Token::UnitVariant { + /// name: "E", + /// variant: "A", + /// }], + /// ); /// # } /// ``` UnitVariant { @@ -232,10 +235,10 @@ pub enum Token { /// struct N(String); /// /// let n = N("newtype".to_owned()); - /// assert_tokens(&n, &[ - /// Token::NewtypeStruct { name: "N" }, - /// Token::String("newtype"), - /// ]); + /// assert_tokens( + /// &n, + /// &[Token::NewtypeStruct { name: "N" }, Token::String("newtype")], + /// ); /// # } /// ``` NewtypeStruct { name: &'static str }, @@ -255,10 +258,16 @@ pub enum Token { /// } /// /// let b = E::B(0); - /// assert_tokens(&b, &[ - /// Token::NewtypeVariant { name: "E", variant: "B" }, - /// Token::U8(0), - /// ]); + /// assert_tokens( + /// &b, + /// &[ + /// Token::NewtypeVariant { + /// name: "E", + /// variant: "B", + /// }, + /// Token::U8(0), + /// ], + /// ); /// # } /// ``` NewtypeVariant { @@ -275,13 +284,16 @@ pub enum Token { /// # use serde_test::{assert_tokens, Token}; /// # /// let vec = vec!['a', 'b', 'c']; - /// assert_tokens(&vec, &[ - /// Token::Seq { len: Some(3) }, - /// Token::Char('a'), - /// Token::Char('b'), - /// Token::Char('c'), - /// Token::SeqEnd, - /// ]); + /// assert_tokens( + /// &vec, + /// &[ + /// Token::Seq { len: Some(3) }, + /// Token::Char('a'), + /// Token::Char('b'), + /// Token::Char('c'), + /// Token::SeqEnd, + /// ], + /// ); /// ``` Seq { len: Option }, @@ -296,12 +308,15 @@ pub enum Token { /// # use serde_test::{assert_tokens, Token}; /// # /// let tuple = ('a', 100); - /// assert_tokens(&tuple, &[ - /// Token::Tuple { len: 2 }, - /// Token::Char('a'), - /// Token::I32(100), - /// Token::TupleEnd, - /// ]); + /// assert_tokens( + /// &tuple, + /// &[ + /// Token::Tuple { len: 2 }, + /// Token::Char('a'), + /// Token::I32(100), + /// Token::TupleEnd, + /// ], + /// ); /// ``` Tuple { len: usize }, @@ -322,12 +337,15 @@ pub enum Token { /// struct T(u8, u8); /// /// let t = T(0, 0); - /// assert_tokens(&t, &[ - /// Token::TupleStruct { name: "T", len: 2 }, - /// Token::U8(0), - /// Token::U8(0), - /// Token::TupleStructEnd, - /// ]); + /// assert_tokens( + /// &t, + /// &[ + /// Token::TupleStruct { name: "T", len: 2 }, + /// Token::U8(0), + /// Token::U8(0), + /// Token::TupleStructEnd, + /// ], + /// ); /// # } /// ``` TupleStruct { name: &'static str, len: usize }, @@ -351,12 +369,19 @@ pub enum Token { /// } /// /// let c = E::C(0, 0); - /// assert_tokens(&c, &[ - /// Token::TupleVariant { name: "E", variant: "C", len: 2 }, - /// Token::U8(0), - /// Token::U8(0), - /// Token::TupleVariantEnd, - /// ]); + /// assert_tokens( + /// &c, + /// &[ + /// Token::TupleVariant { + /// name: "E", + /// variant: "C", + /// len: 2, + /// }, + /// Token::U8(0), + /// Token::U8(0), + /// Token::TupleVariantEnd, + /// ], + /// ); /// # } /// ``` TupleVariant { @@ -381,14 +406,17 @@ pub enum Token { /// map.insert('A', 65); /// map.insert('Z', 90); /// - /// assert_tokens(&map, &[ - /// Token::Map { len: Some(2) }, - /// Token::Char('A'), - /// Token::I32(65), - /// Token::Char('Z'), - /// Token::I32(90), - /// Token::MapEnd, - /// ]); + /// assert_tokens( + /// &map, + /// &[ + /// Token::Map { len: Some(2) }, + /// Token::Char('A'), + /// Token::I32(65), + /// Token::Char('Z'), + /// Token::I32(90), + /// Token::MapEnd, + /// ], + /// ); /// ``` Map { len: Option }, @@ -411,14 +439,17 @@ pub enum Token { /// } /// /// let s = S { a: 0, b: 0 }; - /// assert_tokens(&s, &[ - /// Token::Struct { name: "S", len: 2 }, - /// Token::Str("a"), - /// Token::U8(0), - /// Token::Str("b"), - /// Token::U8(0), - /// Token::StructEnd, - /// ]); + /// assert_tokens( + /// &s, + /// &[ + /// Token::Struct { name: "S", len: 2 }, + /// Token::Str("a"), + /// Token::U8(0), + /// Token::Str("b"), + /// Token::U8(0), + /// Token::StructEnd, + /// ], + /// ); /// # } /// ``` Struct { name: &'static str, len: usize }, @@ -442,12 +473,19 @@ pub enum Token { /// } /// /// let d = E::D { d: 0 }; - /// assert_tokens(&d, &[ - /// Token::StructVariant { name: "E", variant: "D", len: 1 }, - /// Token::Str("d"), - /// Token::U8(0), - /// Token::StructVariantEnd, - /// ]); + /// assert_tokens( + /// &d, + /// &[ + /// Token::StructVariant { + /// name: "E", + /// variant: "D", + /// len: 1, + /// }, + /// Token::Str("d"), + /// Token::U8(0), + /// Token::StructVariantEnd, + /// ], + /// ); /// # } /// ``` StructVariant { @@ -475,38 +513,42 @@ pub enum Token { /// } /// /// let a = E::A; - /// assert_tokens(&a, &[ - /// Token::Enum { name: "E" }, - /// Token::Str("A"), - /// Token::Unit, - /// ]); + /// assert_tokens( + /// &a, + /// &[Token::Enum { name: "E" }, Token::Str("A"), Token::Unit], + /// ); /// /// let b = E::B(0); - /// assert_tokens(&b, &[ - /// Token::Enum { name: "E" }, - /// Token::Str("B"), - /// Token::U8(0), - /// ]); + /// assert_tokens( + /// &b, + /// &[Token::Enum { name: "E" }, Token::Str("B"), Token::U8(0)], + /// ); /// /// let c = E::C(0, 0); - /// assert_tokens(&c, &[ - /// Token::Enum { name: "E" }, - /// Token::Str("C"), - /// Token::Seq { len: Some(2) }, - /// Token::U8(0), - /// Token::U8(0), - /// Token::SeqEnd, - /// ]); + /// assert_tokens( + /// &c, + /// &[ + /// Token::Enum { name: "E" }, + /// Token::Str("C"), + /// Token::Seq { len: Some(2) }, + /// Token::U8(0), + /// Token::U8(0), + /// Token::SeqEnd, + /// ], + /// ); /// /// let d = E::D { d: 0 }; - /// assert_tokens(&d, &[ - /// Token::Enum { name: "E" }, - /// Token::Str("D"), - /// Token::Map { len: Some(1) }, - /// Token::Str("d"), - /// Token::U8(0), - /// Token::MapEnd, - /// ]); + /// assert_tokens( + /// &d, + /// &[ + /// Token::Enum { name: "E" }, + /// Token::Str("D"), + /// Token::Map { len: Some(1) }, + /// Token::Str("d"), + /// Token::U8(0), + /// Token::MapEnd, + /// ], + /// ); /// # } /// ``` Enum { name: &'static str },