From 0666fbfa20f04f433f52bd1520a2be25fd07171d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 6 Jul 2023 15:17:05 -0700 Subject: [PATCH 1/2] Update documentation example code to 2021 edition --- serde/src/de/ignored_any.rs | 2 +- serde/src/de/mod.rs | 32 ++++++------- serde/src/de/value.rs | 2 +- serde/src/integer128.rs | 6 +-- serde/src/macros.rs | 6 +-- serde/src/ser/fmt.rs | 2 +- serde/src/ser/impossible.rs | 2 +- serde/src/ser/mod.rs | 92 ++++++++++++++++++------------------- serde/src/std_error.rs | 6 +-- serde_derive/src/lib.rs | 2 +- serde_test/src/assert.rs | 10 ++-- serde_test/src/configure.rs | 2 +- serde_test/src/lib.rs | 2 +- serde_test/src/token.rs | 60 ++++++++++++------------ 14 files changed, 113 insertions(+), 113 deletions(-) diff --git a/serde/src/de/ignored_any.rs b/serde/src/de/ignored_any.rs index 9ed438e79..88d4e967c 100644 --- a/serde/src/de/ignored_any.rs +++ b/serde/src/de/ignored_any.rs @@ -10,7 +10,7 @@ use de::{ /// any type, except that it does not store any information about the data that /// gets deserialized. /// -/// ```edition2018 +/// ```edition2021 /// use std::fmt; /// use std::marker::PhantomData; /// diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index ca29ec610..6a8162f9c 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -162,7 +162,7 @@ macro_rules! declare_error_trait { /// /// The message should not be capitalized and should not end with a period. /// - /// ```edition2018 + /// ```edition2021 /// # use std::str::FromStr; /// # /// # struct IpAddr; @@ -307,7 +307,7 @@ declare_error_trait!(Error: Sized + Debug + Display); /// This is used as an argument to the `invalid_type`, `invalid_value`, and /// `invalid_length` methods of the `Error` trait to build error messages. /// -/// ```edition2018 +/// ```edition2021 /// # use std::fmt; /// # /// # use serde::de::{self, Unexpected, Visitor}; @@ -432,7 +432,7 @@ impl<'a> fmt::Display for Unexpected<'a> { /// Within the context of a `Visitor` implementation, the `Visitor` itself /// (`&self`) is an implementation of this trait. /// -/// ```edition2018 +/// ```edition2021 /// # use std::fmt; /// # /// # use serde::de::{self, Unexpected, Visitor}; @@ -457,7 +457,7 @@ impl<'a> fmt::Display for Unexpected<'a> { /// /// Outside of a `Visitor`, `&"..."` can be used. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::de::{self, Unexpected}; /// # /// # fn example() -> Result<(), E> @@ -577,7 +577,7 @@ pub trait Deserialize<'de>: Sized { /// from the input string, but a `from_reader` function may only deserialize /// owned data. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::de::{Deserialize, DeserializeOwned}; /// # use std::io::{Read, Result}; /// # @@ -616,7 +616,7 @@ impl DeserializeOwned for T where T: for<'de> Deserialize<'de> {} /// /// The canonical API for stateless deserialization looks like this: /// -/// ```edition2018 +/// ```edition2021 /// # use serde::Deserialize; /// # /// # enum Error {} @@ -630,7 +630,7 @@ impl DeserializeOwned for T where T: for<'de> Deserialize<'de> {} /// Adjusting an API like this to support stateful deserialization is a matter /// of accepting a seed as input: /// -/// ```edition2018 +/// ```edition2021 /// # use serde::de::DeserializeSeed; /// # /// # enum Error {} @@ -663,7 +663,7 @@ impl DeserializeOwned for T where T: for<'de> Deserialize<'de> {} /// into it. This requires stateful deserialization using the `DeserializeSeed` /// trait. /// -/// ```edition2018 +/// ```edition2021 /// use std::fmt; /// use std::marker::PhantomData; /// @@ -1158,7 +1158,7 @@ pub trait Deserializer<'de>: Sized { /// human-readable one and binary formats like Postcard will prefer the /// compact one. /// - /// ```edition2018 + /// ```edition2021 /// # use std::ops::Add; /// # use std::str::FromStr; /// # @@ -1249,7 +1249,7 @@ pub trait Deserializer<'de>: Sized { /// /// # Example /// -/// ```edition2018 +/// ```edition2021 /// # use std::fmt; /// # /// # use serde::de::{self, Unexpected, Visitor}; @@ -1290,7 +1290,7 @@ pub trait Visitor<'de>: Sized { /// "an integer between 0 and 64". The message should not be capitalized and /// should not end with a period. /// - /// ```edition2018 + /// ```edition2021 /// # use std::fmt; /// # /// # struct S { @@ -2035,7 +2035,7 @@ pub trait VariantAccess<'de>: Sized { /// If the data contains a different type of variant, the following /// `invalid_type` error should be constructed: /// - /// ```edition2018 + /// ```edition2021 /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected}; /// # /// # struct X; @@ -2075,7 +2075,7 @@ pub trait VariantAccess<'de>: Sized { /// If the data contains a different type of variant, the following /// `invalid_type` error should be constructed: /// - /// ```edition2018 + /// ```edition2021 /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected}; /// # /// # struct X; @@ -2131,7 +2131,7 @@ pub trait VariantAccess<'de>: Sized { /// If the data contains a different type of variant, the following /// `invalid_type` error should be constructed: /// - /// ```edition2018 + /// ```edition2021 /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected}; /// # /// # struct X; @@ -2178,7 +2178,7 @@ pub trait VariantAccess<'de>: Sized { /// If the data contains a different type of variant, the following /// `invalid_type` error should be constructed: /// - /// ```edition2018 + /// ```edition2021 /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected}; /// # /// # struct X; @@ -2238,7 +2238,7 @@ pub trait VariantAccess<'de>: Sized { /// /// # Example /// -/// ```edition2018 +/// ```edition2021 /// use std::str::FromStr; /// use serde::Deserialize; /// use serde::de::{value, IntoDeserializer}; diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 358ea48a0..4303c2bbf 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -1,7 +1,7 @@ //! Building blocks for deserializing basic values using the `IntoDeserializer` //! trait. //! -//! ```edition2018 +//! ```edition2021 //! use std::str::FromStr; //! use serde::Deserialize; //! use serde::de::{value, IntoDeserializer}; diff --git a/serde/src/integer128.rs b/serde/src/integer128.rs index 904c2a233..a51291be6 100644 --- a/serde/src/integer128.rs +++ b/serde/src/integer128.rs @@ -9,7 +9,7 @@ /// or do not target platforms that lack 128-bit integers, do not need to /// bother with this macro and may assume support for 128-bit integers. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::__private::doc::Error; /// # /// # struct MySerializer; @@ -50,7 +50,7 @@ /// When Serde is built with support for 128-bit integers, this macro expands /// transparently into just the input tokens. /// -/// ```edition2018 +/// ```edition2021 /// macro_rules! serde_if_integer128 { /// ($($tt:tt)*) => { /// $($tt)* @@ -61,7 +61,7 @@ /// When built without support for 128-bit integers, this macro expands to /// nothing. /// -/// ```edition2018 +/// ```edition2021 /// macro_rules! serde_if_integer128 { /// ($($tt:tt)*) => {}; /// } diff --git a/serde/src/macros.rs b/serde/src/macros.rs index 6502a23a7..53827c820 100644 --- a/serde/src/macros.rs +++ b/serde/src/macros.rs @@ -11,7 +11,7 @@ /// input. This requires repetitive implementations of all the [`Deserializer`] /// trait methods. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::forward_to_deserialize_any; /// # use serde::de::{value, Deserializer, Visitor}; /// # @@ -47,7 +47,7 @@ /// methods so that they forward directly to [`Deserializer::deserialize_any`]. /// You can choose which methods to forward. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::forward_to_deserialize_any; /// # use serde::de::{value, Deserializer, Visitor}; /// # @@ -78,7 +78,7 @@ /// called `V`. A different type parameter and a different lifetime can be /// specified explicitly if necessary. /// -/// ```edition2018 +/// ```edition2021 /// # use std::marker::PhantomData; /// # /// # use serde::forward_to_deserialize_any; diff --git a/serde/src/ser/fmt.rs b/serde/src/ser/fmt.rs index e7e09a1bf..8e8d17d8d 100644 --- a/serde/src/ser/fmt.rs +++ b/serde/src/ser/fmt.rs @@ -17,7 +17,7 @@ macro_rules! fmt_primitives { }; } -/// ```edition2018 +/// ```edition2021 /// use serde::Serialize; /// use std::fmt::{self, Display}; /// diff --git a/serde/src/ser/impossible.rs b/serde/src/ser/impossible.rs index e8df9ca7a..1d1d7ac84 100644 --- a/serde/src/ser/impossible.rs +++ b/serde/src/ser/impossible.rs @@ -15,7 +15,7 @@ use ser::{ /// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`], /// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`]. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::ser::{Serializer, Impossible}; /// # use serde::__private::doc::Error; /// # diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 5c45426e8..7d0fb8f36 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -149,7 +149,7 @@ macro_rules! declare_error_trait { /// For example, a filesystem [`Path`] may refuse to serialize /// itself if it contains invalid UTF-8 data. /// - /// ```edition2018 + /// ```edition2021 /// # struct Path; /// # /// # impl Path { @@ -221,7 +221,7 @@ pub trait Serialize { /// See the [Implementing `Serialize`] section of the manual for more /// information about how to implement this method. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeStruct, Serializer}; /// /// struct Person { @@ -388,7 +388,7 @@ pub trait Serializer: Sized { /// Serialize a `bool` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -410,7 +410,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -432,7 +432,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -454,7 +454,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -472,7 +472,7 @@ pub trait Serializer: Sized { /// Serialize an `i64` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -491,7 +491,7 @@ pub trait Serializer: Sized { serde_if_integer128! { /// Serialize an `i128` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -520,7 +520,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -542,7 +542,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -564,7 +564,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -582,7 +582,7 @@ pub trait Serializer: Sized { /// Serialize a `u64` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -601,7 +601,7 @@ pub trait Serializer: Sized { serde_if_integer128! { /// Serialize a `u128` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -630,7 +630,7 @@ pub trait Serializer: Sized { /// reasonable implementation would be to cast the value to `f64` and /// forward to `serialize_f64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -648,7 +648,7 @@ pub trait Serializer: Sized { /// Serialize an `f64` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -669,7 +669,7 @@ pub trait Serializer: Sized { /// If the format does not support characters, it is reasonable to serialize /// it as a single element `str` or a `u32`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -687,7 +687,7 @@ pub trait Serializer: Sized { /// Serialize a `&str`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -711,7 +711,7 @@ pub trait Serializer: Sized { /// `serialize_seq`. If forwarded, the implementation looks usually just /// like this: /// - /// ```edition2018 + /// ```edition2021 /// # use serde::ser::{Serializer, SerializeSeq}; /// # use serde::__private::doc::Error; /// # @@ -740,7 +740,7 @@ pub trait Serializer: Sized { /// Serialize a [`None`] value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Serializer}; /// # /// # enum Option { @@ -773,7 +773,7 @@ pub trait Serializer: Sized { /// Serialize a [`Some(T)`] value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Serializer}; /// # /// # enum Option { @@ -808,7 +808,7 @@ pub trait Serializer: Sized { /// Serialize a `()` value. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::Serializer; /// # /// # serde::__private_serialize!(); @@ -828,7 +828,7 @@ pub trait Serializer: Sized { /// /// A reasonable implementation would be to forward to `serialize_unit`. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// /// struct Nothing; @@ -850,7 +850,7 @@ pub trait Serializer: Sized { /// this variant within the enum, and the `variant` is the name of the /// variant. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// /// enum E { @@ -883,7 +883,7 @@ pub trait Serializer: Sized { /// wrappers around the data they contain. A reasonable implementation would /// be to forward to `value.serialize(self)`. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// /// struct Millimeters(u8); @@ -911,7 +911,7 @@ pub trait Serializer: Sized { /// this variant within the enum, and the `variant` is the name of the /// variant. The `value` is the data contained within this newtype variant. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// /// enum E { @@ -949,7 +949,7 @@ pub trait Serializer: Sized { /// not be computable before the sequence is iterated. Some serializers only /// support sequences whose length is known up front. /// - /// ```edition2018 + /// ```edition2021 /// # use std::marker::PhantomData; /// # /// # struct Vec(PhantomData); @@ -994,7 +994,7 @@ pub trait Serializer: Sized { /// This call must be followed by zero or more calls to `serialize_element`, /// then a call to `end`. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, Serializer, SerializeTuple}; /// /// # mod fool { @@ -1024,7 +1024,7 @@ pub trait Serializer: Sized { /// } /// ``` /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeTuple, Serializer}; /// /// const VRAM_SIZE: usize = 386; @@ -1052,7 +1052,7 @@ pub trait Serializer: Sized { /// The `name` is the name of the tuple struct and the `len` is the number /// of data fields that will be serialized. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer}; /// /// struct Rgb(u8, u8, u8); @@ -1084,7 +1084,7 @@ pub trait Serializer: Sized { /// this variant within the enum, the `variant` is the name of the variant, /// and the `len` is the number of data fields that will be serialized. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer}; /// /// enum E { @@ -1130,7 +1130,7 @@ pub trait Serializer: Sized { /// be computable before the map is iterated. Some serializers only support /// maps whose length is known up front. /// - /// ```edition2018 + /// ```edition2021 /// # use std::marker::PhantomData; /// # /// # struct HashMap(PhantomData, PhantomData); @@ -1178,7 +1178,7 @@ pub trait Serializer: Sized { /// The `name` is the name of the struct and the `len` is the number of /// data fields that will be serialized. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeStruct, Serializer}; /// /// struct Rgb { @@ -1214,7 +1214,7 @@ pub trait Serializer: Sized { /// this variant within the enum, the `variant` is the name of the variant, /// and the `len` is the number of data fields that will be serialized. /// - /// ```edition2018 + /// ```edition2021 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer}; /// /// enum E { @@ -1256,7 +1256,7 @@ pub trait Serializer: Sized { /// using [`serialize_seq`]. Implementors should not need to override this /// method. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// /// struct SecretlyOneHigher { @@ -1304,7 +1304,7 @@ pub trait Serializer: Sized { /// using [`serialize_map`]. Implementors should not need to override this /// method. /// - /// ```edition2018 + /// ```edition2021 /// use serde::{Serialize, Serializer}; /// use std::collections::BTreeSet; /// @@ -1355,7 +1355,7 @@ pub trait Serializer: Sized { /// delegates to [`serialize_str`]. Serializers are encouraged to provide a /// more efficient implementation if possible. /// - /// ```edition2018 + /// ```edition2021 /// # struct DateTime; /// # /// # impl DateTime { @@ -1393,7 +1393,7 @@ pub trait Serializer: Sized { /// of this method. If no more sensible behavior is possible, the /// implementation is expected to return an error. /// - /// ```edition2018 + /// ```edition2021 /// # struct DateTime; /// # /// # impl DateTime { @@ -1428,7 +1428,7 @@ pub trait Serializer: Sized { /// human-readable one and binary formats like Postcard will prefer the /// compact one. /// - /// ```edition2018 + /// ```edition2021 /// # use std::fmt::{self, Display}; /// # /// # struct Timestamp; @@ -1477,7 +1477,7 @@ pub trait Serializer: Sized { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// # use std::marker::PhantomData; /// # /// # struct Vec(PhantomData); @@ -1541,7 +1541,7 @@ pub trait SerializeSeq { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// use serde::ser::{Serialize, Serializer, SerializeTuple}; /// /// # mod fool { @@ -1571,7 +1571,7 @@ pub trait SerializeSeq { /// } /// ``` /// -/// ```edition2018 +/// ```edition2021 /// # use std::marker::PhantomData; /// # /// # struct Array(PhantomData); @@ -1641,7 +1641,7 @@ pub trait SerializeTuple { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer}; /// /// struct Rgb(u8, u8, u8); @@ -1686,7 +1686,7 @@ pub trait SerializeTupleStruct { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer}; /// /// enum E { @@ -1744,7 +1744,7 @@ pub trait SerializeTupleVariant { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// # use std::marker::PhantomData; /// # /// # struct HashMap(PhantomData, PhantomData); @@ -1855,7 +1855,7 @@ pub trait SerializeMap { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// use serde::ser::{Serialize, SerializeStruct, Serializer}; /// /// struct Rgb { @@ -1915,7 +1915,7 @@ pub trait SerializeStruct { /// /// # Example use /// -/// ```edition2018 +/// ```edition2021 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer}; /// /// enum E { diff --git a/serde/src/std_error.rs b/serde/src/std_error.rs index 1055e0ffb..fca023d16 100644 --- a/serde/src/std_error.rs +++ b/serde/src/std_error.rs @@ -9,7 +9,7 @@ use lib::{Debug, Display}; /// generally provide their error types with a `std::error::Error` impl /// directly: /// -/// ```edition2018 +/// ```edition2021 /// #[derive(Debug)] /// struct MySerError {...} /// @@ -29,7 +29,7 @@ use lib::{Debug, Display}; /// std = ["serde/std"] /// ``` /// -/// ```edition2018 +/// ```edition2021 /// #[cfg(feature = "std")] /// impl std::error::Error for MySerError {} /// ``` @@ -37,7 +37,7 @@ use lib::{Debug, Display}; /// ... or else provide the std Error impl unconditionally via Serde's /// re-export: /// -/// ```edition2018 +/// ```edition2021 /// impl serde::ser::StdError for MySerError {} /// ``` pub trait Error: Debug + Display { diff --git a/serde_derive/src/lib.rs b/serde_derive/src/lib.rs index 2dc1b2747..c32f5bb6a 100644 --- a/serde_derive/src/lib.rs +++ b/serde_derive/src/lib.rs @@ -1,6 +1,6 @@ //! This crate provides Serde's two derive macros. //! -//! ```edition2018 +//! ```edition2021 //! # use serde_derive::{Serialize, Deserialize}; //! # //! #[derive(Serialize, Deserialize)] diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 9be153d74..b805d1c8e 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -8,7 +8,7 @@ use std::fmt::Debug; /// Runs both `assert_ser_tokens` and `assert_de_tokens`. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -39,7 +39,7 @@ where /// Asserts that `value` serializes to the given `tokens`. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_ser_tokens, Token}; /// # @@ -78,7 +78,7 @@ where /// Asserts that `value` serializes to the given `tokens`, and then yields /// `error`. /// -/// ```edition2018 +/// ```edition2021 /// use std::sync::{Arc, Mutex}; /// use std::thread; /// @@ -130,7 +130,7 @@ where /// Asserts that the given `tokens` deserialize into `value`. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_de_tokens, Token}; /// # @@ -184,7 +184,7 @@ where /// Asserts that the given `tokens` yield `error` when deserializing. /// -/// ```edition2018 +/// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_de_tokens_error, Token}; /// # diff --git a/serde_test/src/configure.rs b/serde_test/src/configure.rs index d34ad9065..04b95dcfe 100644 --- a/serde_test/src/configure.rs +++ b/serde_test/src/configure.rs @@ -14,7 +14,7 @@ pub struct Compact(T); /// Trait to determine whether a value is represented in human-readable or /// compact form. /// -/// ```edition2018 +/// ```edition2021 /// use serde::{Deserialize, Deserializer, Serialize, Serializer}; /// use serde_test::{assert_tokens, Configure, Token}; /// diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index c606b6180..8474420e6 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -20,7 +20,7 @@ //! //! [`linked-hash-map`]: https://github.com/contain-rs/linked-hash-map //! -//! ```edition2018 +//! ```edition2021 //! # const IGNORE: &str = stringify! { //! use linked_hash_map::LinkedHashMap; //! # }; diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs index 225136144..37702726b 100644 --- a/serde_test/src/token.rs +++ b/serde_test/src/token.rs @@ -4,7 +4,7 @@ use std::fmt::{self, Debug, Display}; pub enum Token { /// A serialized `bool`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&true, &[Token::Bool(true)]); @@ -13,7 +13,7 @@ pub enum Token { /// A serialized `i8`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0i8, &[Token::I8(0)]); @@ -22,7 +22,7 @@ pub enum Token { /// A serialized `i16`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0i16, &[Token::I16(0)]); @@ -31,7 +31,7 @@ pub enum Token { /// A serialized `i32`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0i32, &[Token::I32(0)]); @@ -40,7 +40,7 @@ pub enum Token { /// A serialized `i64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0i64, &[Token::I64(0)]); @@ -49,7 +49,7 @@ pub enum Token { /// A serialized `u8`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0u8, &[Token::U8(0)]); @@ -58,7 +58,7 @@ pub enum Token { /// A serialized `u16`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0u16, &[Token::U16(0)]); @@ -67,7 +67,7 @@ pub enum Token { /// A serialized `u32`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0u32, &[Token::U32(0)]); @@ -76,7 +76,7 @@ pub enum Token { /// A serialized `u64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0u64, &[Token::U64(0)]); @@ -85,7 +85,7 @@ pub enum Token { /// A serialized `f32`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0f32, &[Token::F32(0.0)]); @@ -94,7 +94,7 @@ pub enum Token { /// A serialized `f64`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&0f64, &[Token::F64(0.0)]); @@ -103,7 +103,7 @@ pub enum Token { /// A serialized `char`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&'\n', &[Token::Char('\n')]); @@ -112,7 +112,7 @@ pub enum Token { /// A serialized `str`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let s = String::from("transient"); @@ -122,7 +122,7 @@ pub enum Token { /// A borrowed `str`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let s: &str = "borrowed"; @@ -132,7 +132,7 @@ pub enum Token { /// A serialized `String`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let s = String::from("owned"); @@ -151,7 +151,7 @@ pub enum Token { /// A serialized `Option` containing none. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let opt = None::; @@ -163,7 +163,7 @@ pub enum Token { /// /// The tokens of the value follow after this header. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let opt = Some('c'); @@ -176,7 +176,7 @@ pub enum Token { /// A serialized `()`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// assert_tokens(&(), &[Token::Unit]); @@ -185,7 +185,7 @@ pub enum Token { /// A serialized unit struct of the given name. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -200,7 +200,7 @@ pub enum Token { /// A unit variant of an enum. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -223,7 +223,7 @@ pub enum Token { /// /// After this header is the value contained in the newtype struct. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -244,7 +244,7 @@ pub enum Token { /// /// After this header is the value contained in the newtype variant. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -271,7 +271,7 @@ pub enum Token { /// After this header are the elements of the sequence, followed by /// `SeqEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let vec = vec!['a', 'b', 'c']; @@ -292,7 +292,7 @@ pub enum Token { /// /// After this header are the elements of the tuple, followed by `TupleEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// let tuple = ('a', 100); @@ -313,7 +313,7 @@ pub enum Token { /// After this header are the fields of the tuple struct, followed by /// `TupleStructEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -340,7 +340,7 @@ pub enum Token { /// After this header are the fields of the tuple variant, followed by /// `TupleVariantEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -372,7 +372,7 @@ pub enum Token { /// /// After this header are the entries of the map, followed by `MapEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde_test::{assert_tokens, Token}; /// # /// use std::collections::BTreeMap; @@ -399,7 +399,7 @@ pub enum Token { /// /// After this header are the fields of the struct, followed by `StructEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -431,7 +431,7 @@ pub enum Token { /// After this header are the fields of the struct variant, followed by /// `StructVariantEnd`. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # @@ -461,7 +461,7 @@ pub enum Token { /// The header to an enum of the given name. /// - /// ```edition2018 + /// ```edition2021 /// # use serde::{Serialize, Deserialize}; /// # use serde_test::{assert_tokens, Token}; /// # From 541603ac9453e364fcc267a2474b4a81d3cbc621 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 6 Jul 2023 15:36:17 -0700 Subject: [PATCH 2/2] Fix doc tests for 2021 edition --- serde/src/ser/mod.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index 7d0fb8f36..7538ba1f5 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -962,7 +962,7 @@ pub trait Serializer: Sized { /// # /// # impl<'a, T> IntoIterator for &'a Vec { /// # type Item = &'a T; - /// # type IntoIter = Box>; + /// # type IntoIter = Box>; /// # /// # fn into_iter(self) -> Self::IntoIter { /// # unimplemented!() @@ -1143,7 +1143,7 @@ pub trait Serializer: Sized { /// # /// # impl<'a, K, V> IntoIterator for &'a HashMap { /// # type Item = (&'a K, &'a V); - /// # type IntoIter = Box>; + /// # type IntoIter = Box>; /// # /// # fn into_iter(self) -> Self::IntoIter { /// # unimplemented!() @@ -1490,7 +1490,7 @@ pub trait Serializer: Sized { /// # /// # impl<'a, T> IntoIterator for &'a Vec { /// # type Item = &'a T; -/// # type IntoIter = Box>; +/// # type IntoIter = Box>; /// # fn into_iter(self) -> Self::IntoIter { /// # unimplemented!() /// # } @@ -1584,7 +1584,7 @@ pub trait SerializeSeq { /// # /// # impl<'a, T> IntoIterator for &'a Array { /// # type Item = &'a T; -/// # type IntoIter = Box>; +/// # type IntoIter = Box>; /// # fn into_iter(self) -> Self::IntoIter { /// # unimplemented!() /// # } @@ -1757,7 +1757,7 @@ pub trait SerializeTupleVariant { /// # /// # impl<'a, K, V> IntoIterator for &'a HashMap { /// # type Item = (&'a K, &'a V); -/// # type IntoIter = Box>; +/// # type IntoIter = Box>; /// # /// # fn into_iter(self) -> Self::IntoIter { /// # unimplemented!()