Release 1.0.199

fix: ambiguous associated item in forward_to_deserialize_any!

.github/workflows/ci.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable
 
@@ -27,7 +27,7 @@ jobs:
     runs-on: windows-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
 
@@ -40,7 +40,7 @@ jobs:
         rust: [stable, beta]
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -56,7 +56,7 @@ jobs:
         os: [ubuntu, windows]
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd serde && cargo build
       - run: cd serde && cargo build --no-default-features
@@ -80,7 +80,7 @@ jobs:
         rust: [1.31.0, 1.34.0]
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -93,69 +93,52 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@1.56.0
       - run: cd serde && cargo check --no-default-features
       - run: cd serde && cargo check
       - run: cd serde_derive && cargo check
-      - run: cd precompiled/serde_derive && cargo check
 
   alloc:
     name: Rust 1.36.0
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@1.36.0
       - run: cd serde && cargo build --no-default-features --features alloc
 
-  precompiled:
-    name: Precompiled
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@nightly
-        with:
-          components: rust-src
-          targets: x86_64-unknown-linux-musl
-      - run: precompiled/build.sh
-      - name: replace serde_derive dependency with precompiled
-        run: |
-          cargo rm serde_derive --package serde
-          cargo rm serde_derive --package serde --dev
-          sed -i '/"serde_derive"/d' Cargo.toml
-          sed -i '/\[workspace\]/d' precompiled/serde_derive/Cargo.toml
-          cargo add --dev serde_derive --path precompiled/serde_derive --package serde_test_suite
-          git diff
-      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
-
-  macos:
-    name: macOS
-    runs-on: macos-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
-      - run: cd precompiled/serde_derive && cargo check
-
   minimal:
     name: Minimal versions
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
       - run: cargo generate-lockfile -Z minimal-versions
       - run: cargo check --locked --workspace
 
+  doc:
+    name: Documentation
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/install@cargo-docs-rs
+      - run: cargo docs-rs -p serde
+      - run: cargo docs-rs -p serde_derive
+      - run: cargo docs-rs -p serde_derive_internals
+
   clippy:
     name: Clippy
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@clippy
       - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
       - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
@@ -168,7 +151,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@miri
       - run: cargo miri setup
       - run: cd serde && cargo miri test --features derive,rc,unstable
@@ -184,6 +167,7 @@ jobs:
     if: github.event_name != 'pull_request'
     timeout-minutes: 45
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
       - uses: dtolnay/install@cargo-outdated
       - run: cargo outdated --workspace --exit-code 1

Cargo.toml

@@ -8,3 +8,8 @@ members = [
 
 [patch.crates-io]
 serde = { path = "serde" }
+
+[workspace.dependencies]
+proc-macro2 = { version = "1.0.74", default-features = false }
+quote = { version = "1.0.35", default-features = false }
+syn = { version = "2.0.46", default-features = false }

README.md

@@ -1,11 +1,11 @@
-# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.31+]][Rust 1.31] [![serde_derive: rustc 1.56+]][Rust 1.56]
+# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde msrv]][Rust 1.31] [![serde_derive msrv]][Rust 1.56]
 
 [Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master
 [actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
-[serde: rustc 1.31+]: https://img.shields.io/badge/serde-rustc_1.31+-lightgray.svg
-[serde_derive: rustc 1.56+]: https://img.shields.io/badge/serde_derive-rustc_1.56+-lightgray.svg
+[serde msrv]: https://img.shields.io/crates/msrv/serde.svg?label=serde%20msrv&color=lightgray
+[serde_derive msrv]: https://img.shields.io/crates/msrv/serde_derive.svg?label=serde_derive%20msrv&color=lightgray
 [Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
 [Rust 1.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html
 

precompiled/.gitignore

@@ -1 +0,0 @@
-/serde_derive/serde_derive-x86_64-unknown-linux-gnu

precompiled/Cargo.toml

@@ -1,14 +0,0 @@
-[workspace]
-members = ["bin", "proc-macro2"]
-resolver = "2"
-
-[patch.crates-io]
-proc-macro2 = { path = "proc-macro2" }
-
-[profile.precompiled]
-inherits = "release"
-codegen-units = 1
-lto = true
-opt-level = "z"
-panic = "abort"
-strip = true

precompiled/bin/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "serde_derive"
-version = "1.0.184"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-publish = false
-
-[lib]
-doctest = false
-
-[[bin]]
-name = "serde_derive"
-path = "main.rs"
-
-[dependencies]
-proc-macro2 = "1"
-quote = { version = "1", default-features = false }
-syn = { version = "2.0.28", default-features = false, features = ["clone-impls", "derive", "full", "parsing", "printing"] }

precompiled/bin/build.rs

@@ -1,4 +0,0 @@
-fn main() {
-    println!("cargo:rustc-cfg=precompiled");
-    println!("cargo:rustc-cfg=feature=\"deserialize_in_place\"");
-}

precompiled/bin/main.rs

@@ -1,45 +0,0 @@
-extern crate proc_macro2;
-
-use proc_macro2::watt;
-use proc_macro2::watt::buffer::InputBuffer;
-use std::alloc::{GlobalAlloc, Layout, System};
-use std::io::{self, Read, Write};
-use std::sync::atomic::Ordering;
-
-struct MonotonicAllocator;
-
-#[global_allocator]
-static ALLOCATOR: MonotonicAllocator = MonotonicAllocator;
-
-unsafe impl GlobalAlloc for MonotonicAllocator {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        System.alloc(layout)
-    }
-
-    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
-        // Leak: this cuts 3% of code size from the precompiled macro binary.
-        // There is no way that serde_derive would fill up all memory on the
-        // host. When the subprocess exits, operating system will clean this up.
-    }
-}
-
-fn main() {
-    let mut buf = Vec::new();
-    io::stdin().read_to_end(&mut buf).unwrap();
-
-    let mut buf = InputBuffer::new(&buf);
-    let derive = match buf.read_u8() {
-        0 => serde_derive::derive_serialize,
-        1 => serde_derive::derive_deserialize,
-        2 => {
-            serde_derive::DESERIALIZE_IN_PLACE.store(true, Ordering::Relaxed);
-            serde_derive::derive_deserialize
-        }
-        _ => unreachable!(),
-    };
-
-    let input = watt::load(&mut buf);
-    let output = derive(input);
-    let bytes = watt::linearize(output);
-    io::stdout().write_all(&bytes).unwrap();
-}

precompiled/bin/src

@@ -1 +0,0 @@
-../../serde_derive/src

precompiled/build.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null
-set -e -x
-
-# TODO: Sanitize host filesystem paths. https://github.com/rust-lang/cargo/issues/12137
-
-cargo +nightly build \
-    --manifest-path bin/Cargo.toml \
-    --bin serde_derive \
-    --profile precompiled \
-    -Z unstable-options \
-    -Z build-std=std,panic_abort \
-    -Z build-std-features=panic_immediate_abort \
-    --target x86_64-unknown-linux-musl \
-    --out-dir serde_derive
-
-rm -f serde_derive/serde_derive-x86_64-unknown-linux-gnu
-mv serde_derive/serde_derive{,-x86_64-unknown-linux-gnu}

precompiled/proc-macro2/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "proc-macro2"
-version = "1.0.66"
-edition = "2021"
-publish = false
-
-[dependencies]
-proc-macro2 = { package = "proc-macro2-fallback", version = "1" }

precompiled/proc-macro2/src/lib.rs

@@ -1,815 +0,0 @@
-#[doc(hidden)]
-pub mod watt;
-
-use crate::extra::DelimSpan;
-use crate::watt::Identity;
-use std::cmp::Ordering;
-use std::fmt::{self, Debug, Display};
-use std::hash::{Hash, Hasher};
-use std::ops::RangeBounds;
-use std::str::FromStr;
-
-pub use proc_macro2::{Delimiter, Spacing};
-
-#[derive(Copy, Clone)]
-pub struct Span {
-    lo: u32,
-    hi: u32,
-}
-
-impl Span {
-    pub fn call_site() -> Self {
-        Span { lo: 0, hi: 0 }
-    }
-
-    pub fn join(&self, other: Self) -> Option<Self> {
-        Some(Span {
-            lo: self.lo,
-            hi: other.hi,
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum TokenTree {
-    Group(Group),
-    Ident(Ident),
-    Punct(Punct),
-    Literal(Literal),
-}
-
-impl TokenTree {
-    pub fn span(&self) -> Span {
-        match self {
-            TokenTree::Group(group) => group.span(),
-            TokenTree::Ident(ident) => ident.span(),
-            TokenTree::Punct(punct) => punct.span(),
-            TokenTree::Literal(literal) => literal.span(),
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        match self {
-            TokenTree::Group(group) => group.set_span(span),
-            TokenTree::Ident(ident) => ident.set_span(span),
-            TokenTree::Punct(punct) => punct.set_span(span),
-            TokenTree::Literal(literal) => literal.set_span(span),
-        }
-    }
-}
-
-impl From<Group> for TokenTree {
-    fn from(group: Group) -> Self {
-        TokenTree::Group(group)
-    }
-}
-
-impl From<Ident> for TokenTree {
-    fn from(ident: Ident) -> Self {
-        TokenTree::Ident(ident)
-    }
-}
-
-impl From<Punct> for TokenTree {
-    fn from(punct: Punct) -> Self {
-        TokenTree::Punct(punct)
-    }
-}
-
-impl From<Literal> for TokenTree {
-    fn from(literal: Literal) -> Self {
-        TokenTree::Literal(literal)
-    }
-}
-
-impl Debug for TokenTree {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            TokenTree::Group(group) => Debug::fmt(group, formatter),
-            TokenTree::Ident(ident) => {
-                let mut debug = formatter.debug_struct("Ident");
-                debug.field("sym", &format_args!("{}", ident));
-                debug.finish()
-            }
-            TokenTree::Punct(punct) => Debug::fmt(punct, formatter),
-            TokenTree::Literal(literal) => Debug::fmt(literal, formatter),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct Group {
-    delimiter: Delimiter,
-    stream: Vec<TokenTree>,
-    span: Span,
-    span_open: Span,
-    span_close: Span,
-    identity: u32,
-}
-
-impl Group {
-    pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self {
-        Group {
-            delimiter,
-            stream: stream.content,
-            span: Span::call_site(),
-            span_open: Span::call_site(),
-            span_close: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn stream(&self) -> TokenStream {
-        TokenStream {
-            content: self.stream.clone(),
-        }
-    }
-
-    pub fn delimiter(&self) -> Delimiter {
-        self.delimiter
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn span_open(&self) -> Span {
-        self.span_open
-    }
-
-    pub fn span_close(&self) -> Span {
-        self.span_close
-    }
-
-    pub fn delim_span(&self) -> DelimSpan {
-        DelimSpan {
-            join: self.span,
-            open: self.span_open,
-            close: self.span_close,
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-        self.identity |= Identity::RESPANNED;
-    }
-}
-
-impl Display for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let (open, close) = match self.delimiter {
-            Delimiter::Parenthesis => ("(", ")"),
-            Delimiter::Brace => ("{ ", "}"),
-            Delimiter::Bracket => ("[", "]"),
-            Delimiter::None => ("", ""),
-        };
-
-        formatter.write_str(open)?;
-        display_tokens(&self.stream, formatter)?;
-        if self.delimiter == Delimiter::Brace && !self.stream.is_empty() {
-            formatter.write_str(" ")?;
-        }
-        formatter.write_str(close)?;
-
-        Ok(())
-    }
-}
-
-impl Debug for Group {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = formatter.debug_struct("Group");
-        debug.field("delimiter", &self.delimiter);
-        debug.field("stream", &self.stream);
-        debug.finish()
-    }
-}
-
-#[derive(Clone)]
-pub struct Ident {
-    fallback: proc_macro2::Ident,
-    span: Span,
-    identity: u32,
-}
-
-impl Ident {
-    pub fn new(string: &str, span: Span) -> Self {
-        Ident {
-            fallback: proc_macro2::Ident::new(string, proc_macro2::Span::call_site()),
-            span,
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn new_raw(string: &str, span: Span) -> Self {
-        Ident {
-            fallback: proc_macro2::Ident::new_raw(string, proc_macro2::Span::call_site()),
-            span,
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-        self.identity |= Identity::RESPANNED;
-    }
-}
-
-impl Display for Ident {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.fallback, formatter)
-    }
-}
-
-impl Debug for Ident {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.fallback, formatter)
-    }
-}
-
-impl Eq for Ident {}
-
-impl PartialEq for Ident {
-    fn eq(&self, other: &Self) -> bool {
-        PartialEq::eq(&self.fallback, &other.fallback)
-    }
-}
-
-impl<T> PartialEq<T> for Ident
-where
-    T: ?Sized + AsRef<str>,
-{
-    fn eq(&self, other: &T) -> bool {
-        PartialEq::eq(&self.fallback, other)
-    }
-}
-
-impl Ord for Ident {
-    fn cmp(&self, other: &Self) -> Ordering {
-        Ord::cmp(&self.fallback, &other.fallback)
-    }
-}
-
-impl PartialOrd for Ident {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        PartialOrd::partial_cmp(&self.fallback, &other.fallback)
-    }
-}
-
-impl Hash for Ident {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        Hash::hash(&self.fallback, hasher);
-    }
-}
-
-#[derive(Clone)]
-pub struct Punct {
-    fallback: proc_macro2::Punct,
-    span: Span,
-    identity: u32,
-}
-
-impl Punct {
-    pub fn new(ch: char, spacing: Spacing) -> Self {
-        Punct {
-            fallback: proc_macro2::Punct::new(ch, spacing),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn as_char(&self) -> char {
-        self.fallback.as_char()
-    }
-
-    pub fn spacing(&self) -> Spacing {
-        self.fallback.spacing()
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-        self.identity |= Identity::RESPANNED;
-    }
-}
-
-impl Display for Punct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.fallback, formatter)
-    }
-}
-
-impl Debug for Punct {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.fallback, formatter)
-    }
-}
-
-#[derive(Clone)]
-pub struct Literal {
-    fallback: proc_macro2::Literal,
-    span: Span,
-    identity: u32,
-}
-
-impl Literal {
-    pub fn u8_suffixed(n: u8) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u8_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u16_suffixed(n: u16) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u16_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u32_suffixed(n: u32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u32_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u64_suffixed(n: u64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u64_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u128_suffixed(n: u128) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u128_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn usize_suffixed(n: usize) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::usize_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i8_suffixed(n: i8) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i8_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i16_suffixed(n: i16) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i16_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i32_suffixed(n: i32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i32_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i64_suffixed(n: i64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i64_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i128_suffixed(n: i128) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i128_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn isize_suffixed(n: isize) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::isize_suffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u8_unsuffixed(n: u8) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u8_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u16_unsuffixed(n: u16) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u16_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u32_unsuffixed(n: u32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u32_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u64_unsuffixed(n: u64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u64_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn u128_unsuffixed(n: u128) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::u128_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn usize_unsuffixed(n: usize) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::usize_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i8_unsuffixed(n: i8) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i8_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i16_unsuffixed(n: i16) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i16_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i32_unsuffixed(n: i32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i32_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i64_unsuffixed(n: i64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i64_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn i128_unsuffixed(n: i128) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::i128_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn isize_unsuffixed(n: isize) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::isize_unsuffixed(n),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn f64_unsuffixed(f: f64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::f64_unsuffixed(f),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn f64_suffixed(f: f64) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::f64_suffixed(f),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn f32_unsuffixed(f: f32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::f32_unsuffixed(f),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn f32_suffixed(f: f32) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::f32_suffixed(f),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn string(string: &str) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::string(string),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn character(ch: char) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::character(ch),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn byte_string(s: &[u8]) -> Self {
-        Literal {
-            fallback: proc_macro2::Literal::byte_string(s),
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        }
-    }
-
-    pub fn span(&self) -> Span {
-        self.span
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span;
-        self.identity |= Identity::RESPANNED;
-    }
-
-    pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
-        let _ = range;
-        None
-    }
-}
-
-impl FromStr for Literal {
-    type Err = LexError;
-
-    fn from_str(repr: &str) -> Result<Self, Self::Err> {
-        let fallback = match proc_macro2::Literal::from_str(repr) {
-            Ok(literal) => literal,
-            Err(error) => {
-                return Err(LexError {
-                    fallback: error,
-                    span: Span::call_site(),
-                });
-            }
-        };
-        Ok(Literal {
-            fallback,
-            span: Span::call_site(),
-            identity: Identity::NOVEL,
-        })
-    }
-}
-
-impl Display for Literal {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.fallback, formatter)
-    }
-}
-
-impl Debug for Literal {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.fallback, formatter)
-    }
-}
-
-#[derive(Clone)]
-pub struct TokenStream {
-    content: Vec<TokenTree>,
-}
-
-impl TokenStream {
-    pub fn new() -> Self {
-        TokenStream {
-            content: Vec::new(),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.content.is_empty()
-    }
-}
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = token_stream::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        token_stream::IntoIter {
-            iter: self.content.into_iter(),
-        }
-    }
-}
-
-impl Extend<TokenStream> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
-        self.content.extend(streams.into_iter().flatten());
-    }
-}
-
-impl Extend<TokenTree> for TokenStream {
-    fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
-        self.content.extend(streams);
-    }
-}
-
-impl FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
-        let content = streams.into_iter().flatten().collect();
-        TokenStream { content }
-    }
-}
-
-impl FromIterator<TokenTree> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = TokenTree>>(streams: I) -> Self {
-        let content = streams.into_iter().collect();
-        TokenStream { content }
-    }
-}
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(string: &str) -> Result<Self, Self::Err> {
-        let fallback = match proc_macro2::TokenStream::from_str(string) {
-            Ok(token_stream) => token_stream,
-            Err(error) => {
-                return Err(LexError {
-                    fallback: error,
-                    span: Span::call_site(),
-                });
-            }
-        };
-
-        fn convert_token_stream(stream: proc_macro2::TokenStream) -> TokenStream {
-            TokenStream {
-                content: stream.into_iter().map(convert_token_tree).collect(),
-            }
-        }
-
-        fn convert_token_tree(token: proc_macro2::TokenTree) -> TokenTree {
-            match token {
-                proc_macro2::TokenTree::Group(group) => TokenTree::Group(Group::new(
-                    group.delimiter(),
-                    convert_token_stream(group.stream()),
-                )),
-                proc_macro2::TokenTree::Ident(ident) => TokenTree::Ident(Ident {
-                    fallback: ident,
-                    span: Span::call_site(),
-                    identity: Identity::NOVEL,
-                }),
-                proc_macro2::TokenTree::Punct(punct) => TokenTree::Punct(Punct {
-                    fallback: punct,
-                    span: Span::call_site(),
-                    identity: Identity::NOVEL,
-                }),
-                proc_macro2::TokenTree::Literal(literal) => TokenTree::Literal(Literal {
-                    fallback: literal,
-                    span: Span::call_site(),
-                    identity: Identity::NOVEL,
-                }),
-            }
-        }
-
-        Ok(convert_token_stream(fallback))
-    }
-}
-
-fn display_tokens(tokens: &[TokenTree], formatter: &mut fmt::Formatter) -> fmt::Result {
-    let mut joint = false;
-    for (i, token) in tokens.iter().enumerate() {
-        if i != 0 && !joint {
-            write!(formatter, " ")?;
-        }
-        joint = false;
-        match token {
-            TokenTree::Group(group) => Display::fmt(group, formatter),
-            TokenTree::Ident(ident) => Display::fmt(ident, formatter),
-            TokenTree::Punct(punct) => {
-                joint = punct.spacing() == Spacing::Joint;
-                Display::fmt(punct, formatter)
-            }
-            TokenTree::Literal(literal) => Display::fmt(literal, formatter),
-        }?;
-    }
-
-    Ok(())
-}
-
-impl Display for TokenStream {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        display_tokens(&self.content, formatter)
-    }
-}
-
-impl Debug for TokenStream {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("TokenStream ")?;
-        formatter.debug_list().entries(&self.content).finish()
-    }
-}
-
-pub struct LexError {
-    fallback: proc_macro2::LexError,
-    span: Span,
-}
-
-impl LexError {
-    pub fn span(&self) -> Span {
-        self.span
-    }
-}
-
-impl Debug for LexError {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Debug::fmt(&self.fallback, formatter)
-    }
-}
-
-pub mod token_stream {
-    use super::*;
-
-    #[derive(Clone)]
-    pub struct IntoIter {
-        pub(crate) iter: <Vec<TokenTree> as IntoIterator>::IntoIter,
-    }
-
-    impl Iterator for IntoIter {
-        type Item = TokenTree;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            self.iter.next()
-        }
-
-        fn size_hint(&self) -> (usize, Option<usize>) {
-            self.iter.size_hint()
-        }
-    }
-}
-
-pub mod extra {
-    use crate::Span;
-
-    #[derive(Copy, Clone)]
-    pub struct DelimSpan {
-        pub(crate) join: Span,
-        pub(crate) open: Span,
-        pub(crate) close: Span,
-    }
-
-    impl DelimSpan {
-        pub fn join(&self) -> Span {
-            self.join
-        }
-
-        pub fn open(&self) -> Span {
-            self.open
-        }
-
-        pub fn close(&self) -> Span {
-            self.close
-        }
-    }
-}

precompiled/proc-macro2/src/watt/buffer.rs

@@ -1,69 +0,0 @@
-use std::str;
-
-pub struct OutputBuffer {
-    bytes: Vec<u8>,
-}
-
-impl OutputBuffer {
-    pub fn new() -> Self {
-        OutputBuffer { bytes: Vec::new() }
-    }
-
-    pub fn write_u8(&mut self, value: u8) {
-        self.bytes.push(value);
-    }
-
-    pub fn write_u16(&mut self, value: u16) {
-        self.bytes.extend_from_slice(&value.to_le_bytes());
-    }
-
-    pub fn write_u32(&mut self, value: u32) {
-        self.bytes.extend_from_slice(&value.to_le_bytes());
-    }
-
-    pub fn write_str(&mut self, value: &str) {
-        self.bytes.extend_from_slice(value.as_bytes());
-    }
-
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.bytes
-    }
-}
-
-pub struct InputBuffer<'a> {
-    bytes: &'a [u8],
-}
-
-impl<'a> InputBuffer<'a> {
-    pub fn new(bytes: &'a [u8]) -> Self {
-        InputBuffer { bytes }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.bytes.is_empty()
-    }
-
-    pub fn read_u8(&mut self) -> u8 {
-        let (first, rest) = self.bytes.split_first().unwrap();
-        self.bytes = rest;
-        *first
-    }
-
-    pub fn read_u16(&mut self) -> u16 {
-        let (value, rest) = self.bytes.split_at(2);
-        self.bytes = rest;
-        u16::from_le_bytes([value[0], value[1]])
-    }
-
-    pub fn read_u32(&mut self) -> u32 {
-        let (value, rest) = self.bytes.split_at(4);
-        self.bytes = rest;
-        u32::from_le_bytes([value[0], value[1], value[2], value[3]])
-    }
-
-    pub fn read_str(&mut self, len: usize) -> &'a str {
-        let (string, rest) = self.bytes.split_at(len);
-        self.bytes = rest;
-        str::from_utf8(string).unwrap()
-    }
-}

precompiled/proc-macro2/src/watt/bytecode.rs

@@ -1,17 +0,0 @@
-pub enum Bytecode {}
-
-impl Bytecode {
-    pub const GROUP_PARENTHESIS: u8 = 0;
-    pub const GROUP_BRACE: u8 = 1;
-    pub const GROUP_BRACKET: u8 = 2;
-    pub const GROUP_NONE: u8 = 3;
-    pub const IDENT: u8 = 4;
-    pub const PUNCT_ALONE: u8 = 5;
-    pub const PUNCT_JOINT: u8 = 6;
-    pub const LITERAL: u8 = 7;
-    pub const LOAD_GROUP: u8 = 8;
-    pub const LOAD_IDENT: u8 = 9;
-    pub const LOAD_PUNCT: u8 = 10;
-    pub const LOAD_LITERAL: u8 = 11;
-    pub const SET_SPAN: u8 = 12;
-}

precompiled/proc-macro2/src/watt/mod.rs

@@ -1,205 +0,0 @@
-pub mod buffer;
-pub mod bytecode;
-
-use crate::watt::buffer::{InputBuffer, OutputBuffer};
-use crate::watt::bytecode::Bytecode;
-use crate::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
-use std::str::FromStr;
-
-pub enum Kind {
-    Group(Delimiter),
-    Ident,
-    Punct(Spacing),
-    Literal,
-}
-
-pub enum Identity {}
-
-impl Identity {
-    pub const RESPANNED: u32 = 1 << 31;
-    pub const NOVEL: u32 = u32::MAX;
-}
-
-impl Span {
-    fn is_call_site(&self) -> bool {
-        self.lo == 0 && self.hi == 0
-    }
-}
-
-fn post_increment(counter: &mut u32) -> impl FnMut() -> u32 + '_ {
-    || {
-        let value = *counter;
-        *counter += 1;
-        value
-    }
-}
-
-pub fn load(buf: &mut InputBuffer) -> TokenStream {
-    let mut span_counter = 1;
-    let mut next_span = post_increment(&mut span_counter);
-    let mut next_span = || {
-        let next = next_span();
-        Span { lo: next, hi: next }
-    };
-
-    let [mut group_counter, mut ident_counter, mut punct_counter, mut literal_counter] = [0; 4];
-    let mut next_group = post_increment(&mut group_counter);
-    let mut next_ident = post_increment(&mut ident_counter);
-    let mut next_punct = post_increment(&mut punct_counter);
-    let mut next_literal = post_increment(&mut literal_counter);
-
-    let mut trees = Vec::new();
-    while !buf.is_empty() {
-        match match buf.read_u8() {
-            Bytecode::GROUP_PARENTHESIS => Kind::Group(Delimiter::Parenthesis),
-            Bytecode::GROUP_BRACE => Kind::Group(Delimiter::Brace),
-            Bytecode::GROUP_BRACKET => Kind::Group(Delimiter::Bracket),
-            Bytecode::GROUP_NONE => Kind::Group(Delimiter::None),
-            Bytecode::IDENT => Kind::Ident,
-            Bytecode::PUNCT_ALONE => Kind::Punct(Spacing::Alone),
-            Bytecode::PUNCT_JOINT => Kind::Punct(Spacing::Joint),
-            Bytecode::LITERAL => Kind::Literal,
-            _ => unreachable!(),
-        } {
-            Kind::Group(delimiter) => {
-                let len = buf.read_u32();
-                let stream = trees.drain(trees.len() - len as usize..).collect();
-                trees.push(TokenTree::Group(Group {
-                    delimiter,
-                    stream,
-                    span: next_span(),
-                    span_open: next_span(),
-                    span_close: next_span(),
-                    identity: next_group(),
-                }));
-            }
-            Kind::Ident => {
-                let len = buf.read_u16();
-                let repr = buf.read_str(len as usize);
-                let ident = if let Some(repr) = repr.strip_prefix("r#") {
-                    proc_macro2::Ident::new_raw(repr, proc_macro2::Span::call_site())
-                } else if repr == "$crate" {
-                    proc_macro2::Ident::new("crate", proc_macro2::Span::call_site())
-                } else {
-                    proc_macro2::Ident::new(repr, proc_macro2::Span::call_site())
-                };
-                trees.push(TokenTree::Ident(Ident {
-                    fallback: ident,
-                    span: next_span(),
-                    identity: next_ident(),
-                }));
-            }
-            Kind::Punct(spacing) => {
-                let ch = buf.read_u8();
-                assert!(ch.is_ascii());
-                let punct = proc_macro2::Punct::new(ch as char, spacing);
-                trees.push(TokenTree::Punct(Punct {
-                    fallback: punct,
-                    span: next_span(),
-                    identity: next_punct(),
-                }));
-            }
-            Kind::Literal => {
-                let len = buf.read_u16();
-                let repr = buf.read_str(len as usize);
-                let literal = proc_macro2::Literal::from_str(repr).unwrap();
-                trees.push(TokenTree::Literal(Literal {
-                    fallback: literal,
-                    span: next_span(),
-                    identity: next_literal(),
-                }));
-            }
-        }
-    }
-
-    TokenStream { content: trees }
-}
-
-pub fn linearize(tokens: TokenStream) -> Vec<u8> {
-    let mut buf = OutputBuffer::new();
-    for token in &tokens.content {
-        linearize_token(token, &mut buf);
-    }
-    buf.into_bytes()
-}
-
-fn linearize_token(token: &TokenTree, buf: &mut OutputBuffer) {
-    let needs_span;
-    match token {
-        TokenTree::Group(group) => {
-            if group.identity < Identity::NOVEL {
-                buf.write_u8(Bytecode::LOAD_GROUP);
-                buf.write_u32(group.identity & !Identity::RESPANNED);
-                needs_span = group.identity >= Identity::RESPANNED;
-            } else {
-                let len = group.stream.len();
-                assert!(len <= u32::MAX as usize);
-                for token in &group.stream {
-                    linearize_token(token, buf);
-                }
-                buf.write_u8(match group.delimiter {
-                    Delimiter::Parenthesis => Bytecode::GROUP_PARENTHESIS,
-                    Delimiter::Brace => Bytecode::GROUP_BRACE,
-                    Delimiter::Bracket => Bytecode::GROUP_BRACKET,
-                    Delimiter::None => Bytecode::GROUP_NONE,
-                });
-                buf.write_u32(len as u32);
-                needs_span = !group.span.is_call_site();
-            }
-        }
-        TokenTree::Ident(ident) => {
-            if ident.identity < Identity::NOVEL {
-                buf.write_u8(Bytecode::LOAD_IDENT);
-                buf.write_u32(ident.identity & !Identity::RESPANNED);
-                needs_span = ident.identity >= Identity::RESPANNED;
-            } else {
-                buf.write_u8(Bytecode::IDENT);
-                let repr = ident.to_string();
-                assert!(repr.len() <= u16::MAX as usize);
-                buf.write_u16(repr.len() as u16);
-                buf.write_str(&repr);
-                linearize_span(ident.span, buf);
-                needs_span = false;
-            }
-        }
-        TokenTree::Punct(punct) => {
-            if punct.identity < Identity::NOVEL {
-                buf.write_u8(Bytecode::LOAD_PUNCT);
-                buf.write_u32(punct.identity & !Identity::RESPANNED);
-                needs_span = punct.identity >= Identity::RESPANNED;
-            } else {
-                buf.write_u8(match punct.spacing() {
-                    Spacing::Alone => Bytecode::PUNCT_ALONE,
-                    Spacing::Joint => Bytecode::PUNCT_JOINT,
-                });
-                let ch = punct.as_char();
-                assert!(ch.is_ascii());
-                buf.write_u8(ch as u8);
-                needs_span = !punct.span.is_call_site();
-            }
-        }
-        TokenTree::Literal(literal) => {
-            if literal.identity < Identity::NOVEL {
-                buf.write_u8(Bytecode::LOAD_LITERAL);
-                buf.write_u32(literal.identity & !Identity::RESPANNED);
-                needs_span = literal.identity >= Identity::RESPANNED;
-            } else {
-                buf.write_u8(Bytecode::LITERAL);
-                let repr = literal.to_string();
-                assert!(repr.len() <= u16::MAX as usize);
-                buf.write_u16(repr.len() as u16);
-                buf.write_str(&repr);
-                needs_span = !literal.span.is_call_site();
-            }
-        }
-    }
-    if needs_span {
-        buf.write_u8(Bytecode::SET_SPAN);
-        linearize_span(token.span(), buf);
-    }
-}
-
-fn linearize_span(span: Span, buf: &mut OutputBuffer) {
-    buf.write_u32(span.lo);
-    buf.write_u32(span.hi);
-}

precompiled/serde_derive/Cargo.toml

@@ -1,36 +0,0 @@
-[package]
-name = "serde_derive"
-version = "1.0.184"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-categories = ["no-std", "no-std::no-alloc"]
-description = "Implementation of #[derive(Serialize, Deserialize)]"
-documentation = "https://serde.rs/derive.html"
-edition = "2015"
-homepage = "https://serde.rs"
-include = ["serde_derive-x86_64-unknown-linux-gnu", "src", "LICENSE-APACHE", "LICENSE-MIT"]
-keywords = ["serde", "serialization", "no_std", "derive"]
-license = "MIT OR Apache-2.0"
-readme = "crates-io.md"
-repository = "https://github.com/serde-rs/serde"
-rust-version = "1.56"
-
-[features]
-default = []
-deserialize_in_place = []
-
-[lib]
-proc-macro = true
-
-[target.'cfg(not(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu")))'.dependencies]
-proc-macro2 = "1"
-quote = "1"
-syn = "2.0.28"
-
-[dev-dependencies]
-serde = { version = "1", path = "../../serde" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = ["--generate-link-to-definition"]
-
-[workspace]

precompiled/serde_derive/LICENSE-APACHE

@@ -1 +0,0 @@
-../../LICENSE-APACHE

precompiled/serde_derive/LICENSE-MIT

@@ -1 +0,0 @@
-../../LICENSE-MIT

precompiled/serde_derive/README.md

@@ -1 +0,0 @@
-../../README.md

precompiled/serde_derive/crates-io.md

@@ -1 +0,0 @@
-../../crates-io.md

precompiled/serde_derive/src/bound.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/bound.rs

precompiled/serde_derive/src/buffer.rs

@@ -1 +0,0 @@
-../../proc-macro2/src/watt/buffer.rs

precompiled/serde_derive/src/bytecode.rs

@@ -1 +0,0 @@
-../../proc-macro2/src/watt/bytecode.rs

precompiled/serde_derive/src/de.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/de.rs

precompiled/serde_derive/src/dummy.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/dummy.rs

precompiled/serde_derive/src/fragment.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/fragment.rs

precompiled/serde_derive/src/internals

@@ -1 +0,0 @@
-../../../serde_derive/src/internals/

precompiled/serde_derive/src/lib.rs

@@ -1,22 +0,0 @@
-//! This crate provides Serde's two derive macros.
-//!
-//! ```edition2021
-//! # use serde_derive::{Deserialize, Serialize};
-//! #
-//! #[derive(Serialize, Deserialize)]
-//! # struct S;
-//! #
-//! # fn main() {}
-//! ```
-//!
-//! Please refer to [https://serde.rs/derive.html] for how to set this up.
-//!
-//! [https://serde.rs/derive.html]: https://serde.rs/derive.html
-
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.184")]
-
-#[cfg(not(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu")))]
-include!("lib_from_source.rs");
-
-#[cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"))]
-include!("lib_precompiled.rs");

precompiled/serde_derive/src/lib_from_source.rs

@@ -1,35 +0,0 @@
-extern crate proc_macro;
-extern crate proc_macro2;
-extern crate quote;
-extern crate syn;
-
-#[macro_use]
-mod bound;
-#[macro_use]
-mod fragment;
-
-mod de;
-mod dummy;
-mod internals;
-mod pretend;
-mod ser;
-mod this;
-
-use proc_macro::TokenStream;
-use syn::{parse_macro_input, DeriveInput};
-
-#[proc_macro_derive(Serialize, attributes(serde))]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&mut input)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
-}
-
-#[proc_macro_derive(Deserialize, attributes(serde))]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&mut input)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
-}

precompiled/serde_derive/src/lib_precompiled.rs

@@ -1,234 +0,0 @@
-extern crate proc_macro;
-
-mod buffer;
-mod bytecode;
-
-use crate::buffer::{InputBuffer, OutputBuffer};
-use crate::bytecode::Bytecode;
-use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree};
-use std::io::{ErrorKind, Read, Write};
-use std::iter::FromIterator;
-use std::path::Path;
-use std::process::{Command, ExitStatus, Stdio};
-use std::str::FromStr;
-
-#[proc_macro_derive(Serialize, attributes(serde))]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    derive(0, input)
-}
-
-#[proc_macro_derive(Deserialize, attributes(serde))]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    derive(1 + cfg!(feature = "deserialize_in_place") as u8, input)
-}
-
-fn derive(select: u8, input: TokenStream) -> TokenStream {
-    let mut memory = TokenMemory::default();
-    let mut buf = OutputBuffer::new();
-    buf.write_u8(select);
-
-    memory.spans.push(Span::call_site());
-    for token in input {
-        memory.linearize_token(token, &mut buf);
-    }
-
-    let exe_path = Path::new(concat!(
-        env!("CARGO_MANIFEST_DIR"),
-        "/serde_derive-x86_64-unknown-linux-gnu",
-    ));
-    let mut child = match Command::new(exe_path)
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .spawn()
-    {
-        Ok(child) => child,
-        Err(io_error) => {
-            if io_error.kind() == ErrorKind::NotFound {
-                panic!(
-                    "file missing from serde_derive manifest directory during macro expansion: {}",
-                    exe_path.display(),
-                );
-            } else {
-                panic!("failed to spawn process: {}", io_error);
-            }
-        }
-    };
-
-    let mut stdin = child.stdin.take().unwrap();
-    let mut buf = buf.into_bytes();
-    stdin.write_all(&buf).unwrap();
-    drop(stdin);
-
-    let mut stdout = child.stdout.take().unwrap();
-    buf.clear();
-    stdout.read_to_end(&mut buf).unwrap();
-
-    let success = child.wait().as_ref().map_or(true, ExitStatus::success);
-    if !success || buf.is_empty() {
-        panic!();
-    }
-
-    let mut buf = InputBuffer::new(&buf);
-    memory.receive(&mut buf)
-}
-
-#[derive(Default)]
-struct TokenMemory {
-    spans: Vec<Span>,
-    groups: Vec<Group>,
-    idents: Vec<Ident>,
-    puncts: Vec<Punct>,
-    literals: Vec<Literal>,
-}
-
-enum Kind {
-    Group(Delimiter),
-    Ident,
-    Punct(Spacing),
-    Literal,
-}
-
-impl TokenMemory {
-    // Depth-first post-order traversal.
-    fn linearize_token(&mut self, token: TokenTree, buf: &mut OutputBuffer) {
-        match token {
-            TokenTree::Group(group) => {
-                let mut len = 0usize;
-                for token in group.stream() {
-                    self.linearize_token(token, buf);
-                    len += 1;
-                }
-                assert!(len <= u32::MAX as usize);
-                buf.write_u8(match group.delimiter() {
-                    Delimiter::Parenthesis => Bytecode::GROUP_PARENTHESIS,
-                    Delimiter::Brace => Bytecode::GROUP_BRACE,
-                    Delimiter::Bracket => Bytecode::GROUP_BRACKET,
-                    Delimiter::None => Bytecode::GROUP_NONE,
-                });
-                buf.write_u32(len as u32);
-                self.spans
-                    .extend([group.span(), group.span_open(), group.span_close()]);
-                self.groups.push(group);
-            }
-            TokenTree::Ident(ident) => {
-                buf.write_u8(Bytecode::IDENT);
-                let repr = ident.to_string();
-                assert!(repr.len() <= u16::MAX as usize);
-                buf.write_u16(repr.len() as u16);
-                buf.write_str(&repr);
-                self.spans.push(ident.span());
-                self.idents.push(ident);
-            }
-            TokenTree::Punct(punct) => {
-                buf.write_u8(match punct.spacing() {
-                    Spacing::Alone => Bytecode::PUNCT_ALONE,
-                    Spacing::Joint => Bytecode::PUNCT_JOINT,
-                });
-                let ch = punct.as_char();
-                assert!(ch.is_ascii());
-                buf.write_u8(ch as u8);
-                self.spans.push(punct.span());
-                self.puncts.push(punct);
-            }
-            TokenTree::Literal(literal) => {
-                buf.write_u8(Bytecode::LITERAL);
-                let repr = literal.to_string();
-                assert!(repr.len() <= u16::MAX as usize);
-                buf.write_u16(repr.len() as u16);
-                buf.write_str(&repr);
-                self.spans.push(literal.span());
-                self.literals.push(literal);
-            }
-        }
-    }
-
-    fn receive(&self, buf: &mut InputBuffer) -> TokenStream {
-        let mut trees = Vec::new();
-        while !buf.is_empty() {
-            match match buf.read_u8() {
-                Bytecode::GROUP_PARENTHESIS => Kind::Group(Delimiter::Parenthesis),
-                Bytecode::GROUP_BRACE => Kind::Group(Delimiter::Brace),
-                Bytecode::GROUP_BRACKET => Kind::Group(Delimiter::Bracket),
-                Bytecode::GROUP_NONE => Kind::Group(Delimiter::None),
-                Bytecode::IDENT => Kind::Ident,
-                Bytecode::PUNCT_ALONE => Kind::Punct(Spacing::Alone),
-                Bytecode::PUNCT_JOINT => Kind::Punct(Spacing::Joint),
-                Bytecode::LITERAL => Kind::Literal,
-                Bytecode::LOAD_GROUP => {
-                    let identity = buf.read_u32();
-                    let group = self.groups[identity as usize].clone();
-                    trees.push(TokenTree::Group(group));
-                    continue;
-                }
-                Bytecode::LOAD_IDENT => {
-                    let identity = buf.read_u32();
-                    let ident = self.idents[identity as usize].clone();
-                    trees.push(TokenTree::Ident(ident));
-                    continue;
-                }
-                Bytecode::LOAD_PUNCT => {
-                    let identity = buf.read_u32();
-                    let punct = self.puncts[identity as usize].clone();
-                    trees.push(TokenTree::Punct(punct));
-                    continue;
-                }
-                Bytecode::LOAD_LITERAL => {
-                    let identity = buf.read_u32();
-                    let literal = self.literals[identity as usize].clone();
-                    trees.push(TokenTree::Literal(literal));
-                    continue;
-                }
-                Bytecode::SET_SPAN => {
-                    trees.last_mut().unwrap().set_span(self.read_span(buf));
-                    continue;
-                }
-                _ => unreachable!(),
-            } {
-                Kind::Group(delimiter) => {
-                    let len = buf.read_u32();
-                    let stream = trees.drain(trees.len() - len as usize..).collect();
-                    let group = Group::new(delimiter, stream);
-                    trees.push(TokenTree::Group(group));
-                }
-                Kind::Ident => {
-                    let len = buf.read_u16();
-                    let repr = buf.read_str(len as usize);
-                    let span = self.read_span(buf);
-                    let ident = if let Some(repr) = repr.strip_prefix("r#") {
-                        Ident::new_raw(repr, span)
-                    } else {
-                        Ident::new(repr, span)
-                    };
-                    trees.push(TokenTree::Ident(ident));
-                }
-                Kind::Punct(spacing) => {
-                    let ch = buf.read_u8();
-                    assert!(ch.is_ascii());
-                    let punct = Punct::new(ch as char, spacing);
-                    trees.push(TokenTree::Punct(punct));
-                }
-                Kind::Literal => {
-                    let len = buf.read_u16();
-                    let repr = buf.read_str(len as usize);
-                    let literal = Literal::from_str(repr).unwrap();
-                    trees.push(TokenTree::Literal(literal));
-                }
-            }
-        }
-
-        TokenStream::from_iter(trees)
-    }
-
-    fn read_span(&self, buf: &mut InputBuffer) -> Span {
-        let lo = buf.read_u32();
-        let hi = buf.read_u32();
-        let span = self.spans[lo as usize];
-        if lo == hi {
-            span
-        } else {
-            #[cfg(any())] // FIXME
-            return span.join(self.spans[hi as usize]).unwrap_or(span);
-            span
-        }
-    }
-}

precompiled/serde_derive/src/pretend.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/pretend.rs

precompiled/serde_derive/src/ser.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/ser.rs

precompiled/serde_derive/src/this.rs

@@ -1 +0,0 @@
-../../../serde_derive/src/this.rs

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.184" # remember to update html_root_url and serde_derive dependency
+version = "1.0.199"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
@@ -15,7 +15,7 @@ repository = "https://github.com/serde-rs/serde"
 rust-version = "1.31"
 
 [dependencies]
-serde_derive = { version = "=1.0.184", optional = true, path = "../serde_derive" }
+serde_derive = { version = "1", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1", path = "../serde_derive" }
@@ -27,9 +27,17 @@ doc-scrape-examples = false
 features = ["derive", "rc"]
 
 [package.metadata.docs.rs]
-features = ["derive"]
+features = ["derive", "rc", "unstable"]
 targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = ["--generate-link-to-definition"]
+rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]
+
+# This cfg cannot be enabled, but it still forces Cargo to keep serde_derive's
+# version in lockstep with serde's, even if someone depends on the two crates
+# separately with serde's "derive" feature disabled. Every serde_derive release
+# is compatible with exactly one serde release because the generated code
+# involves nonpublic APIs which are not bound by semver.
+[target.'cfg(any())'.dependencies]
+serde_derive = { version = "=1.0.199", path = "../serde_derive" }
 
 
 ### FEATURES #################################################################

serde/build.rs

@@ -27,11 +27,10 @@ fn main() {
         println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
     }
 
-    // Disabled on Emscripten targets before Rust 1.40 since
-    // Emscripten did not support 128-bit integers until Rust 1.40
-    // (https://github.com/rust-lang/rust/pull/65251)
-    if emscripten && minor < 40 {
-        println!("cargo:rustc-cfg=no_integer128");
+    // f32::copysign and f64::copysign stabilized in Rust 1.35.
+    // https://blog.rust-lang.org/2019/05/23/Rust-1.35.0.html#copy-the-sign-of-a-floating-point-number-onto-another
+    if minor < 35 {
+        println!("cargo:rustc-cfg=no_float_copysign");
     }
 
     // Current minimum supported version of serde_derive crate is Rust 1.56.
@@ -65,6 +64,12 @@ fn main() {
     if minor < 64 {
         println!("cargo:rustc-cfg=no_core_cstr");
     }
+
+    // Support for core::num::Saturating and std::num::Saturating stabilized in Rust 1.74
+    // https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html#stabilized-apis
+    if minor < 74 {
+        println!("cargo:rustc-cfg=no_core_num_saturating");
+    }
 }
 
 fn rustc_minor_version() -> Option<u32> {

serde/src/de/ignored_any.rs

@@ -129,12 +129,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
         Ok(IgnoredAny)
     }
 
-    serde_if_integer128! {
-        #[inline]
-        fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
+    #[inline]
+    fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
+        let _ = x;
+        Ok(IgnoredAny)
     }
 
     #[inline]
@@ -143,12 +141,10 @@ impl<'de> Visitor<'de> for IgnoredAny {
         Ok(IgnoredAny)
     }
 
-    serde_if_integer128! {
-        #[inline]
-        fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
-            let _ = x;
-            Ok(IgnoredAny)
-        }
+    #[inline]
+    fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
+        let _ = x;
+        Ok(IgnoredAny)
     }
 
     #[inline]

serde/src/de/mod.rs

@@ -64,8 +64,8 @@
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -118,12 +118,10 @@ use crate::lib::*;
 
 pub mod value;
 
-#[cfg(not(no_integer128))]
 mod format;
 mod ignored_any;
 mod impls;
 pub(crate) mod size_hint;
-mod utf8;
 
 pub use self::ignored_any::IgnoredAny;
 
@@ -404,20 +402,20 @@ impl<'a> fmt::Display for Unexpected<'a> {
             Bool(b) => write!(formatter, "boolean `{}`", b),
             Unsigned(i) => write!(formatter, "integer `{}`", i),
             Signed(i) => write!(formatter, "integer `{}`", i),
-            Float(f) => write!(formatter, "floating point `{}`", f),
+            Float(f) => write!(formatter, "floating point `{}`", WithDecimalPoint(f)),
             Char(c) => write!(formatter, "character `{}`", c),
             Str(s) => write!(formatter, "string {:?}", s),
-            Bytes(_) => write!(formatter, "byte array"),
-            Unit => write!(formatter, "unit value"),
-            Option => write!(formatter, "Option value"),
-            NewtypeStruct => write!(formatter, "newtype struct"),
-            Seq => write!(formatter, "sequence"),
-            Map => write!(formatter, "map"),
-            Enum => write!(formatter, "enum"),
-            UnitVariant => write!(formatter, "unit variant"),
-            NewtypeVariant => write!(formatter, "newtype variant"),
-            TupleVariant => write!(formatter, "tuple variant"),
-            StructVariant => write!(formatter, "struct variant"),
+            Bytes(_) => formatter.write_str("byte array"),
+            Unit => formatter.write_str("unit value"),
+            Option => formatter.write_str("Option value"),
+            NewtypeStruct => formatter.write_str("newtype struct"),
+            Seq => formatter.write_str("sequence"),
+            Map => formatter.write_str("map"),
+            Enum => formatter.write_str("enum"),
+            UnitVariant => formatter.write_str("unit variant"),
+            NewtypeVariant => formatter.write_str("newtype variant"),
+            TupleVariant => formatter.write_str("tuple variant"),
+            StructVariant => formatter.write_str("struct variant"),
             Other(other) => formatter.write_str(other),
         }
     }
@@ -950,18 +948,15 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `i128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("i128 is not supported"))
-        }
+    /// Hint that the `Deserialize` type is expecting an `i128` value.
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let _ = visitor;
+        Err(Error::custom("i128 is not supported"))
     }
 
     /// Hint that the `Deserialize` type is expecting a `u8` value.
@@ -984,18 +979,15 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
-    serde_if_integer128! {
-        /// Hint that the `Deserialize` type is expecting an `u128` value.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>
-        {
-            let _ = visitor;
-            Err(Error::custom("u128 is not supported"))
-        }
+    /// Hint that the `Deserialize` type is expecting an `u128` value.
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let _ = visitor;
+        Err(Error::custom("u128 is not supported"))
     }
 
     /// Hint that the `Deserialize` type is expecting a `f32` value.
@@ -1367,20 +1359,20 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Signed(v), &self))
     }
 
-    serde_if_integer128! {
-        /// The input contains a `i128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let mut buf = [0u8; 58];
-            let mut writer = format::Buf::new(&mut buf);
-            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
-        }
+    /// The input contains a `i128`.
+    ///
+    /// The default implementation fails with a type error.
+    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        let mut buf = [0u8; 58];
+        let mut writer = format::Buf::new(&mut buf);
+        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
+        Err(Error::invalid_type(
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
     }
 
     /// The input contains a `u8`.
@@ -1429,20 +1421,20 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
     }
 
-    serde_if_integer128! {
-        /// The input contains a `u128`.
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default implementation fails with a type error.
-        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            let mut buf = [0u8; 57];
-            let mut writer = format::Buf::new(&mut buf);
-            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
-            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
-        }
+    /// The input contains a `u128`.
+    ///
+    /// The default implementation fails with a type error.
+    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        let mut buf = [0u8; 57];
+        let mut writer = format::Buf::new(&mut buf);
+        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
+        Err(Error::invalid_type(
+            Unexpected::Other(writer.as_str()),
+            &self,
+        ))
     }
 
     /// The input contains an `f32`.
@@ -1478,7 +1470,7 @@ pub trait Visitor<'de>: Sized {
     where
         E: Error,
     {
-        self.visit_str(utf8::encode(v).as_str())
+        self.visit_str(v.encode_utf8(&mut [0u8; 4]))
     }
 
     /// The input contains a string. The lifetime of the string is ephemeral and
@@ -1533,6 +1525,7 @@ pub trait Visitor<'de>: Sized {
     /// `String`.
     #[inline]
     #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1555,7 +1548,6 @@ pub trait Visitor<'de>: Sized {
     where
         E: Error,
     {
-        let _ = v;
         Err(Error::invalid_type(Unexpected::Bytes(v), &self))
     }
 
@@ -1592,6 +1584,7 @@ pub trait Visitor<'de>: Sized {
     /// The default implementation forwards to `visit_bytes` and then drops the
     /// `Vec<u8>`.
     #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1742,9 +1735,9 @@ pub trait SeqAccess<'de> {
     }
 }
 
-impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
+impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
 where
-    A: SeqAccess<'de>,
+    A: ?Sized + SeqAccess<'de>,
 {
     type Error = A::Error;
 
@@ -1895,9 +1888,9 @@ pub trait MapAccess<'de> {
     }
 }
 
-impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
+impl<'de, 'a, A> MapAccess<'de> for &'a mut A
 where
-    A: MapAccess<'de>,
+    A: ?Sized + MapAccess<'de>,
 {
     type Error = A::Error;
 
@@ -2285,10 +2278,10 @@ impl Display for OneOf {
             1 => write!(formatter, "`{}`", self.names[0]),
             2 => write!(formatter, "`{}` or `{}`", self.names[0], self.names[1]),
             _ => {
-                tri!(write!(formatter, "one of "));
+                tri!(formatter.write_str("one of "));
                 for (i, alt) in self.names.iter().enumerate() {
                     if i > 0 {
-                        tri!(write!(formatter, ", "));
+                        tri!(formatter.write_str(", "));
                     }
                     tri!(write!(formatter, "`{}`", alt));
                 }
@@ -2297,3 +2290,36 @@ impl Display for OneOf {
         }
     }
 }
+
+struct WithDecimalPoint(f64);
+
+impl Display for WithDecimalPoint {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        struct LookForDecimalPoint<'f, 'a> {
+            formatter: &'f mut fmt::Formatter<'a>,
+            has_decimal_point: bool,
+        }
+
+        impl<'f, 'a> fmt::Write for LookForDecimalPoint<'f, 'a> {
+            fn write_str(&mut self, fragment: &str) -> fmt::Result {
+                self.has_decimal_point |= fragment.contains('.');
+                self.formatter.write_str(fragment)
+            }
+
+            fn write_char(&mut self, ch: char) -> fmt::Result {
+                self.has_decimal_point |= ch == '.';
+                self.formatter.write_char(ch)
+            }
+        }
+
+        let mut writer = LookForDecimalPoint {
+            formatter,
+            has_decimal_point: false,
+        };
+        tri!(write!(writer, "{}", self.0));
+        if !writer.has_decimal_point {
+            tri!(formatter.write_str(".0"));
+        }
+        Ok(())
+    }
+}

serde/src/de/utf8.rs

@@ -1,46 +0,0 @@
-use crate::lib::*;
-
-const TAG_CONT: u8 = 0b1000_0000;
-const TAG_TWO_B: u8 = 0b1100_0000;
-const TAG_THREE_B: u8 = 0b1110_0000;
-const TAG_FOUR_B: u8 = 0b1111_0000;
-const MAX_ONE_B: u32 = 0x80;
-const MAX_TWO_B: u32 = 0x800;
-const MAX_THREE_B: u32 = 0x10000;
-
-#[inline]
-pub fn encode(c: char) -> Encode {
-    let code = c as u32;
-    let mut buf = [0; 4];
-    let pos = if code < MAX_ONE_B {
-        buf[3] = code as u8;
-        3
-    } else if code < MAX_TWO_B {
-        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        2
-    } else if code < MAX_THREE_B {
-        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
-        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        1
-    } else {
-        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
-        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
-        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        0
-    };
-    Encode { buf, pos }
-}
-
-pub struct Encode {
-    buf: [u8; 4],
-    pos: usize,
-}
-
-impl Encode {
-    pub fn as_str(&self) -> &str {
-        str::from_utf8(&self.buf[self.pos..]).unwrap()
-    }
-}

serde/src/de/value.rs

@@ -112,6 +112,7 @@ impl Debug for Error {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl error::Error for Error {
     fn description(&self) -> &str {
         &self.err
@@ -184,12 +185,14 @@ impl<E> Debug for UnitDeserializer<E> {
 
 /// A deserializer that cannot be instantiated.
 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 pub struct NeverDeserializer<E> {
     never: !,
     marker: PhantomData<E>,
 }
 
 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 impl<'de, E> IntoDeserializer<'de, E> for !
 where
     E: de::Error,
@@ -292,20 +295,17 @@ primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
 primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
 primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
 primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
+primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
 primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
 primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
 primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
 primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
+primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
 primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
 primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
 
-serde_if_integer128! {
-    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-}
-
 /// A deserializer holding a `u32`.
 pub struct U32Deserializer<E> {
     value: u32,
@@ -565,6 +565,7 @@ impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
 
 /// A deserializer holding a `String`.
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 pub struct StringDeserializer<E> {
     value: String,
     marker: PhantomData<E>,
@@ -581,6 +582,7 @@ impl<E> Clone for StringDeserializer<E> {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, E> IntoDeserializer<'de, E> for String
 where
     E: de::Error,
@@ -668,6 +670,7 @@ impl<E> Debug for StringDeserializer<E> {
 
 /// A deserializer holding a `Cow<str>`.
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 pub struct CowStrDeserializer<'a, E> {
     value: Cow<'a, str>,
     marker: PhantomData<E>,
@@ -684,6 +687,7 @@ impl<'a, E> Clone for CowStrDeserializer<'a, E> {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
 where
     E: de::Error,
@@ -979,7 +983,7 @@ struct ExpectedInSeq(usize);
 impl Expected for ExpectedInSeq {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         if self.0 == 1 {
-            write!(formatter, "1 element in sequence")
+            formatter.write_str("1 element in sequence")
         } else {
             write!(formatter, "{} elements in sequence", self.0)
         }
@@ -1002,6 +1006,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
 where
     T: IntoDeserializer<'de, E>,
@@ -1015,6 +1020,7 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
 where
     T: IntoDeserializer<'de, E> + Eq + Ord,
@@ -1028,6 +1034,7 @@ where
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
 where
     T: IntoDeserializer<'de, E> + Eq + Hash,
@@ -1404,7 +1411,7 @@ struct ExpectedInMap(usize);
 impl Expected for ExpectedInMap {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         if self.0 == 1 {
-            write!(formatter, "1 element in map")
+            formatter.write_str("1 element in map")
         } else {
             write!(formatter, "{} elements in map", self.0)
         }
@@ -1414,6 +1421,7 @@ impl Expected for ExpectedInMap {
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
 where
     K: IntoDeserializer<'de, E> + Eq + Ord,
@@ -1428,6 +1436,7 @@ where
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
 where
     K: IntoDeserializer<'de, E> + Eq + Hash,

serde/src/integer128.rs

@@ -1,82 +1,9 @@
-/// Conditional compilation depending on whether Serde is built with support for
-/// 128-bit integers.
-///
-/// Data formats that wish to support Rust compiler versions older than 1.26
-/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
-/// of their Serializer and Deserializer behind this macro.
-///
-/// Data formats that require a minimum Rust compiler version of at least 1.26,
-/// 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.
-///
-/// ```edition2021
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// use serde::{serde_if_integer128, Serializer};
-///
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
-///         /* ... */
-/// #         unimplemented!()
-///     }
-///
-///     /* ... */
-///
-///     serde_if_integer128! {
-///         fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///
-///         fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-///             /* ... */
-/// #             unimplemented!()
-///         }
-///     }
-/// #
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant seq
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// When Serde is built with support for 128-bit integers, this macro expands
-/// transparently into just the input tokens.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {
-///         $($tt)*
-///     };
-/// }
-/// ```
-///
-/// When built without support for 128-bit integers, this macro expands to
-/// nothing.
-///
-/// ```edition2021
-/// macro_rules! serde_if_integer128 {
-///     ($($tt:tt)*) => {};
-/// }
-/// ```
-#[cfg(not(no_integer128))]
+// No longer used. Old versions of serde used this macro for supporting targets
+// that did not yet have 128-bit integer support.
 #[macro_export]
+#[doc(hidden)]
 macro_rules! serde_if_integer128 {
     ($($tt:tt)*) => {
         $($tt)*
     };
 }
-
-#[cfg(no_integer128)]
-#[macro_export]
-#[doc(hidden)]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {};
-}

serde/src/lib.rs

@@ -63,6 +63,7 @@
 //!   and from DynamoDB.
 //! - [Hjson], a syntax extension to JSON designed around human reading and
 //!   editing. *(deserialization only)*
+//! - [CSV], Comma-separated values is a tabular text file format.
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Postcard]: https://github.com/jamesmunns/postcard
@@ -89,13 +90,16 @@
 //! [DynamoDB Items]: https://docs.rs/serde_dynamo
 //! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
 //! [Hjson]: https://github.com/Canop/deser-hjson
+//! [CSV]: https://docs.rs/csv
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.184")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.199")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
+// Show which crate feature enables conditionally compiled APIs in documentation.
+#![cfg_attr(doc_cfg, feature(doc_cfg))]
 // Unstable functionality only if the user asks for it. For tracking and
 // discussion of these features please refer to this issue:
 //
@@ -114,11 +118,11 @@
     // integer and float ser/de requires these sorts of casts
     clippy::cast_possible_truncation,
     clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
     clippy::cast_sign_loss,
     // things are often more readable this way
     clippy::cast_lossless,
     clippy::module_name_repetitions,
-    clippy::option_if_let_else,
     clippy::single_match_else,
     clippy::type_complexity,
     clippy::use_self,
@@ -127,6 +131,7 @@
     clippy::derive_partial_eq_without_eq,
     clippy::enum_glob_use,
     clippy::explicit_auto_deref,
+    clippy::incompatible_msrv,
     clippy::let_underscore_untyped,
     clippy::map_err_ignore,
     clippy::new_without_default,
@@ -166,22 +171,25 @@ mod lib {
         pub use std::*;
     }
 
-    pub use self::core::{cmp, iter, mem, num, ptr, slice, str};
     pub use self::core::{f32, f64};
     pub use self::core::{i16, i32, i64, i8, isize};
+    pub use self::core::{iter, num, ptr, str};
     pub use self::core::{u16, u32, u64, u8, usize};
 
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    pub use self::core::{cmp, mem, slice};
+
     pub use self::core::cell::{Cell, RefCell};
-    pub use self::core::clone::{self, Clone};
+    pub use self::core::clone;
     pub use self::core::cmp::Reverse;
-    pub use self::core::convert::{self, From, Into};
-    pub use self::core::default::{self, Default};
-    pub use self::core::fmt::{self, Debug, Display};
+    pub use self::core::convert;
+    pub use self::core::default;
+    pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
     pub use self::core::marker::{self, PhantomData};
     pub use self::core::num::Wrapping;
     pub use self::core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
-    pub use self::core::option::{self, Option};
-    pub use self::core::result::{self, Result};
+    pub use self::core::option;
+    pub use self::core::result;
     pub use self::core::time::Duration;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
@@ -267,6 +275,9 @@ mod lib {
     pub use std::sync::atomic::{AtomicI64, AtomicU64};
     #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
     pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
+
+    #[cfg(not(no_core_num_saturating))]
+    pub use self::core::num::Saturating;
 }
 
 // None of this crate's error handling needs the `From::from` error conversion
@@ -319,6 +330,7 @@ extern crate serde_derive;
 
 /// Derive macro available if serde is built with `features = ["derive"]`.
 #[cfg(feature = "serde_derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub use serde_derive::{Deserialize, Serialize};
 
 #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]

serde/src/macros.rs

@@ -123,7 +123,7 @@ macro_rules! forward_to_deserialize_any {
 macro_rules! forward_to_deserialize_any_method {
     ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
         #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
+        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, <Self as $crate::de::Deserializer<$l>>::Error>
         where
             $v: $crate::de::Visitor<$l>,
         {
@@ -154,9 +154,7 @@ macro_rules! forward_to_deserialize_any_helper {
         forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
     };
     (i128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
-        }
+        forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
     };
     (u8<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
@@ -171,9 +169,7 @@ macro_rules! forward_to_deserialize_any_helper {
         forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
     };
     (u128<$l:tt, $v:ident>) => {
-        serde_if_integer128! {
-            forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
-        }
+        forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
     };
     (f32<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}

serde/src/private/de.rs

@@ -313,6 +313,8 @@ mod content {
         }
     }
 
+    /// Used to capture data in [`Content`] from other deserializers.
+    /// Cannot capture externally tagged enums, `i128` and `u128`.
     struct ContentVisitor<'de> {
         value: PhantomData<Content<'de>>,
     }
@@ -528,6 +530,8 @@ mod content {
         Content(Content<'de>),
     }
 
+    /// Serves as a seed for deserializing a key of internally tagged enum.
+    /// Cannot capture externally tagged enums, `i128` and `u128`.
     struct TagOrContentVisitor<'de> {
         name: &'static str,
         value: PhantomData<TagOrContent<'de>>,
@@ -814,6 +818,9 @@ mod content {
 
     /// Used by generated code to deserialize an internally tagged enum.
     ///
+    /// Captures map or sequence from the original deserializer and searches
+    /// a tag in it (in case of sequence, tag is the first element of sequence).
+    ///
     /// Not public API.
     pub struct TaggedContentVisitor<T> {
         tag_name: &'static str,

serde/src/private/doc.rs

@@ -56,7 +56,10 @@ macro_rules! __serialize_unimplemented {
 #[macro_export]
 macro_rules! __serialize_unimplemented_method {
     ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
+        fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error>
+        where
+            $($t: ?Sized + $crate::Serialize,)*
+        {
             unimplemented!()
         }
     };

serde/src/private/ser.rs

@@ -174,9 +174,9 @@ where
         Err(self.bad_type(Unsupported::Optional))
     }
 
-    fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+    fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         Err(self.bad_type(Unsupported::Optional))
     }
@@ -205,18 +205,18 @@ where
         map.end()
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         _: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _: &'static str,
         _: u32,
@@ -224,7 +224,7 @@ where
         inner_value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let mut map = tri!(self.delegate.serialize_map(Some(2)));
         tri!(map.serialize_entry(self.tag, self.variant_name));
@@ -327,9 +327,9 @@ where
     }
 
     #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+    fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Display,
+        T: ?Sized + Display,
     {
         Err(self.bad_type(Unsupported::String))
     }
@@ -364,9 +364,9 @@ mod content {
         type Ok = M::Ok;
         type Error = M::Error;
 
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error>
+        fn serialize_field<T>(&mut self, value: &T) -> Result<(), M::Error>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
             self.fields.push(value);
@@ -404,13 +404,9 @@ mod content {
         type Ok = M::Ok;
         type Error = M::Error;
 
-        fn serialize_field<T: ?Sized>(
-            &mut self,
-            key: &'static str,
-            value: &T,
-        ) -> Result<(), M::Error>
+        fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), M::Error>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
             self.fields.push((key, value));
@@ -635,9 +631,9 @@ mod content {
             Ok(Content::None)
         }
 
-        fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
+        fn serialize_some<T>(self, value: &T) -> Result<Content, E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             Ok(Content::Some(Box::new(tri!(value.serialize(self)))))
         }
@@ -659,13 +655,9 @@ mod content {
             Ok(Content::UnitVariant(name, variant_index, variant))
         }
 
-        fn serialize_newtype_struct<T: ?Sized>(
-            self,
-            name: &'static str,
-            value: &T,
-        ) -> Result<Content, E>
+        fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Content, E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             Ok(Content::NewtypeStruct(
                 name,
@@ -673,7 +665,7 @@ mod content {
             ))
         }
 
-        fn serialize_newtype_variant<T: ?Sized>(
+        fn serialize_newtype_variant<T>(
             self,
             name: &'static str,
             variant_index: u32,
@@ -681,7 +673,7 @@ mod content {
             value: &T,
         ) -> Result<Content, E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             Ok(Content::NewtypeVariant(
                 name,
@@ -782,9 +774,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+        fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.elements.push(value);
@@ -808,9 +800,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+        fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.elements.push(value);
@@ -835,9 +827,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+        fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.fields.push(value);
@@ -864,9 +856,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+        fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.fields.push(value);
@@ -896,18 +888,18 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
+        fn serialize_key<T>(&mut self, key: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let key = tri!(key.serialize(ContentSerializer::<E>::new()));
             self.key = Some(key);
             Ok(())
         }
 
-        fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
+        fn serialize_value<T>(&mut self, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let key = self
                 .key
@@ -922,10 +914,10 @@ mod content {
             Ok(Content::Map(self.entries))
         }
 
-        fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
+        fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), E>
         where
-            K: Serialize,
-            V: Serialize,
+            K: ?Sized + Serialize,
+            V: ?Sized + Serialize,
         {
             let key = tri!(key.serialize(ContentSerializer::<E>::new()));
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
@@ -947,9 +939,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+        fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.fields.push((key, value));
@@ -976,9 +968,9 @@ mod content {
         type Ok = Content;
         type Error = E;
 
-        fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
+        fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
         where
-            T: Serialize,
+            T: ?Sized + Serialize,
         {
             let value = tri!(value.serialize(ContentSerializer::<E>::new()));
             self.fields.push((key, value));
@@ -1088,9 +1080,9 @@ where
         Ok(())
     }
 
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         value.serialize(self)
     }
@@ -1112,18 +1104,18 @@ where
         Err(Self::bad_type(Unsupported::Enum))
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         _: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _: &'static str,
         _: u32,
@@ -1131,7 +1123,7 @@ where
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         tri!(self.0.serialize_key(variant));
         self.0.serialize_value(value)
@@ -1202,28 +1194,24 @@ where
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         self.0.serialize_key(key)
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         self.0.serialize_value(value)
     }
 
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
     where
-        K: Serialize,
-        V: Serialize,
+        K: ?Sized + Serialize,
+        V: ?Sized + Serialize,
     {
         self.0.serialize_entry(key, value)
     }
@@ -1244,13 +1232,9 @@ where
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         self.0.serialize_entry(key, value)
     }
@@ -1289,9 +1273,9 @@ where
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
         self.fields.push(value);
@@ -1335,13 +1319,9 @@ where
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
         self.fields.push((key, value));

serde/src/ser/fmt.rs

@@ -52,10 +52,12 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         serialize_i16: i16,
         serialize_i32: i32,
         serialize_i64: i64,
+        serialize_i128: i128,
         serialize_u8: u8,
         serialize_u16: u16,
         serialize_u32: u32,
         serialize_u64: u64,
+        serialize_u128: u128,
         serialize_f32: f32,
         serialize_f64: f64,
         serialize_char: char,
@@ -63,13 +65,6 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         serialize_unit_struct: &'static str,
     }
 
-    serde_if_integer128! {
-        fmt_primitives! {
-            serialize_i128: i128,
-            serialize_u128: u128,
-        }
-    }
-
     fn serialize_unit_variant(
         self,
         _name: &'static str,
@@ -79,9 +74,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         Display::fmt(variant, self)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> fmt::Result
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         Serialize::serialize(value, self)
     }
@@ -94,9 +89,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         Err(fmt::Error)
     }
 
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
+    fn serialize_some<T>(self, _value: &T) -> fmt::Result
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         Err(fmt::Error)
     }
@@ -105,7 +100,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         Err(fmt::Error)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _name: &'static str,
         _variant_index: u32,
@@ -113,7 +108,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         _value: &T,
     ) -> fmt::Result
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         Err(fmt::Error)
     }
@@ -166,9 +161,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
         Err(fmt::Error)
     }
 
-    fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
+    fn collect_str<T>(self, value: &T) -> fmt::Result
     where
-        T: Display,
+        T: ?Sized + Display,
     {
         Display::fmt(value, self)
     }

serde/src/ser/impls.rs

@@ -24,20 +24,17 @@ primitive_impl!(i8, serialize_i8);
 primitive_impl!(i16, serialize_i16);
 primitive_impl!(i32, serialize_i32);
 primitive_impl!(i64, serialize_i64);
+primitive_impl!(i128, serialize_i128);
 primitive_impl!(usize, serialize_u64 as u64);
 primitive_impl!(u8, serialize_u8);
 primitive_impl!(u16, serialize_u16);
 primitive_impl!(u32, serialize_u32);
 primitive_impl!(u64, serialize_u64);
+primitive_impl!(u128, serialize_u128);
 primitive_impl!(f32, serialize_f32);
 primitive_impl!(f64, serialize_f64);
 primitive_impl!(char, serialize_char);
 
-serde_if_integer128! {
-    primitive_impl!(i128, serialize_i128);
-    primitive_impl!(u128, serialize_u128);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 impl Serialize for str {
@@ -51,6 +48,7 @@ impl Serialize for str {
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl Serialize for String {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -73,6 +71,7 @@ impl<'a> Serialize for fmt::Arguments<'a> {
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(any(feature = "std", not(no_core_cstr)))]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for CStr {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -84,6 +83,7 @@ impl Serialize for CStr {
 }
 
 #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
 impl Serialize for CString {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -114,7 +114,10 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-impl<T: ?Sized> Serialize for PhantomData<T> {
+impl<T> Serialize for PhantomData<T>
+where
+    T: ?Sized,
+{
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -182,9 +185,13 @@ where
     }
 }
 
-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(not(no_relaxed_trait_bounds))]
 macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
         impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
         where
             T: Serialize,
@@ -200,9 +207,13 @@ macro_rules! seq_impl {
     }
 }
 
-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+#[cfg(no_relaxed_trait_bounds)]
 macro_rules! seq_impl {
-    ($ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
         impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
         where
             T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
@@ -219,23 +230,41 @@ macro_rules! seq_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BinaryHeap<T: Ord>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BinaryHeap<T: Ord>
+}
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(BTreeSet<T: Ord>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BTreeSet<T: Ord>
+}
 
-#[cfg(feature = "std")]
-seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>);
+seq_impl! {
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    HashSet<T: Eq + Hash, H: BuildHasher>
+}
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(LinkedList<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    LinkedList<T>
+}
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(Vec<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    Vec<T>
+}
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(VecDeque<T>);
+seq_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    VecDeque<T>
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -342,6 +371,7 @@ impl Serialize for () {
 }
 
 #[cfg(feature = "unstable")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
 impl Serialize for ! {
     fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -397,9 +427,13 @@ tuple_impls! {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(any(feature = "std", feature = "alloc"), not(no_relaxed_trait_bounds)))]
+#[cfg(not(no_relaxed_trait_bounds))]
 macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
         impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
         where
             K: Serialize,
@@ -416,9 +450,13 @@ macro_rules! map_impl {
     }
 }
 
-#[cfg(all(any(feature = "std", feature = "alloc"), no_relaxed_trait_bounds))]
+#[cfg(no_relaxed_trait_bounds)]
 macro_rules! map_impl {
-    ($ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>) => {
+    (
+        $(#[$attr:meta])*
+        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
+    ) => {
+        $(#[$attr])*
         impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
         where
             K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
@@ -436,20 +474,26 @@ macro_rules! map_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-map_impl!(BTreeMap<K: Ord, V>);
+map_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    BTreeMap<K: Ord, V>
+}
 
-#[cfg(feature = "std")]
-map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
+map_impl! {
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    HashMap<K: Eq + Hash, V, H: BuildHasher>
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! deref_impl {
     (
-        $(#[doc = $doc:tt])*
+        $(#[$attr:meta])*
         <$($desc:tt)+
     ) => {
-        $(#[doc = $doc])*
+        $(#[$attr])*
         impl <$($desc)+ {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -462,13 +506,20 @@ macro_rules! deref_impl {
     };
 }
 
-deref_impl!(<'a, T: ?Sized> Serialize for &'a T where T: Serialize);
-deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
+deref_impl! {
+    <'a, T> Serialize for &'a T where T: ?Sized + Serialize
+}
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
+deref_impl! {
+    <'a, T> Serialize for &'a mut T where T: ?Sized + Serialize
+}
+
+deref_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    <T> Serialize for Box<T> where T: ?Sized + Serialize
+}
 
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
 deref_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -478,10 +529,11 @@ deref_impl! {
     /// repeated data.
     ///
     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Rc<T> where T: Serialize
+    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
+    <T> Serialize for Rc<T> where T: ?Sized + Serialize
 }
 
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
 deref_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -491,11 +543,16 @@ deref_impl! {
     /// repeated data.
     ///
     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    <T: ?Sized> Serialize for Arc<T> where T: Serialize
+    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
+    <T> Serialize for Arc<T> where T: ?Sized + Serialize
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
+deref_impl! {
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
+    <'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize + ToOwned
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -503,9 +560,13 @@ deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwne
 ///
 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for RcWeak<T>
+#[cfg_attr(
+    doc_cfg,
+    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
+)]
+impl<T> Serialize for RcWeak<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -519,9 +580,13 @@ where
 ///
 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-impl<T: ?Sized> Serialize for ArcWeak<T>
+#[cfg_attr(
+    doc_cfg,
+    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
+)]
+impl<T> Serialize for ArcWeak<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -553,6 +618,7 @@ nonzero_integers! {
     NonZeroU16,
     NonZeroU32,
     NonZeroU64,
+    NonZeroU128,
     NonZeroUsize,
 }
 
@@ -562,22 +628,10 @@ nonzero_integers! {
     NonZeroI16,
     NonZeroI32,
     NonZeroI64,
+    NonZeroI128,
     NonZeroIsize,
 }
 
-// Currently 128-bit integers do not work on Emscripten targets so we need an
-// additional `#[cfg]`
-serde_if_integer128! {
-    nonzero_integers! {
-        NonZeroU128,
-    }
-
-    #[cfg(not(no_num_nonzero_signed))]
-    nonzero_integers! {
-        NonZeroI128,
-    }
-}
-
 impl<T> Serialize for Cell<T>
 where
     T: Serialize + Copy,
@@ -590,9 +644,9 @@ where
     }
 }
 
-impl<T: ?Sized> Serialize for RefCell<T>
+impl<T> Serialize for RefCell<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -606,9 +660,10 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for Mutex<T>
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+impl<T> Serialize for Mutex<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -622,9 +677,10 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<T: ?Sized> Serialize for RwLock<T>
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+impl<T> Serialize for RwLock<T>
 where
-    T: Serialize,
+    T: ?Sized + Serialize,
 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -675,6 +731,7 @@ impl Serialize for Duration {
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for SystemTime {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -719,6 +776,7 @@ macro_rules! serialize_display_bounded_length {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::IpAddr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -789,6 +847,7 @@ fn test_format_u8() {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::Ipv4Addr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -813,6 +872,7 @@ impl Serialize for net::Ipv4Addr {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::Ipv6Addr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -829,6 +889,7 @@ impl Serialize for net::Ipv6Addr {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddr {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -853,6 +914,7 @@ impl Serialize for net::SocketAddr {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddrV4 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -869,6 +931,7 @@ impl Serialize for net::SocketAddrV4 {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for net::SocketAddrV6 {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -890,6 +953,7 @@ impl Serialize for net::SocketAddrV6 {
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for Path {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -903,6 +967,7 @@ impl Serialize for Path {
 }
 
 #[cfg(feature = "std")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
 impl Serialize for PathBuf {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -913,6 +978,7 @@ impl Serialize for PathBuf {
 }
 
 #[cfg(all(feature = "std", any(unix, windows)))]
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
 impl Serialize for OsStr {
     #[cfg(unix)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -935,6 +1001,7 @@ impl Serialize for OsStr {
 }
 
 #[cfg(all(feature = "std", any(unix, windows)))]
+#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
 impl Serialize for OsString {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -959,6 +1026,20 @@ where
     }
 }
 
+#[cfg(not(no_core_num_saturating))]
+impl<T> Serialize for Saturating<T>
+where
+    T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
 impl<T> Serialize for Reverse<T>
 where
     T: Serialize,
@@ -979,6 +1060,7 @@ macro_rules! atomic_impl {
     ($($ty:ident $size:expr)*) => {
         $(
             #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
+            #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", target_has_atomic = $size))))]
             impl Serialize for $ty {
                 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
                 where

serde/src/ser/impossible.rs

@@ -72,9 +72,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = value;
         match self.void {}
@@ -92,9 +92,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = value;
         match self.void {}
@@ -112,9 +112,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = value;
         match self.void {}
@@ -132,9 +132,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = value;
         match self.void {}
@@ -152,17 +152,17 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = key;
         match self.void {}
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = value;
         match self.void {}
@@ -180,9 +180,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = key;
         let _ = value;
@@ -201,9 +201,9 @@ where
     type Ok = Ok;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
     where
-        T: Serialize,
+        T: ?Sized + Serialize,
     {
         let _ = key;
         let _ = value;

serde/src/ser/mod.rs

@@ -61,8 +61,8 @@
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -488,30 +488,27 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
 
-    serde_if_integer128! {
-        /// Serialize an `i128` value.
-        ///
-        /// ```edition2021
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for i128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_i128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("i128 is not supported"))
-        }
+    /// Serialize an `i128` value.
+    ///
+    /// ```edition2021
+    /// # use serde::Serializer;
+    /// #
+    /// # serde::__private_serialize!();
+    /// #
+    /// impl Serialize for i128 {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         serializer.serialize_i128(*self)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+        let _ = v;
+        Err(Error::custom("i128 is not supported"))
     }
 
     /// Serialize a `u8` value.
@@ -598,30 +595,27 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
 
-    serde_if_integer128! {
-        /// Serialize a `u128` value.
-        ///
-        /// ```edition2021
-        /// # use serde::Serializer;
-        /// #
-        /// # serde::__private_serialize!();
-        /// #
-        /// impl Serialize for u128 {
-        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        ///     where
-        ///         S: Serializer,
-        ///     {
-        ///         serializer.serialize_u128(*self)
-        ///     }
-        /// }
-        /// ```
-        ///
-        /// This method is available only on Rust compiler versions >=1.26. The
-        /// default behavior unconditionally returns an error.
-        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-            let _ = v;
-            Err(Error::custom("u128 is not supported"))
-        }
+    /// Serialize a `u128` value.
+    ///
+    /// ```edition2021
+    /// # use serde::Serializer;
+    /// #
+    /// # serde::__private_serialize!();
+    /// #
+    /// impl Serialize for u128 {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         serializer.serialize_u128(*self)
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default behavior unconditionally returns an error.
+    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+        let _ = v;
+        Err(Error::custom("u128 is not supported"))
     }
 
     /// Serialize an `f32` value.
@@ -802,9 +796,9 @@ pub trait Serializer: Sized {
     /// ```
     ///
     /// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Serialize a `()` value.
     ///
@@ -897,13 +891,13 @@ pub trait Serializer: Sized {
     ///     }
     /// }
     /// ```
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         name: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
     ///
@@ -931,7 +925,7 @@ pub trait Serializer: Sized {
     ///     }
     /// }
     /// ```
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         name: &'static str,
         variant_index: u32,
@@ -939,7 +933,7 @@ pub trait Serializer: Sized {
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Begin to serialize a variably sized sequence. This call must be
     /// followed by zero or more calls to `serialize_element`, then a call to
@@ -1176,7 +1170,8 @@ pub trait Serializer: Sized {
     /// then a call to `end`.
     ///
     /// The `name` is the name of the struct and the `len` is the number of
-    /// data fields that will be serialized.
+    /// data fields that will be serialized. `len` does not include fields
+    /// which are skipped with [`SerializeStruct::skip_field`].
     ///
     /// ```edition2021
     /// use serde::ser::{Serialize, SerializeStruct, Serializer};
@@ -1213,6 +1208,8 @@ pub trait Serializer: Sized {
     /// The `name` is the name of the enum, the `variant_index` is the index of
     /// 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.
+    /// `len` does not include fields which are skipped with
+    /// [`SerializeStructVariant::skip_field`].
     ///
     /// ```edition2021
     /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
@@ -1352,9 +1349,9 @@ pub trait Serializer: Sized {
     /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
     /// [`serialize_str`]: #tymethod.serialize_str
     #[cfg(any(feature = "std", feature = "alloc"))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Display,
+        T: ?Sized + Display,
     {
         self.serialize_str(&value.to_string())
     }
@@ -1385,9 +1382,9 @@ pub trait Serializer: Sized {
     /// }
     /// ```
     #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Display;
+        T: ?Sized + Display;
 
     /// Determine whether `Serialize` implementations should serialize in
     /// human-readable form.
@@ -1499,9 +1496,9 @@ pub trait SerializeSeq {
     type Error: Error;
 
     /// Serialize a sequence element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Finish serializing a sequence.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1599,9 +1596,9 @@ pub trait SerializeTuple {
     type Error: Error;
 
     /// Serialize a tuple element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Finish serializing a tuple.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1644,9 +1641,9 @@ pub trait SerializeTupleStruct {
     type Error: Error;
 
     /// Serialize a tuple struct field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Finish serializing a tuple struct.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1702,9 +1699,9 @@ pub trait SerializeTupleVariant {
     type Error: Error;
 
     /// Serialize a tuple variant field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Finish serializing a tuple variant.
     fn end(self) -> Result<Self::Ok, Self::Error>;
@@ -1773,9 +1770,9 @@ pub trait SerializeMap {
     /// `serialize_entry` instead as it may be implemented more efficiently in
     /// some formats compared to a pair of calls to `serialize_key` and
     /// `serialize_value`.
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Serialize a map value.
     ///
@@ -1783,9 +1780,9 @@ pub trait SerializeMap {
     ///
     /// Calling `serialize_value` before `serialize_key` is incorrect and is
     /// allowed to panic or produce bogus results.
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Serialize a map entry consisting of a key and a value.
     ///
@@ -1804,14 +1801,10 @@ pub trait SerializeMap {
     /// [`Serialize`]: ../trait.Serialize.html
     /// [`serialize_key`]: #tymethod.serialize_key
     /// [`serialize_value`]: #tymethod.serialize_value
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
     where
-        K: Serialize,
-        V: Serialize,
+        K: ?Sized + Serialize,
+        V: ?Sized + Serialize,
     {
         tri!(self.serialize_key(key));
         self.serialize_value(value)
@@ -1862,15 +1855,13 @@ pub trait SerializeStruct {
     type Error: Error;
 
     /// Serialize a struct field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Indicate that a struct field has been skipped.
+    ///
+    /// The default implementation does nothing.
     #[inline]
     fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
         let _ = key;
@@ -1928,15 +1919,13 @@ pub trait SerializeStructVariant {
     type Error: Error;
 
     /// Serialize a struct variant field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     where
-        T: Serialize;
+        T: ?Sized + Serialize;
 
     /// Indicate that a struct variant field has been skipped.
+    ///
+    /// The default implementation does nothing.
     #[inline]
     fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
         let _ = key;

serde_derive/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "serde_derive"
-version = "1.0.184" # remember to update html_root_url
+version = "1.0.199"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 categories = ["no-std", "no-std::no-alloc"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
 documentation = "https://serde.rs/derive.html"
+edition = "2015"
 homepage = "https://serde.rs"
 keywords = ["serde", "serialization", "no_std", "derive"]
 license = "MIT OR Apache-2.0"
@@ -21,9 +22,9 @@ name = "serde_derive"
 proc-macro = true
 
 [dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = "2.0.28"
+proc-macro2 = { workspace = true, features = ["proc-macro"] }
+quote = { workspace = true, features = ["proc-macro"] }
+syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing", "proc-macro"] }
 
 [dev-dependencies]
 serde = { version = "1", path = "../serde" }

serde_derive/src/bound.rs

@@ -144,6 +144,7 @@ pub fn with_bound(
 
         fn visit_type(&mut self, ty: &'ast syn::Type) {
             match ty {
+                #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 syn::Type::Array(ty) => self.visit_type(&ty.elem),
                 syn::Type::BareFn(ty) => {
                     for arg in &ty.inputs {
@@ -181,7 +182,6 @@ pub fn with_bound(
 
                 syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
 
-                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 _ => {}
             }
         }
@@ -196,16 +196,13 @@ pub fn with_bound(
                 syn::PathArguments::AngleBracketed(arguments) => {
                     for arg in &arguments.args {
                         match arg {
+                            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                             syn::GenericArgument::Type(arg) => self.visit_type(arg),
                             syn::GenericArgument::AssocType(arg) => self.visit_type(&arg.ty),
                             syn::GenericArgument::Lifetime(_)
                             | syn::GenericArgument::Const(_)
                             | syn::GenericArgument::AssocConst(_)
                             | syn::GenericArgument::Constraint(_) => {}
-                            #[cfg_attr(
-                                all(test, exhaustive),
-                                deny(non_exhaustive_omitted_patterns)
-                            )]
                             _ => {}
                         }
                     }
@@ -228,9 +225,9 @@ pub fn with_bound(
 
         fn visit_type_param_bound(&mut self, bound: &'ast syn::TypeParamBound) {
             match bound {
+                #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 syn::TypeParamBound::Trait(bound) => self.visit_path(&bound.path),
                 syn::TypeParamBound::Lifetime(_) | syn::TypeParamBound::Verbatim(_) => {}
-                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                 _ => {}
             }
         }

serde_derive/src/de.rs

@@ -6,8 +6,6 @@ use proc_macro2::{Literal, Span, TokenStream};
 use quote::{quote, quote_spanned, ToTokens};
 use std::collections::BTreeSet;
 use std::ptr;
-#[cfg(precompiled)]
-use std::sync::atomic::Ordering;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{parse_quote, Ident, Index, Member};
@@ -301,11 +299,6 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
 
 #[cfg(feature = "deserialize_in_place")]
 fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<Stmts> {
-    #[cfg(precompiled)]
-    if !crate::DESERIALIZE_IN_PLACE.load(Ordering::Relaxed) {
-        return None;
-    }
-
     // Only remote derives have getters, and we do not generate
     // deserialize_in_place for remote derives.
     assert!(!params.has_getter);
@@ -1744,7 +1737,6 @@ fn deserialize_untagged_enum_after(
                 quote!(__deserializer),
             ))
         });
-    let attempts = first_attempt.into_iter().chain(attempts);
     // TODO this message could be better by saving the errors from the failed
     // attempts. The heuristic used by TOML was to count the number of fields
     // processed before an error, and use the error that happened after the
@@ -1757,10 +1749,23 @@ fn deserialize_untagged_enum_after(
     );
     let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
 
+    // Ignore any error associated with non-untagged deserialization so that we
+    // can fall through to the untagged variants. This may be infallible so we
+    // need to provide the error type.
+    let first_attempt = first_attempt.map(|expr| {
+        quote! {
+            if let _serde::__private::Result::<_, __D::Error>::Ok(__ok) = (|| #expr)() {
+                return _serde::__private::Ok(__ok);
+            }
+        }
+    });
+
     quote_block! {
         let __content = <_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)?;
         let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
 
+        #first_attempt
+
         #(
             if let _serde::__private::Ok(__ok) = #attempts {
                 return _serde::__private::Ok(__ok);
@@ -1835,7 +1840,7 @@ fn deserialize_internally_tagged_variant(
             let this_value = &params.this_value;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
+            let default = variant.fields.first().map(|field| {
                 let default = Expr(expr_is_missing(field, cattrs));
                 quote!((#default))
             });
@@ -1880,7 +1885,7 @@ fn deserialize_untagged_variant(
             let this_value = &params.this_value;
             let type_name = params.type_name();
             let variant_name = variant.ident.to_string();
-            let default = variant.fields.get(0).map(|field| {
+            let default = variant.fields.first().map(|field| {
                 let default = Expr(expr_is_missing(field, cattrs));
                 quote!((#default))
             });

serde_derive/src/internals/attr.rs

@@ -1794,6 +1794,7 @@ fn borrowable_lifetimes(
 
 fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
     match ty {
+        #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
         syn::Type::Slice(ty) => {
             collect_lifetimes(&ty.elem, out);
         }
@@ -1829,7 +1830,10 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
                             syn::GenericArgument::AssocType(binding) => {
                                 collect_lifetimes(&binding.ty, out);
                             }
-                            _ => {}
+                            syn::GenericArgument::Const(_)
+                            | syn::GenericArgument::AssocConst(_)
+                            | syn::GenericArgument::Constraint(_)
+                            | _ => {}
                         }
                     }
                 }
@@ -1851,7 +1855,6 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
         | syn::Type::Infer(_)
         | syn::Type::Verbatim(_) => {}
 
-        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
         _ => {}
     }
 }

serde_derive/src/internals/check.rs

@@ -318,6 +318,9 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     for variant in variants {
         match variant.style {
             Style::Struct => {
+                if variant.attrs.untagged() {
+                    continue;
+                }
                 for field in &variant.fields {
                     let check_ser =
                         !(field.attrs.skip_serializing() || variant.attrs.skip_serializing());

serde_derive/src/internals/receiver.rs

@@ -107,6 +107,7 @@ impl ReplaceReceiver<'_> {
 
     fn visit_type_mut_impl(&mut self, ty: &mut Type) {
         match ty {
+            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
             Type::Array(ty) => {
                 self.visit_type_mut(&mut ty.elem);
                 self.visit_expr_mut(&mut ty.len);
@@ -147,7 +148,6 @@ impl ReplaceReceiver<'_> {
 
             Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
 
-            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
             _ => {}
         }
     }
@@ -178,13 +178,13 @@ impl ReplaceReceiver<'_> {
             PathArguments::AngleBracketed(arguments) => {
                 for arg in &mut arguments.args {
                     match arg {
+                        #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                         GenericArgument::Type(arg) => self.visit_type_mut(arg),
                         GenericArgument::AssocType(arg) => self.visit_type_mut(&mut arg.ty),
                         GenericArgument::Lifetime(_)
                         | GenericArgument::Const(_)
                         | GenericArgument::AssocConst(_)
                         | GenericArgument::Constraint(_) => {}
-                        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                         _ => {}
                     }
                 }
@@ -207,9 +207,9 @@ impl ReplaceReceiver<'_> {
 
     fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
         match bound {
+            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
             TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
             TypeParamBound::Lifetime(_) | TypeParamBound::Verbatim(_) => {}
-            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
             _ => {}
         }
     }
@@ -228,6 +228,7 @@ impl ReplaceReceiver<'_> {
         if let Some(where_clause) = &mut generics.where_clause {
             for predicate in &mut where_clause.predicates {
                 match predicate {
+                    #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                     WherePredicate::Type(predicate) => {
                         self.visit_type_mut(&mut predicate.bounded_ty);
                         for bound in &mut predicate.bounds {
@@ -235,7 +236,6 @@ impl ReplaceReceiver<'_> {
                         }
                     }
                     WherePredicate::Lifetime(_) => {}
-                    #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
                     _ => {}
                 }
             }

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.184")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.199")]
 // Ignored clippy lints
 #![allow(
     // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
@@ -50,7 +50,6 @@
     clippy::match_wildcard_for_single_variants,
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
-    clippy::option_if_let_else,
     clippy::similar_names,
     clippy::single_match_else,
     clippy::struct_excessive_bools,
@@ -66,17 +65,11 @@ extern crate proc_macro2;
 extern crate quote;
 extern crate syn;
 
-#[cfg(not(precompiled))]
 extern crate proc_macro;
-#[cfg(precompiled)]
-extern crate proc_macro2 as proc_macro;
 
 mod internals;
 
 use proc_macro::TokenStream;
-#[cfg(precompiled)]
-use std::sync::atomic::AtomicBool;
-#[cfg(not(precompiled))]
 use syn::parse_macro_input;
 use syn::DeriveInput;
 
@@ -91,20 +84,7 @@ mod pretend;
 mod ser;
 mod this;
 
-#[cfg(precompiled)]
-macro_rules! parse_macro_input {
-    ($tokenstream:ident as $ty:ty) => {
-        match syn::parse2::<$ty>($tokenstream) {
-            Ok(data) => data,
-            Err(err) => return err.to_compile_error(),
-        }
-    };
-}
-
-#[cfg(precompiled)]
-pub static DESERIALIZE_IN_PLACE: AtomicBool = AtomicBool::new(false);
-
-#[cfg_attr(not(precompiled), proc_macro_derive(Serialize, attributes(serde)))]
+#[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
     ser::expand_derive_serialize(&mut input)
@@ -112,7 +92,7 @@ pub fn derive_serialize(input: TokenStream) -> TokenStream {
         .into()
 }
 
-#[cfg_attr(not(precompiled), proc_macro_derive(Deserialize, attributes(serde)))]
+#[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
     de::expand_derive_deserialize(&mut input)

serde_derive/src/pretend.rs

@@ -64,14 +64,14 @@ pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
 fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
     match &cont.data {
         Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
-        Data::Struct(Style::Struct, fields) => {
+        Data::Struct(Style::Struct | Style::Tuple | Style::Newtype, fields) => {
             if is_packed {
                 pretend_fields_used_struct_packed(cont, fields)
             } else {
                 pretend_fields_used_struct(cont, fields)
             }
         }
-        Data::Struct(_, _) => quote!(),
+        Data::Struct(Style::Unit, _) => quote!(),
     }
 }
 
@@ -115,13 +115,13 @@ fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStre
     let patterns = variants
         .iter()
         .filter_map(|variant| match variant.style {
-            Style::Struct => {
+            Style::Struct | Style::Tuple | Style::Newtype => {
                 let variant_ident = &variant.ident;
                 let members = variant.fields.iter().map(|field| &field.member);
                 let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
                 Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
             }
-            _ => None,
+            Style::Unit => None,
         })
         .collect::<Vec<_>>();
 

serde_derive/src/ser.rs

@@ -289,7 +289,7 @@ fn serialize_tuple_struct(
 }
 
 fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    assert!(fields.len() as u64 <= u64::from(u32::max_value()));
+    assert!(fields.len() as u64 <= u64::from(u32::MAX));
 
     if cattrs.has_flatten() {
         serialize_struct_as_map(params, fields, cattrs)
@@ -397,7 +397,7 @@ fn serialize_struct_as_map(
 }
 
 fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
-    assert!(variants.len() as u64 <= u64::from(u32::max_value()));
+    assert!(variants.len() as u64 <= u64::from(u32::MAX));
 
     let self_var = &params.self_var;
 
@@ -409,9 +409,9 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
         })
         .collect();
 
-    if cattrs.non_exhaustive() {
+    if cattrs.remote().is_some() && cattrs.non_exhaustive() {
         arms.push(quote! {
-            unrecognized => _serde::__private::Err(_serde::ser::Error::custom(_serde::__private::ser::CannotSerializeVariant(unrecognized))),
+            ref unrecognized => _serde::__private::Err(_serde::ser::Error::custom(_serde::__private::ser::CannotSerializeVariant(unrecognized))),
         });
     }
 
@@ -710,7 +710,7 @@ fn serialize_adjacently_tagged_variant(
     });
 
     let fields_ty = variant.fields.iter().map(|f| &f.ty);
-    let fields_ident: &Vec<_> = &match variant.style {
+    let fields_ident: &[_] = &match variant.style {
         Style::Unit => {
             if variant.attrs.serialize_with().is_some() {
                 vec![]

serde_derive_internals/Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "serde_derive_internals"
-version = "0.28.0" # remember to update html_root_url
+version = "0.29.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 description = "AST representation used by Serde derive macros. Unstable."
 documentation = "https://docs.rs/serde_derive_internals"
+edition = "2015"
 exclude = ["build.rs"]
 homepage = "https://serde.rs"
 keywords = ["serde", "serialization"]
@@ -15,9 +16,9 @@ rust-version = "1.56"
 path = "lib.rs"
 
 [dependencies]
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "2.0.28", default-features = false, features = ["clone-impls", "derive", "parsing", "printing"] }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/lib.rs

@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.28.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.29.0")]
 // Ignored clippy lints
 #![allow(
     clippy::cognitive_complexity,

test_suite/tests/regression/issue2371.rs

@@ -7,7 +7,9 @@ pub struct Nested;
 pub enum ExternallyTagged {
     Flatten {
         #[serde(flatten)]
+        #[allow(dead_code)]
         nested: Nested,
+        #[allow(dead_code)]
         string: &'static str,
     },
 }
@@ -17,7 +19,9 @@ pub enum ExternallyTagged {
 pub enum InternallyTagged {
     Flatten {
         #[serde(flatten)]
+        #[allow(dead_code)]
         nested: Nested,
+        #[allow(dead_code)]
         string: &'static str,
     },
 }
@@ -27,7 +31,9 @@ pub enum InternallyTagged {
 pub enum AdjacentlyTagged {
     Flatten {
         #[serde(flatten)]
+        #[allow(dead_code)]
         nested: Nested,
+        #[allow(dead_code)]
         string: &'static str,
     },
 }
@@ -37,7 +43,9 @@ pub enum AdjacentlyTagged {
 pub enum UntaggedWorkaround {
     Flatten {
         #[serde(flatten)]
+        #[allow(dead_code)]
         nested: Nested,
+        #[allow(dead_code)]
         string: &'static str,
     },
 }

test_suite/tests/test_annotations.rs

@@ -2380,6 +2380,68 @@ fn test_partially_untagged_enum_desugared() {
     );
 }
 
+#[test]
+fn test_partially_untagged_internally_tagged_enum() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A,
+        B,
+        #[serde(untagged)]
+        Var(u32),
+    }
+
+    let data = Data::A;
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+
+    let data = Data::Var(42);
+
+    assert_de_tokens(&data, &[Token::U32(42)]);
+
+    // TODO test error output
+}
+
+#[test]
+fn test_partially_untagged_adjacently_tagged_enum() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    enum Data {
+        A(u32),
+        B,
+        #[serde(untagged)]
+        Var(u32),
+    }
+
+    let data = Data::A(7);
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("c"),
+            Token::U32(7),
+            Token::MapEnd,
+        ],
+    );
+
+    let data = Data::Var(42);
+
+    assert_de_tokens(&data, &[Token::U32(42)]);
+
+    // TODO test error output
+}
+
 #[test]
 fn test_flatten_option() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -2719,7 +2781,7 @@ fn test_expecting_message_externally_tagged_enum() {
     // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
     assert_de_tokens_error::<Enum>(
         &[Token::Enum { name: "Enum" }, Token::Unit],
-        r#"invalid type: unit value, expected variant identifier"#,
+        "invalid type: unit value, expected variant identifier",
     );
 }
 
@@ -2740,7 +2802,7 @@ fn test_expecting_message_internally_tagged_enum() {
     // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
     assert_de_tokens_error::<Enum>(
         &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
-        r#"invalid type: unit value, expected variant identifier"#,
+        "invalid type: unit value, expected variant identifier",
     );
 }
 
@@ -2766,7 +2828,7 @@ fn test_expecting_message_adjacently_tagged_enum() {
     // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
     assert_de_tokens_error::<Enum>(
         &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
-        r#"invalid type: unit value, expected variant of enum Enum"#,
+        "invalid type: unit value, expected variant of enum Enum",
     );
 }
 
@@ -2779,7 +2841,7 @@ fn test_expecting_message_untagged_tagged_enum() {
         Untagged,
     }
 
-    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
+    assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], "something strange...");
 }
 
 #[test]
@@ -2800,7 +2862,7 @@ fn test_expecting_message_identifier_enum() {
 
     assert_de_tokens_error::<FieldEnum>(
         &[Token::Unit],
-        r#"invalid type: unit value, expected something strange..."#,
+        "invalid type: unit value, expected something strange...",
     );
 
     assert_de_tokens_error::<FieldEnum>(
@@ -2809,12 +2871,12 @@ fn test_expecting_message_identifier_enum() {
             Token::Str("Unknown"),
             Token::None,
         ],
-        r#"invalid type: map, expected something strange..."#,
+        "invalid type: map, expected something strange...",
     );
 
     assert_de_tokens_error::<VariantEnum>(
         &[Token::Unit],
-        r#"invalid type: unit value, expected something strange..."#,
+        "invalid type: unit value, expected something strange...",
     );
 
     assert_de_tokens_error::<VariantEnum>(
@@ -2825,7 +2887,7 @@ fn test_expecting_message_identifier_enum() {
             Token::Str("Unknown"),
             Token::None,
         ],
-        r#"invalid type: map, expected something strange..."#,
+        "invalid type: map, expected something strange...",
     );
 }
 

test_suite/tests/test_de.rs

@@ -11,6 +11,7 @@
 #![cfg_attr(feature = "unstable", feature(never_type))]
 
 use fnv::FnvHasher;
+use serde::de::value::{F32Deserializer, F64Deserializer};
 use serde::de::{Deserialize, DeserializeOwned, Deserializer, IntoDeserializer};
 use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Configure, Token};
@@ -22,7 +23,7 @@ use std::iter;
 use std::net;
 use std::num::{
     NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
-    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
+    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Saturating, Wrapping,
 };
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
@@ -832,6 +833,26 @@ fn test_f64() {
     test(1.11, &[Token::F64(1.11)]);
 }
 
+#[test]
+fn test_nan() {
+    let f32_deserializer = F32Deserializer::<serde::de::value::Error>::new;
+    let f64_deserializer = F64Deserializer::<serde::de::value::Error>::new;
+
+    let pos_f32_nan = f32_deserializer(f32::NAN.copysign(1.0));
+    let pos_f64_nan = f64_deserializer(f64::NAN.copysign(1.0));
+    assert!(f32::deserialize(pos_f32_nan).unwrap().is_sign_positive());
+    assert!(f32::deserialize(pos_f64_nan).unwrap().is_sign_positive());
+    assert!(f64::deserialize(pos_f32_nan).unwrap().is_sign_positive());
+    assert!(f64::deserialize(pos_f64_nan).unwrap().is_sign_positive());
+
+    let neg_f32_nan = f32_deserializer(f32::NAN.copysign(-1.0));
+    let neg_f64_nan = f64_deserializer(f64::NAN.copysign(-1.0));
+    assert!(f32::deserialize(neg_f32_nan).unwrap().is_sign_negative());
+    assert!(f32::deserialize(neg_f64_nan).unwrap().is_sign_negative());
+    assert!(f64::deserialize(neg_f32_nan).unwrap().is_sign_negative());
+    assert!(f64::deserialize(neg_f64_nan).unwrap().is_sign_negative());
+}
+
 #[test]
 fn test_char() {
     test('a', &[Token::Char('a')]);
@@ -1877,6 +1898,46 @@ fn test_range_inclusive() {
     );
 }
 
+#[test]
+fn test_range_from() {
+    test(
+        1u32..,
+        &[
+            Token::Struct {
+                name: "RangeFrom",
+                len: 1,
+            },
+            Token::Str("start"),
+            Token::U32(1),
+            Token::StructEnd,
+        ],
+    );
+    test(
+        1u32..,
+        &[Token::Seq { len: Some(1) }, Token::U32(1), Token::SeqEnd],
+    );
+}
+
+#[test]
+fn test_range_to() {
+    test(
+        ..2u32,
+        &[
+            Token::Struct {
+                name: "RangeTo",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(2),
+            Token::StructEnd,
+        ],
+    );
+    test(
+        ..2u32,
+        &[Token::Seq { len: Some(1) }, Token::U32(2), Token::SeqEnd],
+    );
+}
+
 #[test]
 fn test_bound() {
     test(
@@ -2004,6 +2065,43 @@ fn test_wrapping() {
     test(Wrapping(1usize), &[Token::U64(1)]);
 }
 
+#[test]
+fn test_saturating() {
+    test(Saturating(1usize), &[Token::U32(1)]);
+    test(Saturating(1usize), &[Token::U64(1)]);
+    test(Saturating(0u8), &[Token::I8(0)]);
+    test(Saturating(0u16), &[Token::I16(0)]);
+
+    // saturate input values at the minimum or maximum value
+    test(Saturating(u8::MAX), &[Token::U16(u16::MAX)]);
+    test(Saturating(u8::MAX), &[Token::U16(u8::MAX as u16 + 1)]);
+    test(Saturating(u16::MAX), &[Token::U32(u32::MAX)]);
+    test(Saturating(u32::MAX), &[Token::U64(u64::MAX)]);
+    test(Saturating(u8::MIN), &[Token::I8(i8::MIN)]);
+    test(Saturating(u16::MIN), &[Token::I16(i16::MIN)]);
+    test(Saturating(u32::MIN), &[Token::I32(i32::MIN)]);
+    test(Saturating(i8::MIN), &[Token::I16(i16::MIN)]);
+    test(Saturating(i16::MIN), &[Token::I32(i32::MIN)]);
+    test(Saturating(i32::MIN), &[Token::I64(i64::MIN)]);
+
+    test(Saturating(u8::MIN), &[Token::I8(-1)]);
+    test(Saturating(u16::MIN), &[Token::I16(-1)]);
+
+    #[cfg(target_pointer_width = "64")]
+    {
+        test(Saturating(usize::MIN), &[Token::U64(u64::MIN)]);
+        test(Saturating(usize::MAX), &[Token::U64(u64::MAX)]);
+        test(Saturating(isize::MIN), &[Token::I64(i64::MIN)]);
+        test(Saturating(isize::MAX), &[Token::I64(i64::MAX)]);
+        test(Saturating(0usize), &[Token::I64(i64::MIN)]);
+
+        test(
+            Saturating(9_223_372_036_854_775_807usize),
+            &[Token::I64(i64::MAX)],
+        );
+    }
+}
+
 #[test]
 fn test_rc_dst() {
     test(Rc::<str>::from("s"), &[Token::Str("s")]);

test_suite/tests/test_de_error.rs

@@ -1434,7 +1434,7 @@ fn test_number_from_string() {
 fn test_integer_from_float() {
     assert_de_tokens_error::<isize>(
         &[Token::F32(0.0)],
-        "invalid type: floating point `0`, expected isize",
+        "invalid type: floating point `0.0`, expected isize",
     );
 }
 
@@ -1459,7 +1459,7 @@ fn test_duration_overflow_seq() {
     assert_de_tokens_error::<Duration>(
         &[
             Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
             Token::U32(1_000_000_000),
             Token::SeqEnd,
         ],
@@ -1476,7 +1476,7 @@ fn test_duration_overflow_struct() {
                 len: 2,
             },
             Token::Str("secs"),
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
             Token::Str("nanos"),
             Token::U32(1_000_000_000),
             Token::StructEnd,
@@ -1490,7 +1490,7 @@ fn test_systemtime_overflow_seq() {
     assert_de_tokens_error::<SystemTime>(
         &[
             Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
             Token::U32(1_000_000_000),
             Token::SeqEnd,
         ],
@@ -1507,7 +1507,7 @@ fn test_systemtime_overflow_struct() {
                 len: 2,
             },
             Token::Str("secs_since_epoch"),
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
             Token::Str("nanos_since_epoch"),
             Token::U32(1_000_000_000),
             Token::StructEnd,
@@ -1522,7 +1522,7 @@ fn test_systemtime_overflow() {
     assert_de_tokens_error::<SystemTime>(
         &[
             Token::Seq { len: Some(2) },
-            Token::U64(u64::max_value()),
+            Token::U64(u64::MAX),
             Token::U32(0),
             Token::SeqEnd,
         ],

test_suite/tests/test_gen.rs

@@ -686,9 +686,17 @@ fn test_gen() {
 
     #[derive(Deserialize)]
     #[serde(untagged)]
-    enum UntaggedWithBorrow<'a> {
-        Single(#[serde(borrow)] RelObject<'a>),
-        Many(#[serde(borrow)] Vec<RelObject<'a>>),
+    pub enum UntaggedWithBorrow<'a> {
+        Single(
+            #[serde(borrow)]
+            #[allow(dead_code)]
+            RelObject<'a>,
+        ),
+        Many(
+            #[serde(borrow)]
+            #[allow(dead_code)]
+            Vec<RelObject<'a>>,
+        ),
     }
 
     #[derive(Deserialize)]
@@ -730,6 +738,7 @@ fn test_gen() {
 
     #[derive(Serialize)]
     #[repr(packed)]
+    #[allow(dead_code)]
     struct Packed {
         x: u8,
         y: u16,
@@ -761,6 +770,7 @@ fn test_gen() {
     }
 
     #[derive(Serialize)]
+    #[allow(dead_code)]
     struct Struct {
         #[serde(serialize_with = "vec_first_element")]
         vec: Vec<Self>,
@@ -843,7 +853,7 @@ pub fn is_zero(n: &u8) -> bool {
     *n == 0
 }
 
-fn vec_first_element<T, S>(vec: &Vec<T>, serializer: S) -> StdResult<S::Ok, S::Error>
+fn vec_first_element<T, S>(vec: &[T], serializer: S) -> StdResult<S::Ok, S::Error>
 where
     T: Serialize,
     S: Serializer,

test_suite/tests/test_macros.rs

@@ -814,6 +814,100 @@ fn test_internally_tagged_enum() {
     );
 }
 
+#[test]
+fn test_internally_tagged_enum_with_untagged_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "kind")]
+    enum InternallyTagged {
+        Tagged {
+            a: u8,
+        },
+        #[serde(untagged)]
+        Untagged {
+            kind: String,
+            b: u8,
+        },
+    }
+
+    assert_de_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            kind: "Tagged".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("kind"),
+            Token::Str("Tagged"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_internally_tagged_bytes() {
     #[derive(Debug, PartialEq, Deserialize)]
@@ -987,6 +1081,15 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
         Log { level: Level },
     }
 
+    assert_de_tokens(
+        &Level::Info,
+        &[
+            Token::Enum { name: "Level" },
+            Token::BorrowedStr("Info"),
+            Token::Unit,
+        ],
+    );
+
     assert_de_tokens(
         &Message::Log { level: Level::Info },
         &[
@@ -997,7 +1100,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
             Token::Str("action"),
             Token::Str("Log"),
             Token::Str("level"),
+            Token::Enum { name: "Level" },
             Token::BorrowedStr("Info"),
+            Token::Unit,
             Token::StructEnd,
         ],
     );
@@ -1009,7 +1114,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
             Token::Str("action"),
             Token::Str("Log"),
             Token::Str("level"),
+            Token::Enum { name: "Level" },
             Token::BorrowedStr("Info"),
+            Token::Unit,
             Token::MapEnd,
         ],
     );
@@ -1019,7 +1126,9 @@ fn test_internally_tagged_struct_variant_containing_unit_variant() {
         &[
             Token::Seq { len: Some(2) },
             Token::Str("Log"),
+            Token::Enum { name: "Level" },
             Token::BorrowedStr("Info"),
+            Token::Unit,
             Token::SeqEnd,
         ],
     );
@@ -2125,24 +2234,28 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
 fn test_packed_struct_can_derive_serialize() {
     #[derive(Copy, Clone, Serialize)]
     #[repr(packed, C)]
+    #[allow(dead_code)]
     struct PackedC {
         t: f32,
     }
 
     #[derive(Copy, Clone, Serialize)]
     #[repr(C, packed)]
+    #[allow(dead_code)]
     struct CPacked {
         t: f32,
     }
 
     #[derive(Copy, Clone, Serialize)]
     #[repr(C, packed(2))]
+    #[allow(dead_code)]
     struct CPacked2 {
         t: f32,
     }
 
     #[derive(Copy, Clone, Serialize)]
     #[repr(packed(2), C)]
+    #[allow(dead_code)]
     struct Packed2C {
         t: f32,
     }

test_suite/tests/test_remote.rs

@@ -127,7 +127,7 @@ struct Test {
     enum_concrete: remote::EnumGeneric<u8>,
 
     #[serde(with = "ErrorKindDef")]
-    io_error_kind: std::io::ErrorKind,
+    io_error_kind: ErrorKind,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -200,8 +200,16 @@ enum EnumConcrete {
     Variant(u8),
 }
 
+#[derive(Debug)]
+enum ErrorKind {
+    NotFound,
+    PermissionDenied,
+    #[allow(dead_code)]
+    ConnectionRefused,
+}
+
 #[derive(Serialize, Deserialize)]
-#[serde(remote = "std::io::ErrorKind")]
+#[serde(remote = "ErrorKind")]
 #[non_exhaustive]
 enum ErrorKindDef {
     NotFound,

test_suite/tests/test_ser.rs

@@ -8,7 +8,7 @@ use std::cell::RefCell;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::CString;
 use std::net;
-use std::num::Wrapping;
+use std::num::{Saturating, Wrapping};
 use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
@@ -500,6 +500,38 @@ fn test_range_inclusive() {
     );
 }
 
+#[test]
+fn test_range_from() {
+    assert_ser_tokens(
+        &(1u32..),
+        &[
+            Token::Struct {
+                name: "RangeFrom",
+                len: 1,
+            },
+            Token::Str("start"),
+            Token::U32(1),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_range_to() {
+    assert_ser_tokens(
+        &(..2u32),
+        &[
+            Token::Struct {
+                name: "RangeTo",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_bound() {
     assert_ser_tokens(
@@ -592,6 +624,11 @@ fn test_wrapping() {
     assert_ser_tokens(&Wrapping(1usize), &[Token::U64(1)]);
 }
 
+#[test]
+fn test_saturating() {
+    assert_ser_tokens(&Saturating(1usize), &[Token::U64(1)]);
+}
+
 #[test]
 fn test_rc_dst() {
     assert_ser_tokens(&Rc::<str>::from("s"), &[Token::Str("s")]);

test_suite/tests/test_serde_path.rs

@@ -27,19 +27,21 @@ mod fake_serde {
     {
     }
 
+    #[allow(dead_code)]
     pub trait Serialize {
         fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
     }
 
+    #[allow(dead_code)]
     pub trait Deserialize<'a>: Sized {
         fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>;
     }
 }
 
-trait AssertNotSerdeSerialize {}
+pub trait AssertNotSerdeSerialize {}
 
 impl<T: serde::Serialize> AssertNotSerdeSerialize for T {}
 
-trait AssertNotSerdeDeserialize<'a> {}
+pub trait AssertNotSerdeDeserialize<'a> {}
 
 impl<'a, T: serde::Deserialize<'a>> AssertNotSerdeDeserialize<'a> for T {}

test_suite/tests/test_value.rs

@@ -63,7 +63,7 @@ fn test_map_access_to_enum() {
                 type Value = Potential;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    write!(formatter, "a map")
+                    formatter.write_str("a map")
                 }
 
                 fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>

test_suite/tests/ui/remote/unknown_field.stderr

@@ -2,10 +2,17 @@ error[E0609]: no field `b` on type `&remote::S`
   --> tests/ui/remote/unknown_field.rs:12:5
    |
 12 |     b: u8,
-   |     ^ help: a field with a similar name exists: `a`
+   |     ^ unknown field
+   |
+help: a field with a similar name exists
+   |
+12 |     a: u8,
+   |     ~
 
 error[E0560]: struct `remote::S` has no field named `b`
   --> tests/ui/remote/unknown_field.rs:12:5
    |
 12 |     b: u8,
-   |     ^ help: a field with a similar name exists: `a`
+   |     ^ `remote::S` does not have this field
+   |
+   = note: all struct fields are already assigned

test_suite/tests/ui/remote/wrong_de.stderr

@@ -12,7 +12,3 @@ note: tuple struct defined here
 4 |     pub struct S(pub u16);
   |                ^
   = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
-help: you can convert a `u8` to a `u16`
-  |
-7 | #[derive(Deserialize.into())]
-  |                     +++++++