Release 1.0.188

This reverts commit e1c27243b2.

Closes https://github.com/serde-rs/serde/issues/2603.

.github/workflows/ci.yml

@@ -98,7 +98,6 @@ jobs:
       - 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
@@ -109,38 +108,6 @@ jobs:
       - 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: |
-          # FIXME: consider using `cargo rm serde_derive` but it's currently broken
-          # https://github.com/rust-lang/cargo/issues/12419
-          sed -i '/serde_derive =/d' serde/Cargo.toml
-          sed -i '/derive = \["serde_derive"\]/d' serde/Cargo.toml
-          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 --manifest-path test_suite/Cargo.toml
-          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

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.182"
-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,21 +0,0 @@
-#!/bin/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}
-
-#upx --best --lzma 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.182"
-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.182")]
-
-#[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.182" # remember to update html_root_url and serde_derive dependency
+version = "1.0.188" # remember to update html_root_url and serde_derive dependency
 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.182", optional = true, path = "../serde_derive" }
+serde_derive = { version = "1", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1", path = "../serde_derive" }
@@ -31,6 +31,14 @@ features = ["derive"]
 targets = ["x86_64-unknown-linux-gnu"]
 rustdoc-args = ["--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.188", path = "../serde_derive" }
+
 
 ### FEATURES #################################################################
 

serde/build.rs

@@ -27,13 +27,6 @@ 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");
-    }
-
     // Current minimum supported version of serde_derive crate is Rust 1.56.
     if minor < 56 {
         println!("cargo:rustc-cfg=no_serde_derive");

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/impls.rs

@@ -364,64 +364,62 @@ impl_deserialize_num! {
     num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
 }
 
-serde_if_integer128! {
-    macro_rules! num_128 {
-        ($ty:ident : $visit:ident) => {
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
+macro_rules! num_128 {
+    ($ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if v as i128 >= Self::Value::min_value() as i128
+                && v as u128 <= Self::Value::max_value() as u128
             {
-                if v as i128 >= Self::Value::min_value() as i128
-                    && v as u128 <= Self::Value::max_value() as u128
-                {
-                    Ok(v as Self::Value)
-                } else {
-                    Err(Error::invalid_value(
-                        Unexpected::Other(stringify!($ty)),
-                        &self,
-                    ))
-                }
+                Ok(v as Self::Value)
+            } else {
+                Err(Error::invalid_value(
+                    Unexpected::Other(stringify!($ty)),
+                    &self,
+                ))
             }
-        };
+        }
+    };
 
-        (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-            fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-            where
-                E: Error,
+    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
+        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            if v as i128 >= $primitive::min_value() as i128
+                && v as u128 <= $primitive::max_value() as u128
             {
-                if v as i128 >= $primitive::min_value() as i128
-                    && v as u128 <= $primitive::max_value() as u128
-                {
-                    if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                        Ok(nonzero)
-                    } else {
-                        Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
-                    }
+                if let Some(nonzero) = Self::Value::new(v as $primitive) {
+                    Ok(nonzero)
                 } else {
-                    Err(Error::invalid_value(
-                        Unexpected::Other(stringify!($ty)),
-                        &self,
-                    ))
+                    Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
                 }
+            } else {
+                Err(Error::invalid_value(
+                    Unexpected::Other(stringify!($ty)),
+                    &self,
+                ))
             }
-        };
-    }
+        }
+    };
+}
 
-    impl_deserialize_num! {
-        i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
-        num_self!(i128:visit_i128);
-        num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-        num_128!(u128:visit_u128);
-    }
+impl_deserialize_num! {
+    i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
+    num_self!(i128:visit_i128);
+    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+    num_128!(u128:visit_u128);
+}
 
-    impl_deserialize_num! {
-        u128, NonZeroU128, deserialize_u128
-        num_self!(u128:visit_u128);
-        num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-        int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-        num_128!(i128:visit_i128);
-    }
+impl_deserialize_num! {
+    u128, NonZeroU128, deserialize_u128
+    num_self!(u128:visit_u128);
+    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
+    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
+    num_128!(i128:visit_i128);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1789,6 +1787,9 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 #[cfg(any(feature = "std", feature = "alloc"))]
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
+#[cfg(all(feature = "std", any(unix, windows)))]
+forwarded_impl!((), Box<OsStr>, OsString::into_boxed_os_str);
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
 where

serde/src/de/mod.rs

@@ -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;
 
@@ -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
@@ -1555,7 +1547,6 @@ pub trait Visitor<'de>: Sized {
     where
         E: Error,
     {
-        let _ = v;
         Err(Error::invalid_type(Unexpected::Bytes(v), &self))
     }
 

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

@@ -292,20 +292,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,

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

@@ -93,7 +93,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.182")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.188")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and

serde/src/macros.rs

@@ -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/ser.rs

@@ -1370,3 +1370,16 @@ impl Serialize for AdjacentlyTaggedEnumVariant {
         serializer.serialize_unit_variant(self.enum_name, self.variant_index, self.variant_name)
     }
 }
+
+// Error when Serialize for a non_exhaustive remote enum encounters a variant
+// that is not recognized.
+pub struct CannotSerializeVariant<T>(pub T);
+
+impl<T> Display for CannotSerializeVariant<T>
+where
+    T: Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        write!(formatter, "enum variant cannot be serialized: {:?}", self.0)
+    }
+}

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,

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 {
@@ -553,6 +550,7 @@ nonzero_integers! {
     NonZeroU16,
     NonZeroU32,
     NonZeroU64,
+    NonZeroU128,
     NonZeroUsize,
 }
 
@@ -562,22 +560,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,

serde/src/ser/mod.rs

@@ -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.

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.182" # remember to update html_root_url
+version = "1.0.188" # remember to update html_root_url
 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)]"

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);
@@ -965,12 +958,7 @@ fn deserialize_struct(
             )
         })
         .collect();
-    let field_visitor = Stmts(deserialize_generated_identifier(
-        &field_names_idents,
-        cattrs,
-        false,
-        None,
-    ));
+    let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs);
 
     // untagged struct variants do not get a visit_seq method. The same applies to
     // structs that only have a map representation.
@@ -1128,12 +1116,7 @@ fn deserialize_struct_in_place(
         })
         .collect();
 
-    let field_visitor = Stmts(deserialize_generated_identifier(
-        &field_names_idents,
-        cattrs,
-        false,
-        None,
-    ));
+    let field_visitor = deserialize_field_identifier(&field_names_idents, cattrs);
 
     let mut_seq = if field_names_idents.is_empty() {
         quote!(_)
@@ -1247,7 +1230,12 @@ fn prepare_enum_variant_enum(
         })
         .collect();
 
-    let other_idx = deserialized_variants.position(|(_, variant)| variant.attrs.other());
+    let fallthrough = deserialized_variants
+        .position(|(_, variant)| variant.attrs.other())
+        .map(|other_idx| {
+            let ignore_variant = variant_names_idents[other_idx].1.clone();
+            quote!(_serde::__private::Ok(__Field::#ignore_variant))
+        });
 
     let variants_stmt = {
         let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
@@ -1261,7 +1249,8 @@ fn prepare_enum_variant_enum(
         &variant_names_idents,
         cattrs,
         true,
-        other_idx,
+        None,
+        fallthrough,
     ));
 
     (variants_stmt, variant_visitor)
@@ -1986,27 +1975,12 @@ fn deserialize_generated_identifier(
     fields: &[(&str, Ident, &BTreeSet<String>)],
     cattrs: &attr::Container,
     is_variant: bool,
-    other_idx: Option<usize>,
+    ignore_variant: Option<TokenStream>,
+    fallthrough: Option<TokenStream>,
 ) -> Fragment {
     let this_value = quote!(__Field);
     let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
 
-    let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
-        let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
-        let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
-        (Some(ignore_variant), Some(fallthrough))
-    } else if let Some(other_idx) = other_idx {
-        let ignore_variant = fields[other_idx].1.clone();
-        let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant));
-        (None, Some(fallthrough))
-    } else if is_variant || cattrs.deny_unknown_fields() {
-        (None, None)
-    } else {
-        let ignore_variant = quote!(__ignore,);
-        let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
-        (Some(ignore_variant), Some(fallthrough))
-    };
-
     let visitor_impl = Stmts(deserialize_identifier(
         &this_value,
         fields,
@@ -2052,6 +2026,33 @@ fn deserialize_generated_identifier(
     }
 }
 
+/// Generates enum and its `Deserialize` implementation that represents each
+/// non-skipped field of the struct
+fn deserialize_field_identifier(
+    fields: &[(&str, Ident, &BTreeSet<String>)],
+    cattrs: &attr::Container,
+) -> Stmts {
+    let (ignore_variant, fallthrough) = if cattrs.has_flatten() {
+        let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
+        let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
+        (Some(ignore_variant), Some(fallthrough))
+    } else if cattrs.deny_unknown_fields() {
+        (None, None)
+    } else {
+        let ignore_variant = quote!(__ignore,);
+        let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
+        (Some(ignore_variant), Some(fallthrough))
+    };
+
+    Stmts(deserialize_generated_identifier(
+        fields,
+        cattrs,
+        false,
+        ignore_variant,
+        fallthrough,
+    ))
+}
+
 // Generates `Deserialize::deserialize` body for an enum with
 // `serde(field_identifier)` or `serde(variant_identifier)` attribute.
 fn deserialize_custom_identifier(

serde_derive/src/internals/attr.rs

@@ -221,6 +221,7 @@ pub struct Container {
     is_packed: bool,
     /// Error message generated when type can't be deserialized
     expecting: Option<String>,
+    non_exhaustive: bool,
 }
 
 /// Styles of representing an enum.
@@ -306,9 +307,12 @@ impl Container {
         let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
         let mut serde_path = Attr::none(cx, CRATE);
         let mut expecting = Attr::none(cx, EXPECTING);
+        let mut non_exhaustive = false;
 
         for attr in &item.attrs {
             if attr.path() != SERDE {
+                non_exhaustive |=
+                    matches!(&attr.meta, syn::Meta::Path(path) if path == NON_EXHAUSTIVE);
                 continue;
             }
 
@@ -587,6 +591,7 @@ impl Container {
             serde_path: serde_path.get(),
             is_packed,
             expecting: expecting.get(),
+            non_exhaustive,
         }
     }
 
@@ -672,6 +677,10 @@ impl Container {
     pub fn expecting(&self) -> Option<&str> {
         self.expecting.as_ref().map(String::as_ref)
     }
+
+    pub fn non_exhaustive(&self) -> bool {
+        self.non_exhaustive
+    }
 }
 
 fn decide_tag(
@@ -707,7 +716,7 @@ fn decide_tag(
             }
             TagType::Internal { tag }
         }
-        (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => {
+        (Some((untagged_tokens, ())), Some((tag_tokens, _)), None) => {
             let msg = "enum cannot be both untagged and internally tagged";
             cx.error_spanned_by(untagged_tokens, msg);
             cx.error_spanned_by(tag_tokens, msg);
@@ -718,14 +727,14 @@ fn decide_tag(
             cx.error_spanned_by(content_tokens, msg);
             TagType::External
         }
-        (Some((untagged_tokens, _)), None, Some((content_tokens, _))) => {
+        (Some((untagged_tokens, ())), None, Some((content_tokens, _))) => {
             let msg = "untagged enum cannot have #[serde(content = \"...\")]";
             cx.error_spanned_by(untagged_tokens, msg);
             cx.error_spanned_by(content_tokens, msg);
             TagType::External
         }
         (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content },
-        (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => {
+        (Some((untagged_tokens, ())), Some((tag_tokens, _)), Some((content_tokens, _))) => {
             let msg = "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]";
             cx.error_spanned_by(untagged_tokens, msg);
             cx.error_spanned_by(tag_tokens, msg);
@@ -747,7 +756,7 @@ fn decide_identifier(
         variant_identifier.0.get_with_tokens(),
     ) {
         (_, None, None) => Identifier::No,
-        (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
+        (_, Some((field_identifier_tokens, ())), Some((variant_identifier_tokens, ()))) => {
             let msg =
                 "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set";
             cx.error_spanned_by(field_identifier_tokens, msg);

serde_derive/src/internals/symbol.rs

@@ -19,6 +19,7 @@ pub const FLATTEN: Symbol = Symbol("flatten");
 pub const FROM: Symbol = Symbol("from");
 pub const GETTER: Symbol = Symbol("getter");
 pub const INTO: Symbol = Symbol("into");
+pub const NON_EXHAUSTIVE: Symbol = Symbol("non_exhaustive");
 pub const OTHER: Symbol = Symbol("other");
 pub const REMOTE: Symbol = Symbol("remote");
 pub const RENAME: Symbol = Symbol("rename");

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.182")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.188")]
 // Ignored clippy lints
 #![allow(
     // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
@@ -66,17 +66,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 +85,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 +93,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/ser.rs

@@ -401,7 +401,7 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
 
     let self_var = &params.self_var;
 
-    let arms: Vec<_> = variants
+    let mut arms: Vec<_> = variants
         .iter()
         .enumerate()
         .map(|(variant_index, variant)| {
@@ -409,6 +409,12 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
         })
         .collect();
 
+    if cattrs.remote().is_some() && cattrs.non_exhaustive() {
+        arms.push(quote! {
+            ref unrecognized => _serde::__private::Err(_serde::ser::Error::custom(_serde::__private::ser::CannotSerializeVariant(unrecognized))),
+        });
+    }
+
     quote_expr! {
         match *#self_var {
             #(#arms)*
@@ -704,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![]

test_suite/tests/test_gen.rs

@@ -843,7 +843,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_remote.rs

@@ -125,6 +125,9 @@ struct Test {
 
     #[serde(with = "EnumConcrete")]
     enum_concrete: remote::EnumGeneric<u8>,
+
+    #[serde(with = "ErrorKindDef")]
+    io_error_kind: ErrorKind,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -197,6 +200,23 @@ enum EnumConcrete {
     Variant(u8),
 }
 
+#[derive(Debug)]
+enum ErrorKind {
+    NotFound,
+    PermissionDenied,
+    #[allow(dead_code)]
+    ConnectionRefused,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "ErrorKind")]
+#[non_exhaustive]
+enum ErrorKindDef {
+    NotFound,
+    PermissionDenied,
+    // ...
+}
+
 impl From<PrimitivePrivDef> for remote::PrimitivePriv {
     fn from(def: PrimitivePrivDef) -> Self {
         remote::PrimitivePriv::new(def.0)