Version bump

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: dtolnay

.github/ISSUE_TEMPLATE/1-problem.md

@@ -1,7 +0,0 @@
----
-name: Problem
-about: Something does not seem right
-
----
-
-

.github/ISSUE_TEMPLATE/2-suggestion.md

@@ -1,7 +0,0 @@
----
-name: Suggestion
-about: Share how Serde could support your use case better
-
----
-
-

.github/ISSUE_TEMPLATE/3-documentation.md

@@ -1,7 +0,0 @@
----
-name: Documentation
-about: Certainly there is room for improvement
-
----
-
-

.github/ISSUE_TEMPLATE/4-other.md

@@ -1,7 +0,0 @@
----
-name: Anything else!
-about: Whatever is on your mind
-
----
-
-

.github/workflows/ci.yml

@@ -1,181 +0,0 @@
-name: CI
-
-on:
-  push:
-  pull_request:
-  workflow_dispatch:
-  schedule: [cron: "40 1 * * *"]
-
-permissions:
-  contents: read
-
-env:
-  RUSTFLAGS: -Dwarnings
-
-jobs:
-  test:
-    name: Test suite
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@nightly
-      - run: cd test_suite && cargo test --features unstable
-      - uses: actions/upload-artifact@v6
-        if: always()
-        with:
-          name: Cargo.lock
-          path: Cargo.lock
-        continue-on-error: true
-
-  windows:
-    name: Test suite (windows)
-    runs-on: windows-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@nightly
-      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
-
-  stable:
-    name: Rust ${{matrix.rust}}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        rust: [stable, beta]
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{matrix.rust}}
-      - run: cd serde && cargo build --features rc
-      - run: cd serde && cargo build --no-default-features
-      - run: cd test_suite/no_std && cargo build
-
-  nightly:
-    name: Rust nightly${{matrix.os == 'windows' && ' (windows)' || ''}}
-    runs-on: ${{matrix.os}}-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu, windows]
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@nightly
-      - run: cd serde && cargo build
-      - run: cd serde && cargo build --no-default-features
-      - run: cd serde && cargo build --no-default-features --features alloc
-      - run: cd serde && cargo build --no-default-features --features rc,alloc
-      - run: cd serde && cargo build --no-default-features --features unstable
-      - run: cd serde_core && cargo test --features rc,unstable
-      - run: cd test_suite/no_std && cargo build
-        if: matrix.os != 'windows'
-      - run: cd serde_derive && cargo check --tests
-        env:
-          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
-        if: matrix.os != 'windows'
-
-  build:
-    name: Rust ${{matrix.rust}}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        rust: [1.56.0, 1.60.0]
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{matrix.rust}}
-      - run: sed -i '/"test_suite"/d' Cargo.toml
-      - run: cd serde && cargo build --features rc
-      - run: cd serde && cargo build --no-default-features
-      - run: cd serde && cargo build --no-default-features --features alloc
-      - run: cd serde && cargo build
-
-  derive:
-    name: Rust 1.68.0
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@1.68.0
-      - run: |
-          sed -i 's/proc-macro2 = { workspace = true/proc-macro2 = { version = "1"/' serde_derive*/Cargo.toml
-          sed -i 's/quote = { workspace = true/quote = { version = "1"/' serde_derive*/Cargo.toml
-          sed -i 's/syn = { workspace = true/syn = { version = "2"/' serde_derive*/Cargo.toml
-      - run: cd serde && cargo check --no-default-features
-      - run: cd serde && cargo check
-      - run: cd serde_derive && cargo check
-
-  minimal:
-    name: Minimal versions
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - 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@v6
-      - uses: dtolnay/rust-toolchain@nightly
-      - uses: dtolnay/install@cargo-docs-rs
-      - run: cargo docs-rs -p serde
-      - run: cargo docs-rs -p serde_core
-      - 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@v6
-      - uses: dtolnay/rust-toolchain@clippy
-      - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
-      - run: cd serde_core && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
-      - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
-      - run: cd serde_derive_internals && cargo clippy -- -Dclippy::all -Dclippy::pedantic
-      - run: cd test_suite && cargo clippy --tests --features unstable -- -Dclippy::all -Dclippy::pedantic
-      - run: cd test_suite/no_std && cargo clippy -- -Dclippy::all -Dclippy::pedantic
-
-  miri:
-    name: Miri
-    runs-on: ubuntu-latest
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@miri
-        with:
-          toolchain: nightly-2025-05-16  # https://github.com/rust-lang/miri/issues/4323
-      - run: cargo miri setup
-      - run: cd serde_core && cargo miri test --features rc,unstable
-        env:
-          MIRIFLAGS: -Zmiri-strict-provenance
-      - run: cd test_suite && cargo miri test --features unstable
-        env:
-          MIRIFLAGS: -Zmiri-strict-provenance
-
-  outdated:
-    name: Outdated
-    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
-    timeout-minutes: 45
-    steps:
-      - uses: actions/checkout@v6
-      - uses: dtolnay/rust-toolchain@stable
-      - uses: dtolnay/install@cargo-outdated
-      - run: cargo outdated --workspace --exit-code 1

.gitignore

@@ -1,2 +1,2 @@
-/target/
-/Cargo.lock
+target
+Cargo.lock

.travis.yml

@@ -0,0 +1,34 @@
+language: rust
+rust:
+  - stable
+  - beta
+  - nightly
+env:
+  global:
+    secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
+  matrix:
+    - CRATE=serde_tests TARGET=test
+matrix:
+  include:
+    - rust: nightly
+      env: CRATE=serde_macros TARGET=test
+    - rust: nightly
+      env: CRATE=serde_macros TARGET=bench
+    - rust: nightly
+      env: CRATE=serde_tests TARGET=bench
+script:
+  - (cd $CRATE && cargo $TARGET)
+after_success: |
+  [ $TRAVIS_BRANCH = "master" ] &&
+  [ $TRAVIS_PULL_REQUEST  = false ] &&
+  mkdir -p target/doc &&
+  (cd serde && cargo doc --no-deps) &&
+  (cd serde_codegen && cargo doc --no-deps) &&
+  (cd serde_macros && cargo doc --no-deps) &&
+  cp -r serde/target/doc target/doc/serde &&
+  cp -r serde_codegen/target/doc target/doc/serde_codegen &&
+  cp -r serde_macros/target/doc target/doc/serde_macros &&
+  echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2`/index.html>" > target/doc/index.html &&
+  sudo pip install ghp-import &&
+  ghp-import -n target/doc &&
+  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages

CONTRIBUTING.md

@@ -1,55 +0,0 @@
-# Contributing to Serde
-
-Serde welcomes contribution from everyone in the form of suggestions, bug
-reports, pull requests, and feedback. This document gives some guidance if you
-are thinking of helping us.
-
-## Submitting bug reports and feature requests
-
-Serde development is spread across lots of repositories, but this serde-rs/serde
-repository is always a safe choice for opening any issues related to Serde.
-
-When reporting a bug or asking for help, please include enough details so that
-the people helping you can reproduce the behavior you are seeing. For some tips
-on how to approach this, read about how to produce a [Minimal, Complete, and
-Verifiable example].
-
-[Minimal, Complete, and Verifiable example]: https://stackoverflow.com/help/mcve
-
-When making a feature request, please make it clear what problem you intend to
-solve with the feature, any ideas for how Serde could support solving that
-problem, any possible alternatives, and any disadvantages.
-
-## Running the test suite
-
-We encourage you to check that the test suite passes locally before submitting a
-pull request with your changes. If anything does not pass, typically it will be
-easier to iterate and fix it locally than waiting for the CI servers to run
-tests for you.
-
-##### In the [`serde_core`] directory
-
-```sh
-# Test all the example code in Serde documentation
-cargo test
-```
-
-##### In the [`test_suite`] directory
-
-```sh
-# Run the full test suite, including tests of unstable functionality
-cargo +nightly test --features unstable
-```
-
-Note that this test suite currently only supports running on a nightly compiler.
-
-[`serde_core`]: https://github.com/serde-rs/serde/tree/master/serde_core
-[`test_suite`]: https://github.com/serde-rs/serde/tree/master/test_suite
-
-## Conduct
-
-In all Serde-related forums, we follow the [Rust Code of Conduct]. For
-escalation or moderation issues please contact Erick (erick.tryzelaar@gmail.com)
-instead of the Rust moderation team.
-
-[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct

Cargo.toml

@@ -1,19 +0,0 @@
-[workspace]
-members = [
-    "serde",
-    "serde_core",
-    "serde_derive",
-    "serde_derive_internals",
-    "test_suite",
-]
-resolver = "2"
-
-[patch.crates-io]
-serde = { path = "serde" }
-serde_core = { path = "serde_core" }
-serde_derive = { path = "serde_derive" }
-
-[workspace.dependencies]
-proc-macro2 = { version = "1.0.74", default-features = false }
-quote = { version = "1.0.35", default-features = false }
-syn = { version = "2.0.81", default-features = false }

LICENSE

@@ -0,0 +1,33 @@
+See LICENSE-APACHE and LICENSE-MIT.
+
+----
+
+bench_log is derived from https://github.com/cloudflare/goser, which has the
+following license:
+
+Copyright (c) 2013, CloudFlare, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of the author nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

LICENSE-APACHE

@@ -174,3 +174,28 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
    of your accepting any such warranty or additional liability.
 
 END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

LICENSE-MIT

@@ -1,3 +1,5 @@
+Copyright (c) 2014 The Rust Project Developers
+
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the

README.md

@@ -1,114 +1,424 @@
-# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde msrv]][Rust 1.56] [![serde_derive msrv]][Rust 1.68]
+Serde Rust Serialization Framework
+==================================
 
-[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 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.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0/
-[Rust 1.68]: https://blog.rust-lang.org/2023/03/09/Rust-1.68.0/
+[![Build Status](https://api.travis-ci.org/serde-rs/serde.png?branch=master)](https://travis-ci.org/serde-rs/serde)
+[![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
 
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
+Serde is a powerful framework that enables serialization libraries to
+generically serialize Rust data structures without the overhead of runtime type
+information. In many situations, the handshake protocol between serializers and
+serializees can be completely optimized away, leaving Serde to perform roughly
+the same speed as a hand written serializer for a specific type.
 
----
+Documentation is available at http://serde-rs.github.io/serde/serde
 
-You may be looking for:
+Making a Type Serializable
+==========================
 
-- [An overview of Serde](https://serde.rs)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.rs/serde)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-<details>
-<summary>
-Click to show Cargo.toml.
-<a href="https://play.rust-lang.org/?edition=2021&gist=72755f28f99afc95e01d63174b28c1f5" target="_blank">Run this code in the playground.</a>
-</summary>
-
-```toml
-[dependencies]
-
-# The core APIs, including the Serialize and Deserialize traits. Always
-# required when using Serde. The "derive" feature is only required when
-# using #[derive(Serialize, Deserialize)] to make Serde work with structs
-# and enums defined in your crate.
-serde = { version = "1.0", features = ["derive"] }
-
-# Each data format lives in its own crate; the sample code below uses JSON
-# but you may be using a different one.
-serde_json = "1.0"
-```
-
-</details>
-<p></p>
+The simplest way to make a type serializable is to use the `serde_macros`
+syntax extension, which comes with a `#[derive(Serialize, Deserialize)]`
+annotation, which automatically generates implementations of 
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+and
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+for the annotated type:
 
 ```rust
-use serde::{Deserialize, Serialize};
+#![feature(custom_derive, plugin)]
+#![plugin(serde_macros)]
 
-#[derive(Serialize, Deserialize, Debug)]
+extern crate serde;
+
+...
+
+#[derive(Serialize, Deserialize)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+```
+
+Serde bundles a high performance JSON serializer and deserializer,
+[serde::json](http://serde-rs.github.io/serde/serde/json/index.html),
+which comes with the helper functions
+[to_string](http://serde-rs.github.io/serde/serde/json/ser/fn.to_string.html)
+and
+[from_str](http://serde-rs.github.io/serde/serde/json/de/fn.from_str.html)
+that make it easy to go to and from JSON:
+
+```rust
+use serde::json;
+
+...
+
+let point = Point { x: 1, y: 2 };
+let serialized_point = json::to_string(&point).unwrap();
+
+println!("{}", serialized_point); // prints: {"x":1,"y":2}
+
+let deserialize_point: Point = json::from_str(&serialized_point).unwrap();
+```
+
+[serde::json](http://serde-rs.github.io/serde/serde/json/index.html) also
+supports a generic
+[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
+type, which can represent any JSON value. Also, any
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+and
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+can be converted into a 
+[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
+with the methods
+[to_value](http://serde-rs.github.io/serde/serde/json/value/fn.to_value.html)
+and
+[from_value](http://serde-rs.github.io/serde/serde/json/value/fn.from_value.html):
+
+```rust
+let point = Point { x: 1, y: 2 };
+let point_value = json::to_value(&point).unwrap();
+
+println!("{}", point_value.find("x")); // prints: Some(1)
+
+let deserialize_point: Point = json::from_value(point_value).unwrap();
+```
+
+Serialization without Macros
+============================
+
+Under the covers, Serde extensively uses the Visitor pattern to thread state
+between the
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+and
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+without the two having specific information about each other's concrete type.
+This has many of the same benefits as frameworks that use runtime type
+information without the overhead.  In fact, when compiling with optimizations,
+Rust is able to remove most or all the visitor state, and generate code that's
+nearly as fast as a hand written serializer format for a specific type.
+
+To see it in action, lets look at how a simple type like `i32` is serialized.
+The
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+is threaded through the type:
+
+```rust
+impl serde::Serialize for i32 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: serde::Serializer,
+    {
+        serializer.visit_i32(*self)
+    }
+}
+```
+
+As you can see it's pretty simple. More complex types like `BTreeMap` need to
+pass a
+[MapVisitor](http://serde-rs.github.io/serde/serde/ser/trait.MapVisitor.html)
+to the 
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+in order to walk through the type:
+
+```rust
+impl<K, V> Serialize for BTreeMap<K, V>
+    where K: Serialize + Ord,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+pub struct MapIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<K, V, Iter> MapIteratorVisitor<Iter>
+    where Iter: Iterator<Item=(K, V)>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
+        MapIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
+    where K: Serialize,
+          V: Serialize,
+          I: Iterator<Item=(K, V)>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                let value = try!(serializer.visit_map_elt(key, value));
+                Ok(Some(value))
+            }
+            None => Ok(None)
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+```
+
+Serializing structs follow this same pattern. In fact, structs are represented
+as a named map. It's visitor uses a simple state machine to iterate through all
+the fields:
+
+```rust
 struct Point {
     x: i32,
     y: i32,
 }
 
-fn main() {
-    let point = Point { x: 1, y: 2 };
+impl serde::Serialize for Point {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: serde::Serializer
+    {
+        serializer.visit_named_map("Point", PointMapVisitor {
+            value: self,
+            state: 0,
+        })
+    }
+}
 
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
+struct PointMapVisitor<'a> {
+    value: &'a Point,
+    state: u8,
+}
 
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
+impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: serde::Serializer
+    {
+        match self.state {
+            0 => {
+                self.state += 1;
+                Ok(Some(try!(serializer.visit_map_elt("x", &self.value.x))))
+            }
+            1 => {
+                self.state += 1;
+                Ok(Some(try!(serializer.visit_map_elt("y", &self.value.y))))
+            }
+            _ => {
+                Ok(None)
+            }
+        }
+    }
 }
 ```
 
-## Getting help
+Deserialization without Macros
+==============================
 
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#rust-questions] or [#rust-beginners] channels of the unofficial community
-Discord (invite: <https://discord.gg/rust-lang-community>), the [#rust-usage] or
-[#beginners] channels of the official Rust Project Discord (invite:
-<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
-asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
-[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
-[Discourse forum][discourse]. It's acceptable to file a support issue in this
-repo but they tend not to get as many eyes as any of the above and may get
-closed without a response after some time.
+Deserialization is a little more complicated since there's a bit more error
+handling that needs to occur. Let's start with the simple `i32`
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+implementation. It passes a
+[Visitor](http://serde-rs.github.io/serde/serde/de/trait.Visitor.html) to the
+[Deserializer](http://serde-rs.github.io/serde/serde/de/trait.Deserializer.html).
+The [Visitor](http://serde-rs.github.io/serde/serde/de/trait.Visitor.html)
+can create the `i32` from a variety of different types:
 
-[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
-[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org
+```rust
+impl Deserialize for i32 {
+    fn deserialize<D>(deserializer: &mut D) -> Result<i32, D::Error>
+        where D: serde::Deserializer,
+    {
+        deserializer.visit(I32Visitor)
+    }
+}
 
-<br>
+struct I32Visitor;
 
-#### License
+impl serde::de::Visitor for I32Visitor {
+    type Value = i32;
 
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
+    fn visit_i16<E>(&mut self, value: i16) -> Result<i16, E>
+        where E: Error,
+    {
+        self.visit_i32(value as i32)
+    }
 
-<br>
+    fn visit_i32<E>(&mut self, value: i32) -> Result<i32, E>
+        where E: Error,
+    {
+        Ok(value)
+    }
 
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
-</sub>
+    ...
+
+```
+
+Since it's possible for this type to get passed an unexpected type, we need a
+way to error out. This is done by way of the
+[Error](http://serde-rs.github.io/serde/serde/de/trait.Error.html) trait,
+which allows a 
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+to generate an error for a few common error conditions. Here's how it could be used:
+
+```rust
+    ...
+
+    fn visit_string<E>(&mut self, _: String) -> Result<i32, E>
+        where E: Error,
+    {
+        Err(serde::de::Error::syntax_error())
+    }
+
+    ...
+
+```
+
+Maps follow a similar pattern as before, and use a
+[MapVisitor](http://serde-rs.github.io/serde/serde/de/trait.MapVisitor.html)
+to walk through the values generated by the 
+[Deserializer](http://serde-rs.github.io/serde/serde/de/trait.Deserializer.html).
+
+```rust
+impl<K, V> serde::Deserialize for BTreeMap<K, V>
+    where K: serde::Deserialize + Eq + Ord,
+          V: serde::Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
+        where D: serde::Deserializer,
+    {
+        deserializer.visit(BTreeMapVisitor::new())
+    }
+}
+
+pub struct BTreeMapVisitor<K, V> {
+    marker: PhantomData<BTreeMap<K, V>>,
+}
+
+impl<K, V> BTreeMapVisitor<K, V> {
+    pub fn new() -> Self {
+        BTreeMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> serde::de::Visitor for BTreeMapVisitor<K, V>
+    where K: serde::de::Deserialize + Ord,
+          V: serde::de::Deserialize
+{
+    type Value = BTreeMap<K, V>;
+
+    fn visit_unit<E>(&mut self) -> Result<BTreeMap<K, V>, E>
+        where E: Error,
+    {
+        Ok(BTreeMap::new())
+    }
+
+    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<BTreeMap<K, V>, V_::Error>
+        where V_: MapVisitor,
+    {
+        let mut values = BTreeMap::new();
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+```
+
+Deserializing structs goes a step further in order to support not allocating a
+`String` to hold the field names. This is done by custom field enum that
+deserializes an enum variant from a string. So for our `Point` example from
+before, we need to generate:
+
+```rust
+enum PointField {
+    X,
+    Y,
+}
+
+impl serde::Deserialize for PointField {
+    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
+        where D: serde::de::Deserializer
+    {
+        struct FieldVisitor;
+
+        impl serde::de::Visitor for FieldVisitor {
+            type Value = Field;
+
+            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
+                where E: serde::de::Error
+            {
+                match value {
+                    "x" => Ok(Field::X),
+                    "y" => Ok(Field::Y),
+                    _ => Err(serde::de::Error::syntax_error()),
+                }
+            }
+        }
+
+        deserializer.visit(FieldVisitor)
+    }
+}
+```
+
+This is then used in our actual deserializer:
+
+```rust
+impl serde::Deserialize for Point {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
+        where D: serde::de::Deserializer
+    {
+        deserializer.visit_named_map("Point", PointVisitor)
+    }
+}
+
+struct PointVisitor;
+
+impl serde::de::Visitor for PointVisitor {
+    type Value = Point;
+
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
+        where V: serde::de::MapVisitor
+    {
+        let mut x = None;
+        let mut y = None;
+
+        loop {
+            match try!(visitor.visit_key()) {
+                Some(Field::X) => { x = Some(try!(visitor.visit_value())); }
+                Some(Field::Y) => { y = Some(try!(visitor.visit_value())); }
+                None => { break; }
+            }
+        }
+
+        let x = match x {
+            Some(x) => x,
+            None => try!(visitor.missing_field("x")),
+        };
+
+        let y = match y {
+            Some(y) => y,
+            None => try!(visitor.missing_field("y")),
+        };
+
+        try!(visitor.end());
+
+        Ok(Point{ x: x, y: y })
+    }
+}
+```

crates-io.md

@@ -1,65 +0,0 @@
-<!-- Serde readme rendered on crates.io -->
-
-**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
-
----
-
-You may be looking for:
-
-- [An overview of Serde](https://serde.rs)
-- [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
-- [Examples](https://serde.rs/examples.html)
-- [API documentation](https://docs.rs/serde)
-- [Release notes](https://github.com/serde-rs/serde/releases)
-
-## Serde in action
-
-```rust
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-
-    // Convert the Point to a JSON string.
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    // Prints serialized = {"x":1,"y":2}
-    println!("serialized = {}", serialized);
-
-    // Convert the JSON string back to a Point.
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    // Prints deserialized = Point { x: 1, y: 2 }
-    println!("deserialized = {:?}", deserialized);
-}
-```
-
-## Getting help
-
-Serde is one of the most widely used Rust libraries so any place that Rustaceans
-congregate will be able to help you out. For chat, consider trying the
-[#rust-questions] or [#rust-beginners] channels of the unofficial community
-Discord (invite: <https://discord.gg/rust-lang-community>), the [#rust-usage]
-or [#beginners] channels of the official Rust Project Discord (invite:
-<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
-asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
-[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
-[Discourse forum][discourse]. It's acceptable to file a support issue in this
-repo but they tend not to get as many eyes as any of the above and may get
-closed without a response after some time.
-
-[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
-[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
-[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
-[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
-[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
-[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
-[/r/rust]: https://www.reddit.com/r/rust
-[discourse]: https://users.rust-lang.org

serde/Cargo.toml

@@ -1,62 +1,13 @@
 [package]
 name = "serde"
-version = "1.0.228"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-build = "build.rs"
-categories = ["encoding", "no-std", "no-std::no-alloc"]
+version = "0.4.2"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
-documentation = "https://docs.rs/serde"
-edition = "2021"
-homepage = "https://serde.rs"
-keywords = ["serde", "serialization", "no_std"]
-license = "MIT OR Apache-2.0"
-readme = "crates-io.md"
 repository = "https://github.com/serde-rs/serde"
-rust-version = "1.56"
+documentation = "http://serde-rs.github.io/serde/serde"
+readme = "../README.md"
+keywords = ["serialization"]
 
 [dependencies]
-serde_core = { version = "=1.0.228", path = "../serde_core", default-features = false, features = ["result"] }
-serde_derive = { version = "1", optional = true, path = "../serde_derive" }
-
-[package.metadata.playground]
-features = ["derive", "rc"]
-
-[package.metadata.docs.rs]
-features = ["derive", "rc", "unstable"]
-targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = [
-    "--generate-link-to-definition",
-    "--generate-macro-expansion",
-    "--extern-html-root-url=core=https://doc.rust-lang.org",
-    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
-    "--extern-html-root-url=std=https://doc.rust-lang.org",
-]
-
-
-### FEATURES #################################################################
-
-[features]
-default = ["std"]
-
-# Provide derive(Serialize, Deserialize) macros.
-derive = ["serde_derive"]
-
-# Provide impls for common standard library types like Vec<T> and HashMap<K, V>.
-# Requires a dependency on the Rust standard library.
-std = ["serde_core/std"]
-
-# Provide impls for types that require unstable functionality. For tracking and
-# discussion of unstable functionality please refer to this issue:
-#
-#    https://github.com/serde-rs/serde/issues/812
-unstable = ["serde_core/unstable"]
-
-# Provide impls for types in the Rust core allocation and collections library
-# including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
-# be enabled without depending on all of std.
-alloc = ["serde_core/alloc"]
-
-# Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
-# does not preserve identity and may result in multiple copies of the same data.
-# Be sure that this is what you want before enabling this feature.
-rc = ["serde_core/rc"]
+num = "*"

serde/LICENSE-APACHE

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

serde/LICENSE-MIT

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

serde/README.md

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

serde/build.rs

@@ -1,69 +0,0 @@
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-use std::process::Command;
-use std::str;
-
-const PRIVATE: &str = "\
-#[doc(hidden)]
-pub mod __private$$ {
-    #[doc(hidden)]
-    pub use crate::private::*;
-}
-use serde_core::__private$$ as serde_core_private;
-";
-
-// The rustc-cfg strings below are *not* public API. Please let us know by
-// opening a GitHub issue if your build environment requires some way to enable
-// these cfgs other than by executing our build script.
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    println!("cargo:rustc-cfg=if_docsrs_then_no_serde_core");
-
-    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let patch_version = env::var("CARGO_PKG_VERSION_PATCH").unwrap();
-    let module = PRIVATE.replace("$$", &patch_version);
-    fs::write(out_dir.join("private.rs"), module).unwrap();
-
-    let minor = match rustc_minor_version() {
-        Some(minor) => minor,
-        None => return,
-    };
-
-    if minor >= 77 {
-        println!("cargo:rustc-check-cfg=cfg(feature, values(\"result\"))");
-        println!("cargo:rustc-check-cfg=cfg(if_docsrs_then_no_serde_core)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_cstr)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_error)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_net)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_num_saturating)");
-        println!("cargo:rustc-check-cfg=cfg(no_diagnostic_namespace)");
-        println!("cargo:rustc-check-cfg=cfg(no_serde_derive)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic64)");
-        println!("cargo:rustc-check-cfg=cfg(no_target_has_atomic)");
-    }
-
-    // Current minimum supported version of serde_derive crate is Rust 1.68.
-    if minor < 68 {
-        println!("cargo:rustc-cfg=no_serde_derive");
-    }
-
-    // Support for the `#[diagnostic]` tool attribute namespace
-    // https://blog.rust-lang.org/2024/05/02/Rust-1.78.0.html#diagnostic-attributes
-    if minor < 78 {
-        println!("cargo:rustc-cfg=no_diagnostic_namespace");
-    }
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    pieces.next()?.parse().ok()
-}

serde/crates-io.md

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

serde/src/buf.rs

@@ -0,0 +1,94 @@
+use std::cmp;
+use std::io;
+use std::slice;
+
+trait IntoBufRead {
+    type IntoBuf: io::BufRead + BufReadExt;
+
+    fn into_buf_read(self) -> Self::IntoBuf;
+}
+
+trait BufReadExt {
+    fn get_buf(&self) -> &[u8];
+    fn read_u8(&mut self) -> io::Result<Option<u8>>;
+}
+
+struct SliceReader<'a> {
+    buf: &'a [u8],
+}
+
+impl<'a> io::Read for SliceReader<'a> {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.buf.len());
+        let (a, b) = self.buf.split_at(amt);
+        slice::bytes::copy_memory(buf, a);
+        *self.buf = b;
+        Ok(amt)
+    }
+}
+
+impl<'a> io::BufRead for SliceReader<'a> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
+    fn consume(&mut self, amt: usize) { *self.buf = &self.buf[amt..]; }
+}
+
+impl<'a> BufReadExt for SliceReader<'a> {
+    fn get_buf(&self) -> &[u8] { self.buf }
+    fn read_u8(&mut self) -> io::Result<Option<u8>> {
+        let byte = self.buf.get(0);
+        *self.buf = &self.buf[1..];
+        byte
+    }
+}
+
+struct BufReader<R> {
+    inner: R,
+    buf: io::Cursor<Vec<u8>>,
+}
+
+impl<R> BufReader<R> where R: io::Read {
+    fn new(inner: R) -> Self {
+        BufferedReader::with_capacity(io::DEFAULT_BUF_SIZE, inner)
+    }
+
+    fn new(cap: usize, inner: R) -> Self {
+        BufferedReader {
+            inner: inner,
+            buf: io::Cursor::new(Vec::with_capacity(cap)),
+        }
+    }
+
+    fn into_inner(self) -> R {
+        self.inner
+    }
+}
+
+impl<R> Read for BufReader<R> where R: io::Read {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        // If we don't have any buffered data and we're doing a massive read
+        // (larger than our internal buffer), bypass our internal buffer
+        // entirely.
+        if self.buf.get_ref().len() == self.buf.position() as usize &&
+            buf.len() >= self.buf.get_ref().capacity() {
+            return self.inner.read(buf);
+        }
+        try!(self.fill_buf());
+        self.buf.read(buf)
+    }
+}
+
+impl<R> BufReadExt for BufReader<R> {
+    fn get_buf(&self) -> &[u8] {
+        self.buf.get_ref()
+    }
+
+    fn read_u8(&mut self) -> io::Result<Option<u8>> {
+        if self.buf.get_ref().len() == self.buf.position() as usize {
+
+        }
+        let byte = self.buf.get(0);
+        *self.buf = &self.buf[1..];
+        byte
+    }
+}

serde/src/bytes.rs

@@ -0,0 +1,213 @@
+//! Helper module to enable serializing bytes more efficiently
+
+use std::ops;
+use std::fmt;
+use std::ascii;
+
+use ser;
+use de;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `Bytes` wraps a `&[u8]` in order to serialize into a byte array.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct Bytes<'a> {
+    bytes: &'a [u8],
+}
+
+impl<'a> fmt::Debug for Bytes<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes))
+    }
+}
+
+impl<'a> From<&'a [u8]> for Bytes<'a> {
+    fn from(bytes: &'a [u8]) -> Self {
+        Bytes {
+            bytes: bytes,
+        }
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
+    fn from(bytes: &'a Vec<u8>) -> Self {
+        Bytes {
+            bytes: &bytes,
+        }
+    }
+}
+
+impl<'a> Into<&'a [u8]> for Bytes<'a> {
+    fn into(self) -> &'a [u8] {
+        self.bytes
+    }
+}
+
+impl<'a> ops::Deref for Bytes<'a> {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { self.bytes }
+}
+
+impl<'a> ser::Serialize for Bytes<'a> {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(self.bytes)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `ByteBuf` wraps a `Vec<u8>` in order to hook into serialize and from deserialize a byte array.
+#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ByteBuf {
+    bytes: Vec<u8>,
+}
+
+impl ByteBuf {
+    pub fn new() -> Self {
+        ByteBuf {
+            bytes: Vec::new(),
+        }
+    }
+
+    pub fn with_capacity(cap: usize) -> Self {
+        ByteBuf {
+            bytes: Vec::with_capacity(cap)
+        }
+    }
+}
+
+impl fmt::Debug for ByteBuf {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes.as_ref()))
+    }
+}
+
+impl Into<Vec<u8>> for ByteBuf {
+    fn into(self) -> Vec<u8> {
+        self.bytes
+    }
+}
+
+impl From<Vec<u8>> for ByteBuf {
+    fn from(bytes: Vec<u8>) -> Self {
+        ByteBuf {
+            bytes: bytes,
+        }
+    }
+}
+
+impl AsRef<Vec<u8>> for ByteBuf {
+    fn as_ref(&self) -> &Vec<u8> {
+        &self.bytes
+    }
+}
+
+impl AsRef<[u8]> for ByteBuf {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+impl AsMut<Vec<u8>> for ByteBuf {
+    fn as_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.bytes
+    }
+}
+
+impl AsMut<[u8]> for ByteBuf {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.bytes
+    }
+}
+
+impl ops::Deref for ByteBuf {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { &self.bytes[..] }
+}
+
+impl ops::DerefMut for ByteBuf {
+    fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
+}
+
+impl ser::Serialize for ByteBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(&self)
+    }
+}
+
+pub struct ByteBufVisitor;
+
+impl de::Visitor for ByteBufVisitor {
+    type Value = ByteBuf;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: Vec::new(),
+        })
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
+        where V: de::SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = Vec::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.push(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(ByteBuf {
+            bytes: values,
+        })
+    }
+
+    #[inline]
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        self.visit_byte_buf(v.to_vec())
+    }
+
+    #[inline]
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: v,
+        })
+    }
+}
+
+impl de::Deserialize for ByteBuf {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
+        where D: de::Deserializer
+    {
+        deserializer.visit_bytes(ByteBufVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+fn escape_bytestring(bytes: &[u8]) -> String {
+    let mut result = String::new();
+    for &b in bytes {
+        for esc in ascii::escape_default(b) {
+            result.push(esc as char);
+        }
+    }
+    result
+}

serde/src/core

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

serde/src/de/impls.rs

@@ -0,0 +1,856 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::hash::Hash;
+use std::marker::PhantomData;
+use std::path;
+use std::rc::Rc;
+use std::str;
+use std::sync::Arc;
+
+use num::FromPrimitive;
+
+use de::{
+    Deserialize,
+    Deserializer,
+    Error,
+    MapVisitor,
+    SeqVisitor,
+    Visitor,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct UnitVisitor;
+
+impl Visitor for UnitVisitor {
+    type Value = ();
+
+    fn visit_unit<E>(&mut self) -> Result<(), E>
+        where E: Error,
+    {
+        Ok(())
+    }
+
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), V::Error>
+        where V: SeqVisitor,
+    {
+        visitor.end()
+    }
+}
+
+impl Deserialize for () {
+    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(UnitVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct BoolVisitor;
+
+impl Visitor for BoolVisitor {
+    type Value = bool;
+
+    fn visit_bool<E>(&mut self, v: bool) -> Result<bool, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_str<E>(&mut self, s: &str) -> Result<bool, E>
+        where E: Error,
+    {
+        match s.trim() {
+            "true" => Ok(true),
+            "false" => Ok(false),
+            _ => Err(Error::syntax_error()),
+        }
+    }
+}
+
+impl Deserialize for bool {
+    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(BoolVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! impl_deserialize_num_method {
+    ($src_ty:ty, $method:ident, $from_method:ident) => {
+        #[inline]
+        fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
+            where E: Error,
+        {
+            match FromPrimitive::$from_method(v) {
+                Some(v) => Ok(v),
+                None => Err(Error::syntax_error()),
+            }
+        }
+    }
+}
+
+pub struct PrimitiveVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> PrimitiveVisitor<T> {
+    #[inline]
+    pub fn new() -> Self {
+        PrimitiveVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<
+    T: Deserialize + FromPrimitive + str::FromStr
+> Visitor for PrimitiveVisitor<T> {
+    type Value = T;
+
+    impl_deserialize_num_method!(isize, visit_isize, from_isize);
+    impl_deserialize_num_method!(i8, visit_i8, from_i8);
+    impl_deserialize_num_method!(i16, visit_i16, from_i16);
+    impl_deserialize_num_method!(i32, visit_i32, from_i32);
+    impl_deserialize_num_method!(i64, visit_i64, from_i64);
+    impl_deserialize_num_method!(usize, visit_usize, from_usize);
+    impl_deserialize_num_method!(u8, visit_u8, from_u8);
+    impl_deserialize_num_method!(u16, visit_u16, from_u16);
+    impl_deserialize_num_method!(u32, visit_u32, from_u32);
+    impl_deserialize_num_method!(u64, visit_u64, from_u64);
+    impl_deserialize_num_method!(f32, visit_f32, from_f32);
+    impl_deserialize_num_method!(f64, visit_f64, from_f64);
+
+    #[inline]
+    fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
+        where E: Error,
+    {
+        str::FromStr::from_str(v.trim()).or(Err(Error::syntax_error()))
+    }
+}
+
+macro_rules! impl_deserialize_num {
+    ($ty:ty) => {
+        impl Deserialize for $ty {
+            #[inline]
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.visit(PrimitiveVisitor::new())
+            }
+        }
+    }
+}
+
+impl_deserialize_num!(isize);
+impl_deserialize_num!(i8);
+impl_deserialize_num!(i16);
+impl_deserialize_num!(i32);
+impl_deserialize_num!(i64);
+impl_deserialize_num!(usize);
+impl_deserialize_num!(u8);
+impl_deserialize_num!(u16);
+impl_deserialize_num!(u32);
+impl_deserialize_num!(u64);
+impl_deserialize_num!(f32);
+impl_deserialize_num!(f64);
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct CharVisitor;
+
+impl Visitor for CharVisitor {
+    type Value = char;
+
+    #[inline]
+    fn visit_char<E>(&mut self, v: char) -> Result<char, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    #[inline]
+    fn visit_str<E>(&mut self, v: &str) -> Result<char, E>
+        where E: Error,
+    {
+        let mut iter = v.chars();
+        if let Some(v) = iter.next() {
+            if iter.next().is_some() {
+                Err(Error::syntax_error())
+            } else {
+                Ok(v)
+            }
+        } else {
+            Err(Error::end_of_stream_error())
+        }
+    }
+}
+
+impl Deserialize for char {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(CharVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct StringVisitor;
+
+impl Visitor for StringVisitor {
+    type Value = String;
+
+    fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(v.to_string())
+    }
+
+    fn visit_string<E>(&mut self, v: String) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
+        where E: Error,
+    {
+        match str::from_utf8(v) {
+            Ok(s) => Ok(s.to_string()),
+            Err(_) => Err(Error::syntax_error()),
+        }
+    }
+
+    fn visit_byte_buf<'a, E>(&mut self, v: Vec<u8>) -> Result<String, E>
+        where E: Error,
+    {
+        match String::from_utf8(v) {
+            Ok(s) => Ok(s),
+            Err(_) => Err(Error::syntax_error()),
+        }
+    }
+}
+
+impl Deserialize for String {
+    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(StringVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct OptionVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<
+    T: Deserialize,
+> Visitor for OptionVisitor<T> {
+    type Value = Option<T>;
+
+    #[inline]
+    fn visit_none<E>(&mut self) -> Result<Option<T>, E>
+        where E: Error,
+    {
+        Ok(None)
+    }
+
+    #[inline]
+    fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error>
+        where D: Deserializer,
+    {
+        Ok(Some(try!(Deserialize::deserialize(deserializer))))
+    }
+}
+
+impl<T> Deserialize for Option<T> where T: Deserialize {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_option(OptionVisitor { marker: PhantomData })
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct BTreeSetVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> BTreeSetVisitor<T> {
+    pub fn new() -> Self {
+        BTreeSetVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Visitor for BTreeSetVisitor<T>
+    where T: Deserialize + Eq + Ord,
+{
+    type Value = BTreeSet<T>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<BTreeSet<T>, E>
+        where E: Error,
+    {
+        Ok(BTreeSet::new())
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<BTreeSet<T>, V::Error>
+        where V: SeqVisitor,
+    {
+        let mut values = BTreeSet::new();
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.insert(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<T> Deserialize for BTreeSet<T>
+    where T: Deserialize + Eq + Ord,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeSet<T>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(BTreeSetVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct HashSetVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> HashSetVisitor<T> {
+    pub fn new() -> Self {
+        HashSetVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Visitor for HashSetVisitor<T>
+    where T: Deserialize + Eq + Hash,
+{
+    type Value = HashSet<T>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<HashSet<T>, E>
+        where E: Error,
+    {
+        Ok(HashSet::new())
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<HashSet<T>, V::Error>
+        where V: SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = HashSet::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.insert(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<T> Deserialize for HashSet<T>
+    where T: Deserialize + Eq + Hash,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<HashSet<T>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(HashSetVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct VecVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> VecVisitor<T> {
+    pub fn new() -> Self {
+        VecVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Visitor for VecVisitor<T> where T: Deserialize {
+    type Value = Vec<T>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<Vec<T>, E>
+        where E: Error,
+    {
+        Ok(Vec::new())
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error>
+        where V: SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = Vec::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.push(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<T> Deserialize for Vec<T>
+    where T: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_seq(VecVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct ArrayVisitor0<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> ArrayVisitor0<T> {
+    pub fn new() -> Self {
+        ArrayVisitor0 {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
+    type Value = [T; 0];
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<[T; 0], E>
+        where E: Error,
+    {
+        Ok([T::default(); 0])
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<[T; 0], V::Error>
+        where V: SeqVisitor,
+    {
+        try!(visitor.end());
+        Ok([T::default(); 0])
+    }
+}
+
+impl<T> Deserialize for [T; 0]
+    where T: Deserialize + Default
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(ArrayVisitor0::new())
+    }
+}
+
+macro_rules! array_impls {
+    ($($visitor:ident, $len:expr => ($($name:ident),+),)+) => {
+        $(
+            struct $visitor<T> {
+                marker: PhantomData<T>,
+            }
+
+            impl<T> $visitor<T> {
+                pub fn new() -> Self {
+                    $visitor {
+                        marker: PhantomData
+                    }
+                }
+            }
+
+            impl<T> Visitor for $visitor<T> where T: Deserialize {
+                type Value = [T; $len];
+
+                #[inline]
+                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<[T; $len], V::Error>
+                    where V: SeqVisitor,
+                {
+                    $(
+                        let $name = match try!(visitor.visit()) {
+                            Some(val) => val,
+                            None => { return Err(Error::end_of_stream_error()); }
+                        };
+                    )+;
+
+                    try!(visitor.end());
+
+                    Ok([$($name,)+])
+                }
+            }
+
+            impl<T> Deserialize for [T; $len]
+                where T: Deserialize,
+            {
+                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
+                    where D: Deserializer,
+                {
+                    deserializer.visit($visitor::new())
+                }
+            }
+        )+
+    }
+}
+
+array_impls! {
+    ArrayVisitor1, 1 => (a),
+    ArrayVisitor2, 2 => (a, b),
+    ArrayVisitor3, 3 => (a, b, c),
+    ArrayVisitor4, 4 => (a, b, c, d),
+    ArrayVisitor5, 5 => (a, b, c, d, e),
+    ArrayVisitor6, 6 => (a, b, c, d, e, f),
+    ArrayVisitor7, 7 => (a, b, c, d, e, f, g),
+    ArrayVisitor8, 8 => (a, b, c, d, e, f, g, h),
+    ArrayVisitor9, 9 => (a, b, c, d, e, f, g, h, i),
+    ArrayVisitor10, 10 => (a, b, c, d, e, f, g, h, i, j),
+    ArrayVisitor11, 11 => (a, b, c, d, e, f, g, h, i, j, k),
+    ArrayVisitor12, 12 => (a, b, c, d, e, f, g, h, i, j, k, l),
+    ArrayVisitor13, 13 => (a, b, c, d, e, f, g, h, i, j, k, l, m),
+    ArrayVisitor14, 14 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n),
+    ArrayVisitor15, 15 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o),
+    ArrayVisitor16, 16 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p),
+    ArrayVisitor17, 17 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q),
+    ArrayVisitor18, 18 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r),
+    ArrayVisitor19, 19 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s),
+    ArrayVisitor20, 20 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s ,t),
+    ArrayVisitor21, 21 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u),
+    ArrayVisitor22, 22 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v),
+    ArrayVisitor23, 23 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w),
+    ArrayVisitor24, 24 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x),
+    ArrayVisitor25, 25 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y),
+    ArrayVisitor26, 26 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z),
+    ArrayVisitor27, 27 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa),
+    ArrayVisitor28, 28 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab),
+    ArrayVisitor29, 29 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac),
+    ArrayVisitor30, 30 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad),
+    ArrayVisitor31, 31 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad, ae),
+    ArrayVisitor32, 32 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad, ae, af),
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! tuple_impls {
+    () => {};
+    ($($visitor:ident => ($($name:ident),+),)+) => {
+        $(
+            struct $visitor<$($name,)+> {
+                marker: PhantomData<($($name,)+)>,
+            }
+
+            impl<
+                $($name: Deserialize,)+
+            > Visitor for $visitor<$($name,)+> {
+                type Value = ($($name,)+);
+
+                #[inline]
+                #[allow(non_snake_case)]
+                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error>
+                    where V: SeqVisitor,
+                {
+                    $(
+                        let $name = match try!(visitor.visit()) {
+                            Some(value) => value,
+                            None => { return Err(Error::end_of_stream_error()); }
+                        };
+                     )+;
+
+                    try!(visitor.end());
+
+                    Ok(($($name,)+))
+                }
+            }
+
+            impl<
+                $($name: Deserialize),+
+            > Deserialize for ($($name,)+) {
+                #[inline]
+                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
+                    where D: Deserializer,
+                {
+                    deserializer.visit_seq($visitor { marker: PhantomData })
+                }
+            }
+        )+
+    }
+}
+
+tuple_impls! {
+    TupleVisitor1 => (T0),
+    TupleVisitor2 => (T0, T1),
+    TupleVisitor3 => (T0, T1, T2),
+    TupleVisitor4 => (T0, T1, T2, T3),
+    TupleVisitor5 => (T0, T1, T2, T3, T4),
+    TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
+    TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
+    TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
+    TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
+    TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+    TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
+    TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct BTreeMapVisitor<K, V> {
+    marker: PhantomData<BTreeMap<K, V>>,
+}
+
+impl<K, V> BTreeMapVisitor<K, V> {
+    #[inline]
+    pub fn new() -> Self {
+        BTreeMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> Visitor for BTreeMapVisitor<K, V>
+    where K: Deserialize + Ord,
+          V: Deserialize
+{
+    type Value = BTreeMap<K, V>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<BTreeMap<K, V>, E>
+        where E: Error,
+    {
+        Ok(BTreeMap::new())
+    }
+
+    #[inline]
+    fn visit_map<Visitor>(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, Visitor::Error>
+        where Visitor: MapVisitor,
+    {
+        let mut values = BTreeMap::new();
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<K, V> Deserialize for BTreeMap<K, V>
+    where K: Deserialize + Eq + Ord,
+          V: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(BTreeMapVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct HashMapVisitor<K, V> {
+    marker: PhantomData<HashMap<K, V>>,
+}
+
+impl<K, V> HashMapVisitor<K, V> {
+    #[inline]
+    pub fn new() -> Self {
+        HashMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> Visitor for HashMapVisitor<K, V>
+    where K: Deserialize + Eq + Hash,
+          V: Deserialize,
+{
+    type Value = HashMap<K, V>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<HashMap<K, V>, E>
+        where E: Error,
+    {
+        Ok(HashMap::new())
+    }
+
+    #[inline]
+    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<HashMap<K, V>, V_::Error>
+        where V_: MapVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = HashMap::with_capacity(len);
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<K, V> Deserialize for HashMap<K, V>
+    where K: Deserialize + Eq + Hash,
+          V: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(HashMapVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// FIXME: `VecMap` is unstable.
+/*
+pub struct VecMapVisitor<V> {
+    marker: PhantomData<VecMap<V>>,
+}
+
+impl<V> VecMapVisitor<V> {
+    #[inline]
+    pub fn new() -> Self {
+        VecMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<V> Visitor for VecMapVisitor<V>
+    where V: Deserialize,
+{
+    type Value = VecMap<V>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<VecMap<V>, E>
+        where E: Error,
+    {
+        Ok(VecMap::new())
+    }
+
+    #[inline]
+    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<VecMap<V>, V_::Error>
+        where V_: MapVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = VecMap::with_capacity(len);
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+impl<V> Deserialize for VecMap<V>
+    where V: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<VecMap<V>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(VecMapVisitor::new())
+    }
+}
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct PathBufVisitor;
+
+impl Visitor for PathBufVisitor {
+    type Value = path::PathBuf;
+
+    fn visit_str<E>(&mut self, v: &str) -> Result<path::PathBuf, E>
+        where E: Error,
+    {
+        Ok(From::from(v))
+    }
+
+    fn visit_string<E>(&mut self, v: String) -> Result<path::PathBuf, E>
+        where E: Error,
+    {
+        self.visit_str(&v)
+    }
+}
+
+impl Deserialize for path::PathBuf {
+    fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(PathBufVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T: Deserialize> Deserialize for Box<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Box::new(val))
+    }
+}
+
+impl<T: Deserialize> Deserialize for Arc<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Arc::new(val))
+    }
+}
+
+impl<T: Deserialize> Deserialize for Rc<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Rc::new(val))
+    }
+}

serde/src/de/mod.rs

@@ -0,0 +1,478 @@
+//! Generic deserialization framework.
+
+pub mod impls;
+pub mod value;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Error {
+    fn syntax_error() -> Self;
+
+    fn end_of_stream_error() -> Self;
+
+    fn unknown_field_error(field: &str) -> Self;
+
+    fn missing_field_error(field: &'static str) -> Self;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Deserialize {
+    /// Deserialize this value given this `Deserializer`.
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `Deserializer` is an abstract trait that can deserialize values into a `Visitor`.
+pub trait Deserializer {
+    type Error: Error;
+
+    /// The `visit` method walks a visitor through a value as it is being deserialized.
+    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor;
+
+    /// The `visit_option` method allows a `Deserialize` type to inform the `Deserializer` that
+    /// it's expecting an optional value. This allows deserializers that encode an optional value
+    /// as a nullable value to convert the null value into a `None`, and a regular value as
+    /// `Some(value)`.
+    #[inline]
+    fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// The `visit_seq` method allows a `Deserialize` type to inform the `Deserializer` that it's
+    /// expecting a sequence of values. This allows deserializers to parse sequences that aren't
+    /// tagged as sequences.
+    #[inline]
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// The `visit_map` method allows a `Deserialize` type to inform the `Deserializer` that it's
+    /// expecting a map of values. This allows deserializers to parse sequences that aren't tagged
+    /// as maps.
+    #[inline]
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// The `visit_named_unit` method allows a `Deserialize` type to inform the `Deserializer` that
+    /// it's expecting a named unit. This allows deserializers to a named unit that aren't tagged
+    /// as a named unit.
+    #[inline]
+    fn visit_named_unit<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// The `visit_named_seq` method allows a `Deserialize` type to inform the `Deserializer` that
+    /// it's expecting a named sequence of values. This allows deserializers to parse sequences
+    /// that aren't tagged as sequences.
+    #[inline]
+    fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    /// The `visit_named_map` method allows a `Deserialize` type to inform the `Deserializer` that
+    /// it's expecting a map of values. This allows deserializers to parse sequences that aren't
+    /// tagged as maps.
+    #[inline]
+    fn visit_named_map<V>(&mut self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    /// The `visit_enum` method allows a `Deserialize` type to inform the `Deserializer` that it's
+    /// expecting an enum value. This allows deserializers that provide a custom enumeration
+    /// serialization to properly deserialize the type.
+    #[inline]
+    fn visit_enum<V>(&mut self, _enum: &str, _visitor: V) -> Result<V::Value, Self::Error>
+        where V: EnumVisitor,
+    {
+        Err(Error::syntax_error())
+    }
+
+    /// The `visit_bytes` method allows a `Deserialize` type to inform the `Deserializer` that it's
+    /// expecting a `Vec<u8>`. This allows deserializers that provide a custom byte vector
+    /// serialization to properly deserialize the type.
+    #[inline]
+    fn visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// Specify a format string for the deserializer.
+    ///
+    /// The deserializer format is used to determine which format
+    /// specific field attributes should be used with the
+    /// deserializer.
+    fn format() -> &'static str {
+        ""
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Visitor {
+    type Value: Deserialize;
+
+    fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_f64(v as f64)
+    }
+
+    fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    #[inline]
+    fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.visit_string(v.to_string())
+    }
+
+    fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    #[inline]
+    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_str(&v)
+    }
+
+    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    #[inline]
+    fn visit_named_unit<E>(&mut self, _name: &str) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_unit()
+    }
+
+    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
+        where D: Deserializer,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
+        where V: SeqVisitor,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
+        where V: MapVisitor,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_bytes<E>(&mut self, _v: &[u8]) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax_error())
+    }
+
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_bytes(&v)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait SeqVisitor {
+    type Error: Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: Deserialize;
+
+    fn end(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+}
+
+impl<'a, V> SeqVisitor for &'a mut V where V: SeqVisitor {
+    type Error = V::Error;
+
+    #[inline]
+    fn visit<T>(&mut self) -> Result<Option<T>, V::Error>
+        where T: Deserialize
+    {
+        (**self).visit()
+    }
+
+    #[inline]
+    fn end(&mut self) -> Result<(), V::Error> {
+        (**self).end()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (**self).size_hint()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait MapVisitor {
+    type Error: Error;
+
+    #[inline]
+    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
+        where K: Deserialize,
+              V: Deserialize,
+    {
+        match try!(self.visit_key()) {
+            Some(key) => {
+                let value = try!(self.visit_value());
+                Ok(Some((key, value)))
+            }
+            None => Ok(None)
+        }
+    }
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
+        where K: Deserialize;
+
+    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize;
+
+    fn end(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+
+    fn missing_field<V>(&mut self, field: &'static str) -> Result<V, Self::Error>
+        where V: Deserialize,
+    {
+        Err(Error::missing_field_error(field))
+    }
+}
+
+impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
+    type Error = V_::Error;
+
+    #[inline]
+    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, V_::Error>
+        where K: Deserialize,
+              V: Deserialize,
+    {
+        (**self).visit()
+    }
+
+    #[inline]
+    fn visit_key<K>(&mut self) -> Result<Option<K>, V_::Error>
+        where K: Deserialize
+    {
+        (**self).visit_key()
+    }
+
+    #[inline]
+    fn visit_value<V>(&mut self) -> Result<V, V_::Error>
+        where V: Deserialize
+    {
+        (**self).visit_value()
+    }
+
+    #[inline]
+    fn end(&mut self) -> Result<(), V_::Error> {
+        (**self).end()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (**self).size_hint()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `EnumVisitor` is a visitor that is created by the `Deserialize` and passed to the
+/// `Deserializer` in order to deserialize enums.
+pub trait EnumVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: VariantVisitor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `VariantVisitor` is a visitor that is created by the `Deserializer` and passed to the
+/// `Deserialize` in order to deserialize a specific enum variant.
+pub trait VariantVisitor {
+    type Error: Error;
+
+    /// `visit_variant` is called to identify which variant to deserialize.
+    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize;
+
+    /// `visit_unit` is called when deserializing a variant with no values.
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        Err(Error::syntax_error())
+    }
+
+    /// `visit_seq` is called when deserializing a tuple-like variant.
+    fn visit_seq<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        Err(Error::syntax_error())
+    }
+
+    /// `visit_map` is called when deserializing a struct-like variant.
+    fn visit_map<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        Err(Error::syntax_error())
+    }
+}
+
+impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
+    type Error = T::Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, T::Error>
+        where V: Deserialize
+    {
+        (**self).visit_variant()
+    }
+
+    fn visit_unit(&mut self) -> Result<(), T::Error> {
+        (**self).visit_unit()
+    }
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, T::Error>
+        where V: Visitor,
+    {
+        (**self).visit_seq(visitor)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, T::Error>
+        where V: Visitor,
+    {
+        (**self).visit_map(visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait EnumSeqVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: SeqVisitor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait EnumMapVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: MapVisitor;
+}

serde/src/de/value.rs

@@ -0,0 +1,465 @@
+use std::collections::{
+    BTreeMap,
+    BTreeSet,
+    HashMap,
+    HashSet,
+    btree_map,
+    btree_set,
+    hash_map,
+    hash_set,
+};
+use std::hash::Hash;
+use std::vec;
+
+use de;
+use bytes;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub enum Error {
+    SyntaxError,
+    EndOfStreamError,
+    UnknownFieldError(String),
+    MissingFieldError(&'static str),
+}
+
+impl de::Error for Error {
+    fn syntax_error() -> Self { Error::SyntaxError }
+    fn end_of_stream_error() -> Self { Error::EndOfStreamError }
+    fn unknown_field_error(field: &str) -> Self { Error::UnknownFieldError(field.to_string()) }
+    fn missing_field_error(field: &'static str) -> Self { Error::MissingFieldError(field) }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait ValueDeserializer {
+    type Deserializer: de::Deserializer<Error=Error>;
+
+    fn into_deserializer(self) -> Self::Deserializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl ValueDeserializer for () {
+    type Deserializer = UnitDeserializer;
+
+    fn into_deserializer(self) -> UnitDeserializer {
+        UnitDeserializer
+    }
+}
+
+/// A helper deserializer that deserializes a `()`.
+pub struct UnitDeserializer;
+
+impl de::Deserializer for UnitDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_unit()
+    }
+
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_none()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! primitive_deserializer {
+    ($ty:ty, $name:ident, $method:ident) => {
+        pub struct $name(Option<$ty>);
+
+        impl ValueDeserializer for $ty {
+            type Deserializer = $name;
+
+            fn into_deserializer(self) -> $name {
+                $name(Some(self))
+            }
+        }
+
+        impl de::Deserializer for $name {
+            type Error = Error;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                match self.0.take() {
+                    Some(v) => visitor.$method(v),
+                    None => Err(de::Error::end_of_stream_error()),
+                }
+            }
+        }
+    }
+}
+
+primitive_deserializer!(bool, BoolDeserializer, visit_bool);
+primitive_deserializer!(i8, I8Deserializer, visit_i8);
+primitive_deserializer!(i16, I16Deserializer, visit_i16);
+primitive_deserializer!(i32, I32Deserializer, visit_i32);
+primitive_deserializer!(i64, I64Deserializer, visit_i64);
+primitive_deserializer!(isize, IsizeDeserializer, visit_isize);
+primitive_deserializer!(u8, U8Deserializer, visit_u8);
+primitive_deserializer!(u16, U16Deserializer, visit_u16);
+primitive_deserializer!(u32, U32Deserializer, visit_u32);
+primitive_deserializer!(u64, U64Deserializer, visit_u64);
+primitive_deserializer!(usize, UsizeDeserializer, visit_usize);
+primitive_deserializer!(f32, F32Deserializer, visit_f32);
+primitive_deserializer!(f64, F64Deserializer, visit_f64);
+primitive_deserializer!(char, CharDeserializer, visit_char);
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// A helper deserializer that deserializes a `&str`.
+pub struct StrDeserializer<'a>(Option<&'a str>);
+
+impl<'a> ValueDeserializer for &'a str {
+    type Deserializer = StrDeserializer<'a>;
+
+    fn into_deserializer(self) -> StrDeserializer<'a> {
+        StrDeserializer(Some(self))
+    }
+}
+
+impl<'a> de::Deserializer for StrDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(v) => visitor.visit_str(v),
+            None => Err(de::Error::end_of_stream_error()),
+        }
+    }
+
+    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+}
+
+impl<'a> de::VariantVisitor for StrDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// A helper deserializer that deserializes a `String`.
+pub struct StringDeserializer(Option<String>);
+
+impl ValueDeserializer for String {
+    type Deserializer = StringDeserializer;
+
+    fn into_deserializer(self) -> StringDeserializer {
+        StringDeserializer(Some(self))
+    }
+}
+
+impl de::Deserializer for StringDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(string) => visitor.visit_string(string),
+            None => Err(de::Error::end_of_stream_error()),
+        }
+    }
+
+    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+}
+
+impl<'a> de::VariantVisitor for StringDeserializer {
+    type Error = Error;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct SeqDeserializer<I> {
+    iter: I,
+    len: usize,
+}
+
+impl<I> SeqDeserializer<I> {
+    pub fn new(iter: I, len: usize) -> Self {
+        SeqDeserializer {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<I, T> de::Deserializer for SeqDeserializer<I>
+    where I: Iterator<Item=T>,
+          T: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_seq(self)
+    }
+}
+
+impl<I, T> de::SeqVisitor for SeqDeserializer<I>
+    where I: Iterator<Item=T>,
+          T: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self) -> Result<Option<V>, Error>
+        where V: de::Deserialize
+    {
+        match self.iter.next() {
+            Some(value) => {
+                self.len -= 1;
+                let mut de = value.into_deserializer();
+                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream_error())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> ValueDeserializer for Vec<T>
+    where T: ValueDeserializer,
+{
+    type Deserializer = SeqDeserializer<vec::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<vec::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<T> ValueDeserializer for BTreeSet<T>
+    where T: ValueDeserializer + Eq + Ord,
+{
+    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<btree_set::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<T> ValueDeserializer for HashSet<T>
+    where T: ValueDeserializer + Eq + Hash,
+{
+    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<hash_set::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    iter: I,
+    value: Option<V>,
+    len: usize,
+}
+
+impl<I, K, V> MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    pub fn new(iter: I, len: usize) -> Self {
+        MapDeserializer {
+            iter: iter,
+            value: None,
+            len: len,
+        }
+    }
+}
+
+impl<I, K, V> de::Deserializer for MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Error>
+        where V_: de::Visitor,
+    {
+        visitor.visit_map(self)
+    }
+}
+
+impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.len -= 1;
+                self.value = Some(value);
+                let mut de = key.into_deserializer();
+                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        match self.value.take() {
+            Some(value) => {
+                let mut de = value.into_deserializer();
+                de::Deserialize::deserialize(&mut de)
+            }
+            None => Err(de::Error::syntax_error())
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream_error())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<K, V> ValueDeserializer for BTreeMap<K, V>
+    where K: ValueDeserializer + Eq + Ord,
+          V: ValueDeserializer,
+{
+    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V>;
+
+    fn into_deserializer(self) -> MapDeserializer<btree_map::IntoIter<K, V>, K, V> {
+        let len = self.len();
+        MapDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<K, V> ValueDeserializer for HashMap<K, V>
+    where K: ValueDeserializer + Eq + Hash,
+          V: ValueDeserializer,
+{
+    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V>;
+
+    fn into_deserializer(self) -> MapDeserializer<hash_map::IntoIter<K, V>, K, V> {
+        let len = self.len();
+        MapDeserializer::new(self.into_iter(), len)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a> ValueDeserializer for bytes::Bytes<'a>
+{
+    type Deserializer = BytesDeserializer<'a>;
+
+    fn into_deserializer(self) -> BytesDeserializer<'a> {
+        BytesDeserializer(Some(self.into()))
+    }
+}
+
+pub struct BytesDeserializer<'a> (Option<&'a [u8]>);
+
+impl<'a> de::Deserializer for BytesDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(bytes) => visitor.visit_bytes(bytes),
+            None => Err(de::Error::end_of_stream_error()),
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl ValueDeserializer for bytes::ByteBuf
+{
+    type Deserializer = ByteBufDeserializer;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        ByteBufDeserializer(Some(self.into()))
+    }
+}
+
+pub struct ByteBufDeserializer(Option<Vec<u8>>);
+
+impl de::Deserializer for ByteBufDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(bytes) => visitor.visit_byte_buf(bytes),
+            None => Err(de::Error::end_of_stream_error()),
+        }
+    }
+}

serde/src/integer128.rs

@@ -1,14 +0,0 @@
-#[macro_export]
-#[deprecated = "
-This macro has no effect on any version of Serde released in the past 2 years.
-It was used long ago in crates that needed to support Rustc older than 1.26.0,
-or Emscripten targets older than 1.40.0, which did not yet have 128-bit integer
-support. These days Serde requires a Rust compiler newer than that so 128-bit
-integers are always supported.
-"]
-#[doc(hidden)]
-macro_rules! serde_if_integer128 {
-    ($($tt:tt)*) => {
-        $($tt)*
-    };
-}

serde/src/iter.rs

@@ -0,0 +1,57 @@
+use std::io;
+use std::iter::Peekable;
+
+pub struct LineColIterator<Iter: Iterator<Item=io::Result<u8>>> {
+    iter: Iter,
+    line: usize,
+    col: usize,
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Iter> {
+    pub fn new(iter: Iter) -> LineColIterator<Iter> {
+        LineColIterator {
+            iter: iter,
+            line: 1,
+            col: 0,
+        }
+    }
+
+    /// Report the current line inside the iterator.
+    pub fn line(&self) -> usize { self.line }
+
+    /// Report the current column inside the iterator.
+    pub fn col(&self) -> usize { self.col }
+
+    /// Gets a reference to the underlying iterator.
+    pub fn get_ref(&self) -> &Iter { &self.iter }
+
+    /// Gets a mutable reference to the underlying iterator.
+    pub fn get_mut(&mut self) -> &mut Iter { &mut self.iter }
+
+    /// Unwraps this `LineColIterator`, returning the underlying iterator.
+    pub fn into_inner(self) -> Iter { self.iter }
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Peekable<Iter>> {
+    /// peeks at the next value
+    pub fn peek(&mut self) -> Option<&io::Result<u8>> { self.iter.peek() }
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> Iterator for LineColIterator<Iter> {
+    type Item = io::Result<u8>;
+    fn next(&mut self) -> Option<io::Result<u8>> {
+        match self.iter.next() {
+            None => None,
+            Some(Ok(b'\n')) => {
+                self.line += 1;
+                self.col = 0;
+                Some(Ok(b'\n'))
+            },
+            Some(Ok(c)) => {
+                self.col += 1;
+                Some(Ok(c))
+            },
+            Some(Err(e)) => Some(Err(e)),
+        }
+    }
+}

serde/src/json/builder.rs

@@ -0,0 +1,84 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::BTreeMap;
+
+use ser::{self, Serialize};
+use json::value::{self, Value};
+
+pub struct ArrayBuilder {
+    array: Vec<Value>,
+}
+
+impl ArrayBuilder {
+    pub fn new() -> ArrayBuilder {
+        ArrayBuilder { array: Vec::new() }
+    }
+
+    pub fn unwrap(self) -> Value {
+        Value::Array(self.array)
+    }
+
+    pub fn push<T: ser::Serialize>(mut self, v: T) -> ArrayBuilder {
+        self.array.push(value::to_value(&v));
+        self
+    }
+
+    pub fn push_array<F>(mut self, f: F) -> ArrayBuilder where
+        F: FnOnce(ArrayBuilder) -> ArrayBuilder
+    {
+        let builder = ArrayBuilder::new();
+        self.array.push(f(builder).unwrap());
+        self
+    }
+
+    pub fn push_object<F>(mut self, f: F) -> ArrayBuilder where
+        F: FnOnce(ObjectBuilder) -> ObjectBuilder
+    {
+        let builder = ObjectBuilder::new();
+        self.array.push(f(builder).unwrap());
+        self
+    }
+}
+
+pub struct ObjectBuilder {
+    object: BTreeMap<String, Value>,
+}
+
+impl ObjectBuilder {
+    pub fn new() -> ObjectBuilder {
+        ObjectBuilder { object: BTreeMap::new() }
+    }
+
+    pub fn unwrap(self) -> Value {
+        Value::Object(self.object)
+    }
+
+    pub fn insert<V: ser::Serialize>(mut self, k: String, v: V) -> ObjectBuilder {
+        self.object.insert(k, value::to_value(&v));
+        self
+    }
+
+    pub fn insert_array<F>(mut self, key: String, f: F) -> ObjectBuilder where
+        F: FnOnce(ArrayBuilder) -> ArrayBuilder
+    {
+        let builder = ArrayBuilder::new();
+        self.object.insert(key, f(builder).unwrap());
+        self
+    }
+
+    pub fn insert_object<F>(mut self, key: String, f: F) -> ObjectBuilder where
+        F: FnOnce(ObjectBuilder) -> ObjectBuilder
+    {
+        let builder = ObjectBuilder::new();
+        self.object.insert(key, f(builder).unwrap());
+        self
+    }
+}

serde/src/json/de.rs

@@ -0,0 +1,694 @@
+use std::char;
+use std::i32;
+use std::io;
+use std::str;
+
+use de;
+use iter::LineColIterator;
+
+use super::error::{Error, ErrorCode};
+
+pub struct Deserializer<Iter: Iterator<Item=io::Result<u8>>> {
+    rdr: LineColIterator<Iter>,
+    ch: Option<u8>,
+    str_buf: Vec<u8>,
+}
+
+macro_rules! try_or_invalid {
+    ($self_:expr, $e:expr) => {
+        match $e {
+            Some(v) => v,
+            None => { return Err($self_.error(ErrorCode::InvalidNumber)); }
+        }
+    }
+}
+
+impl<Iter> Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    /// Creates the JSON parser from an `std::iter::Iterator`.
+    #[inline]
+    pub fn new(rdr: Iter) -> Result<Deserializer<Iter>, Error> {
+        let mut deserializer = Deserializer {
+            rdr: LineColIterator::new(rdr),
+            ch: None,
+            str_buf: Vec::with_capacity(128),
+        };
+
+        try!(deserializer.bump());
+
+        Ok(deserializer)
+    }
+
+    #[inline]
+    pub fn end(&mut self) -> Result<(), Error> {
+        try!(self.parse_whitespace());
+        if self.eof() {
+            Ok(())
+        } else {
+            Err(self.error(ErrorCode::TrailingCharacters))
+        }
+    }
+
+    fn eof(&self) -> bool { self.ch.is_none() }
+
+    fn ch_or_null(&self) -> u8 { self.ch.unwrap_or(b'\x00') }
+
+    fn bump(&mut self) -> Result<(), Error> {
+        self.ch = match self.rdr.next() {
+            Some(Err(err)) => { return Err(Error::IoError(err)); }
+            Some(Ok(ch)) => Some(ch),
+            None => None,
+        };
+
+        Ok(())
+    }
+
+    fn next_char(&mut self) -> Result<Option<u8>, Error> {
+        try!(self.bump());
+        Ok(self.ch)
+    }
+
+    fn ch_is(&self, c: u8) -> bool {
+        self.ch == Some(c)
+    }
+
+    fn error(&mut self, reason: ErrorCode) -> Error {
+        Error::SyntaxError(reason, self.rdr.line(), self.rdr.col())
+    }
+
+    fn parse_whitespace(&mut self) -> Result<(), Error> {
+        while self.ch_is(b' ') ||
+              self.ch_is(b'\n') ||
+              self.ch_is(b'\t') ||
+              self.ch_is(b'\r') { try!(self.bump()); }
+
+        Ok(())
+    }
+
+    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        try!(self.parse_whitespace());
+
+        if self.eof() {
+            return Err(self.error(ErrorCode::EOFWhileParsingValue));
+        }
+
+        let value = match self.ch_or_null() {
+            b'n' => {
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_unit()
+            }
+            b't' => {
+                try!(self.parse_ident(b"rue"));
+                visitor.visit_bool(true)
+            }
+            b'f' => {
+                try!(self.parse_ident(b"alse"));
+                visitor.visit_bool(false)
+            }
+            b'0' ... b'9' | b'-' => self.parse_number(visitor),
+            b'"' => {
+                try!(self.parse_string());
+                let s = str::from_utf8(&self.str_buf).unwrap();
+                visitor.visit_str(s)
+            }
+            b'[' => {
+                try!(self.bump());
+                visitor.visit_seq(SeqVisitor::new(self))
+            }
+            b'{' => {
+                try!(self.bump());
+                visitor.visit_map(MapVisitor::new(self))
+            }
+            _ => {
+                Err(self.error(ErrorCode::ExpectedSomeValue))
+            }
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(Error::SyntaxError(code, _, _)) => Err(self.error(code)),
+            Err(err) => Err(err),
+        }
+    }
+
+    fn parse_ident(&mut self, ident: &[u8]) -> Result<(), Error> {
+        for c in ident {
+            if Some(*c) != try!(self.next_char()) {
+                return Err(self.error(ErrorCode::ExpectedSomeIdent));
+            }
+        }
+
+        try!(self.bump());
+        Ok(())
+    }
+
+    fn parse_number<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        let mut neg = false;
+
+        if self.ch_is(b'-') {
+            try!(self.bump());
+            neg = true;
+        }
+
+        let res = try!(self.parse_integer());
+
+        if self.ch_is(b'.') || self.ch_is(b'e') || self.ch_is(b'E') {
+            let mut res = res as f64;
+
+            if self.ch_is(b'.') {
+                res = try!(self.parse_decimal(res));
+            }
+
+            if self.ch_is(b'e') || self.ch_is(b'E') {
+                res = try!(self.parse_exponent(res));
+            }
+
+            if neg {
+                visitor.visit_f64(-res)
+            } else {
+                visitor.visit_f64(res)
+            }
+        } else {
+            if neg {
+                let res = -(res as i64);
+
+                // Make sure we didn't underflow.
+                if res > 0 {
+                    Err(self.error(ErrorCode::InvalidNumber))
+                } else {
+                    visitor.visit_i64(res)
+                }
+            } else {
+                visitor.visit_u64(res)
+            }
+        }
+    }
+
+    fn parse_integer(&mut self) -> Result<u64, Error> {
+        let mut accum: u64 = 0;
+
+        match self.ch_or_null() {
+            b'0' => {
+                try!(self.bump());
+
+                // There can be only one leading '0'.
+                match self.ch_or_null() {
+                    b'0' ... b'9' => {
+                        return Err(self.error(ErrorCode::InvalidNumber));
+                    }
+                    _ => ()
+                }
+            },
+            b'1' ... b'9' => {
+                while !self.eof() {
+                    match self.ch_or_null() {
+                        c @ b'0' ... b'9' => {
+                            accum = try_or_invalid!(self, accum.checked_mul(10));
+                            accum = try_or_invalid!(self, accum.checked_add((c as u64) - ('0' as u64)));
+
+                            try!(self.bump());
+                        }
+                        _ => break,
+                    }
+                }
+            }
+            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
+        }
+
+        Ok(accum)
+    }
+
+    fn parse_decimal(&mut self, res: f64) -> Result<f64, Error> {
+        try!(self.bump());
+
+        // Make sure a digit follows the decimal place.
+        match self.ch_or_null() {
+            b'0' ... b'9' => (),
+             _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
+        }
+
+        let mut res = res;
+        let mut dec = 1.0;
+        while !self.eof() {
+            match self.ch_or_null() {
+                c @ b'0' ... b'9' => {
+                    dec /= 10.0;
+                    res += (((c as u64) - (b'0' as u64)) as f64) * dec;
+                    try!(self.bump());
+                }
+                _ => break,
+            }
+        }
+
+        Ok(res)
+    }
+
+    fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
+        try!(self.bump());
+
+        let mut exp: u64 = 0;
+        let mut neg_exp = false;
+
+        if self.ch_is(b'+') {
+            try!(self.bump());
+        } else if self.ch_is(b'-') {
+            try!(self.bump());
+            neg_exp = true;
+        }
+
+        // Make sure a digit follows the exponent place.
+        match self.ch_or_null() {
+            b'0' ... b'9' => (),
+            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
+        }
+        while !self.eof() {
+            match self.ch_or_null() {
+                c @ b'0' ... b'9' => {
+                    exp = try_or_invalid!(self, exp.checked_mul(10));
+                    exp = try_or_invalid!(self, exp.checked_add((c as u64) - (b'0' as u64)));
+
+                    try!(self.bump());
+                }
+                _ => break
+            }
+        }
+
+        let exp = if exp <= i32::MAX as u64 {
+            10_f64.powi(exp as i32)
+        } else {
+            return Err(self.error(ErrorCode::InvalidNumber));
+        };
+
+        if neg_exp {
+            res /= exp;
+        } else {
+            res *= exp;
+        }
+
+        Ok(res)
+    }
+
+    fn decode_hex_escape(&mut self) -> Result<u16, Error> {
+        let mut i = 0;
+        let mut n = 0u16;
+        while i < 4 && !self.eof() {
+            try!(self.bump());
+            n = match self.ch_or_null() {
+                c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
+                b'a' | b'A' => n * 16_u16 + 10_u16,
+                b'b' | b'B' => n * 16_u16 + 11_u16,
+                b'c' | b'C' => n * 16_u16 + 12_u16,
+                b'd' | b'D' => n * 16_u16 + 13_u16,
+                b'e' | b'E' => n * 16_u16 + 14_u16,
+                b'f' | b'F' => n * 16_u16 + 15_u16,
+                _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
+            };
+
+            i += 1;
+        }
+
+        // Error out if we didn't parse 4 digits.
+        if i != 4 {
+            return Err(self.error(ErrorCode::InvalidEscape));
+        }
+
+        Ok(n)
+    }
+
+    fn parse_string(&mut self) -> Result<(), Error> {
+        self.str_buf.clear();
+
+        loop {
+            let ch = match try!(self.next_char()) {
+                Some(ch) => ch,
+                None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
+            };
+
+            match ch {
+                b'"' => {
+                    try!(self.bump());
+                    return Ok(());
+                }
+                b'\\' => {
+                    let ch = match try!(self.next_char()) {
+                        Some(ch) => ch,
+                        None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
+                    };
+
+                    match ch {
+                        b'"' => self.str_buf.push(b'"'),
+                        b'\\' => self.str_buf.push(b'\\'),
+                        b'/' => self.str_buf.push(b'/'),
+                        b'b' => self.str_buf.push(b'\x08'),
+                        b'f' => self.str_buf.push(b'\x0c'),
+                        b'n' => self.str_buf.push(b'\n'),
+                        b'r' => self.str_buf.push(b'\r'),
+                        b't' => self.str_buf.push(b'\t'),
+                        b'u' => {
+                            let c = match try!(self.decode_hex_escape()) {
+                                0xDC00 ... 0xDFFF => {
+                                    return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
+                                }
+
+                                // Non-BMP characters are encoded as a sequence of
+                                // two hex escapes, representing UTF-16 surrogates.
+                                n1 @ 0xD800 ... 0xDBFF => {
+                                    match (try!(self.next_char()), try!(self.next_char())) {
+                                        (Some(b'\\'), Some(b'u')) => (),
+                                        _ => {
+                                            return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
+                                        }
+                                    }
+
+                                    let n2 = try!(self.decode_hex_escape());
+
+                                    if n2 < 0xDC00 || n2 > 0xDFFF {
+                                        return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
+                                    }
+
+                                    let n = (((n1 - 0xD800) as u32) << 10 |
+                                              (n2 - 0xDC00) as u32) + 0x1_0000;
+
+                                    match char::from_u32(n as u32) {
+                                        Some(c) => c,
+                                        None => {
+                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
+                                        }
+                                    }
+                                }
+
+                                n => {
+                                    match char::from_u32(n as u32) {
+                                        Some(c) => c,
+                                        None => {
+                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
+                                        }
+                                    }
+                                }
+                            };
+
+                            // FIXME: this allocation is required in order to be compatible with stable
+                            // rust, which doesn't support encoding a `char` into a stack buffer.
+                            let buf = c.to_string();
+                            self.str_buf.extend(buf.bytes());
+                        }
+                        _ => {
+                            return Err(self.error(ErrorCode::InvalidEscape));
+                        }
+                    }
+                }
+                ch => {
+                    self.str_buf.push(ch);
+                }
+            }
+        }
+    }
+
+    fn parse_object_colon(&mut self) -> Result<(), Error> {
+        try!(self.parse_whitespace());
+
+        if self.ch_is(b':') {
+            try!(self.bump());
+            Ok(())
+        } else if self.eof() {
+            Err(self.error(ErrorCode::EOFWhileParsingObject))
+        } else {
+            Err(self.error(ErrorCode::ExpectedColon))
+        }
+    }
+}
+
+impl<Iter> de::Deserializer for Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        self.parse_value(visitor)
+    }
+
+    #[inline]
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        try!(self.parse_whitespace());
+
+        if self.eof() {
+            return Err(self.error(ErrorCode::EOFWhileParsingValue));
+        }
+
+        if self.ch_is(b'n') {
+            try!(self.parse_ident(b"ull"));
+            visitor.visit_none()
+        } else {
+            visitor.visit_some(self)
+        }
+    }
+
+    #[inline]
+    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        try!(self.parse_whitespace());
+
+        if self.ch_is(b'{') {
+            try!(self.bump());
+            try!(self.parse_whitespace());
+
+            let value = {
+                try!(visitor.visit(&mut *self))
+            };
+
+            try!(self.parse_whitespace());
+
+            if self.ch_is(b'}') {
+                try!(self.bump());
+                Ok(value)
+            } else {
+                Err(self.error(ErrorCode::ExpectedSomeValue))
+            }
+        } else {
+            Err(self.error(ErrorCode::ExpectedSomeValue))
+        }
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+struct SeqVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
+    de: &'a mut Deserializer<Iter>,
+    first: bool,
+}
+
+impl<'a, Iter: Iterator<Item=io::Result<u8>>> SeqVisitor<'a, Iter> {
+    fn new(de: &'a mut Deserializer<Iter>) -> Self {
+        SeqVisitor {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'a, Iter> de::SeqVisitor for SeqVisitor<'a, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
+        try!(self.de.parse_whitespace());
+
+        if self.de.ch_is(b']') {
+            return Ok(None);
+        }
+
+        if self.first {
+            self.first = false;
+        } else {
+            if self.de.ch_is(b',') {
+                try!(self.de.bump());
+            } else if self.de.eof() {
+                return Err(self.de.error(ErrorCode::EOFWhileParsingList));
+            } else {
+                return Err(self.de.error(ErrorCode::ExpectedListCommaOrEnd));
+            }
+        }
+
+        let value = try!(de::Deserialize::deserialize(self.de));
+        Ok(Some(value))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        try!(self.de.parse_whitespace());
+
+        if self.de.ch_is(b']') {
+            self.de.bump()
+        } else if self.de.eof() {
+            Err(self.de.error(ErrorCode::EOFWhileParsingList))
+        } else {
+            Err(self.de.error(ErrorCode::TrailingCharacters))
+        }
+    }
+}
+
+struct MapVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
+    de: &'a mut Deserializer<Iter>,
+    first: bool,
+}
+
+impl<'a, Iter: Iterator<Item=io::Result<u8>>> MapVisitor<'a, Iter> {
+    fn new(de: &'a mut Deserializer<Iter>) -> Self {
+        MapVisitor {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'a, Iter> de::MapVisitor for MapVisitor<'a, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+        where K: de::Deserialize,
+    {
+        try!(self.de.parse_whitespace());
+
+        if self.de.ch_is(b'}') {
+            return Ok(None);
+        }
+
+        if self.first {
+            self.first = false;
+        } else {
+            if self.de.ch_is(b',') {
+                try!(self.de.bump());
+                try!(self.de.parse_whitespace());
+            } else if self.de.eof() {
+                return Err(self.de.error(ErrorCode::EOFWhileParsingObject));
+            } else {
+                return Err(self.de.error(ErrorCode::ExpectedObjectCommaOrEnd));
+            }
+        }
+
+        if self.de.eof() {
+            return Err(self.de.error(ErrorCode::EOFWhileParsingValue));
+        }
+
+        if !self.de.ch_is(b'"') {
+            return Err(self.de.error(ErrorCode::KeyMustBeAString));
+        }
+
+        Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        try!(self.de.parse_object_colon());
+
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        try!(self.de.parse_whitespace());
+
+        if self.de.ch_is(b'}') {
+            try!(self.de.bump());
+            Ok(())
+        } else if self.de.eof() {
+            Err(self.de.error(ErrorCode::EOFWhileParsingObject))
+        } else {
+            Err(self.de.error(ErrorCode::TrailingCharacters))
+        }
+    }
+
+    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        let mut de = de::value::ValueDeserializer::into_deserializer(());
+        Ok(try!(de::Deserialize::deserialize(&mut de)))
+    }
+}
+
+impl<Iter> de::VariantVisitor for Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        try!(self.parse_object_colon());
+
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        try!(self.parse_object_colon());
+
+        de::Deserializer::visit(self, visitor)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        try!(self.parse_object_colon());
+
+        de::Deserializer::visit(self, visitor)
+    }
+}
+
+/// Decodes a json value from a `std::io::Read`.
+pub fn from_iter<I, T>(iter: I) -> Result<T, Error>
+    where I: Iterator<Item=io::Result<u8>>,
+          T: de::Deserialize,
+{
+    let mut de = try!(Deserializer::new(iter));
+    let value = try!(de::Deserialize::deserialize(&mut de));
+
+    // Make sure the whole stream has been consumed.
+    try!(de.end());
+    Ok(value)
+}
+
+/// Decodes a json value from a `std::io::Read`.
+pub fn from_reader<R, T>(rdr: R) -> Result<T, Error>
+    where R: io::Read,
+          T: de::Deserialize,
+{
+    from_iter(rdr.bytes())
+}
+
+/// Decodes a json value from a `&str`.
+pub fn from_slice<T>(v: &[u8]) -> Result<T, Error>
+    where T: de::Deserialize
+{
+    from_iter(v.iter().map(|byte| Ok(*byte)))
+}
+
+/// Decodes a json value from a `&str`.
+pub fn from_str<T>(s: &str) -> Result<T, Error>
+    where T: de::Deserialize
+{
+    from_slice(s.as_bytes())
+}

serde/src/json/error.rs

@@ -0,0 +1,185 @@
+use std::error;
+use std::fmt;
+use std::io;
+
+use de;
+
+/// The errors that can arise while parsing a JSON stream.
+#[derive(Clone, PartialEq)]
+pub enum ErrorCode {
+    EOFWhileParsingList,
+    EOFWhileParsingObject,
+    EOFWhileParsingString,
+    EOFWhileParsingValue,
+    ExpectedColon,
+    ExpectedConversion,
+    ExpectedEnumEnd,
+    ExpectedEnumEndToken,
+    ExpectedEnumMapStart,
+    ExpectedEnumToken,
+    ExpectedEnumVariantString,
+    ExpectedListCommaOrEnd,
+    ExpectedName,
+    ExpectedObjectCommaOrEnd,
+    ExpectedSomeIdent,
+    ExpectedSomeValue,
+    InvalidEscape,
+    InvalidNumber,
+    InvalidUnicodeCodePoint,
+    KeyMustBeAString,
+    LoneLeadingSurrogateInHexEscape,
+    UnknownField(String),
+    MissingField(&'static str),
+    NotFourDigit,
+    NotUtf8,
+    TrailingCharacters,
+    UnexpectedEndOfHexEscape,
+    UnknownVariant,
+    UnrecognizedHex,
+}
+
+impl fmt::Debug for ErrorCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use std::fmt::Debug;
+
+        match *self {
+            //ErrorCode::ConversionError(ref token) => write!(f, "failed to convert {}", token),
+            ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
+            ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
+            ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
+            ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
+            ErrorCode::ExpectedColon => "expected `:`".fmt(f),
+            ErrorCode::ExpectedConversion => "expected conversion".fmt(f),
+            ErrorCode::ExpectedEnumEnd => "expected enum end".fmt(f),
+            ErrorCode::ExpectedEnumEndToken => "expected enum map end".fmt(f),
+            ErrorCode::ExpectedEnumMapStart => "expected enum map start".fmt(f),
+            ErrorCode::ExpectedEnumToken => "expected enum token".fmt(f),
+            ErrorCode::ExpectedEnumVariantString => "expected variant".fmt(f),
+            ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
+            ErrorCode::ExpectedName => "expected name".fmt(f),
+            ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),
+            ErrorCode::ExpectedSomeIdent => "expected ident".fmt(f),
+            ErrorCode::ExpectedSomeValue => "expected value".fmt(f),
+            //ErrorCode::ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token),
+            ErrorCode::InvalidEscape => "invalid escape".fmt(f),
+            ErrorCode::InvalidNumber => "invalid number".fmt(f),
+            ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
+            ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
+            ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
+            ErrorCode::UnknownField(ref field) => write!(f, "unknown field \"{}\"", field),
+            ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
+            ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
+            ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
+            ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
+            ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
+            //ErrorCode::UnexpectedName(ref name) => write!(f, "unexpected name {}", name),
+            ErrorCode::UnknownVariant => "unknown variant".fmt(f),
+            ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    /// msg, line, col
+    SyntaxError(ErrorCode, usize, usize),
+    IoError(io::Error),
+    /*
+    ExpectedError(String, String),
+    */
+    MissingFieldError(&'static str),
+    /*
+    UnknownVariantError(String),
+    */
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Error::SyntaxError(..) => "syntax error",
+            Error::IoError(ref error) => error::Error::description(error),
+            /*
+            Error::ExpectedError(ref expected, _) => &expected,
+            */
+            Error::MissingFieldError(_) => "missing field",
+            /*
+            Error::UnknownVariantError(_) => "unknown variant",
+            */
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            Error::IoError(ref error) => Some(error),
+            _ => None,
+        }
+    }
+
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::SyntaxError(ref code, line, col) => {
+                write!(fmt, "{:?} at line {} column {}", code, line, col)
+            }
+            Error::IoError(ref error) => fmt::Display::fmt(error, fmt),
+            /*
+            Error::ExpectedError(ref expected, ref found) => {
+                Some(format!("expected {}, found {}", expected, found))
+            }
+            */
+            Error::MissingFieldError(ref field) => {
+                write!(fmt, "missing field {}", field)
+            }
+            /*
+            Error::UnknownVariantError(ref variant) => {
+                Some(format!("unknown variant {}", variant))
+            }
+            */
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(error: io::Error) -> Error {
+        Error::IoError(error)
+    }
+}
+
+impl From<de::value::Error> for Error {
+    fn from(error: de::value::Error) -> Error {
+        match error {
+            de::value::Error::SyntaxError => {
+                de::Error::syntax_error()
+            }
+            de::value::Error::EndOfStreamError => {
+                de::Error::end_of_stream_error()
+            }
+            de::value::Error::UnknownFieldError(field) => {
+                Error::SyntaxError(ErrorCode::UnknownField(field), 0, 0)
+            }
+            de::value::Error::MissingFieldError(field) => {
+                de::Error::missing_field_error(field)
+            }
+        }
+    }
+}
+
+impl de::Error for Error {
+    fn syntax_error() -> Error {
+        Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
+    }
+
+    fn end_of_stream_error() -> Error {
+        Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0)
+    }
+
+    fn unknown_field_error(field: &str) -> Error {
+        Error::SyntaxError(ErrorCode::UnknownField(field.to_string()), 0, 0)
+    }
+
+    fn missing_field_error(field: &'static str) -> Error {
+        Error::MissingFieldError(field)
+    }
+}

serde/src/json/mod.rs

@@ -0,0 +1,113 @@
+//! JSON and serialization
+//!
+//! # What is JSON?
+//!
+//! JSON (JavaScript Object Notation) is a way to write data in JavaScript.  Like XML, it allows to
+//! encode structured data in a text format that can be easily read by humans.  Its simple syntax
+//! and native compatibility with JavaScript have made it a widely used format.
+//!
+//! Data types that can be encoded are JavaScript types (see the `serde::json:Value` enum for more
+//! details):
+//!
+//! * `Boolean`: equivalent to rust's `bool`
+//! * `I64`: equivalent to rust's `i64`
+//! * `U64`: equivalent to rust's `u64`
+//! * `F64`: equivalent to rust's `i64`
+//! * `String`: equivalent to rust's `String`
+//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
+//!    same array
+//! * `Object`: equivalent to rust's `BTreeMap<String, serde::json::Value>`
+//! * `Null`
+//!
+//! An object is a series of string keys mapping to values, in `"key": value` format.  Arrays are
+//! enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).  A simple JSON
+//! document encoding a person, his/her age, address and phone numbers could look like
+//!
+//! ```ignore
+//! {
+//!     "FirstName": "John",
+//!     "LastName": "Doe",
+//!     "Age": 43,
+//!     "Address": {
+//!         "Street": "Downing Street 10",
+//!         "City": "London",
+//!         "Country": "Great Britain"
+//!     },
+//!     "PhoneNumbers": [
+//!         "+44 1234567",
+//!         "+44 2345678"
+//!     ]
+//! }
+//! ```
+//!
+//! # Type-based Serialization and Deserialization
+//!
+//! Serde provides a mechanism for low boilerplate serialization & deserialization of values to and
+//! from JSON via the serialization API.  To be able to serialize a piece of data, it must implement
+//! the `serde::Serialize` trait.  To be able to deserialize a piece of data, it must implement the
+//! `serde::Deserialize` trait.  Serde provides provides an annotation to automatically generate
+//! the code for these traits: `#[derive(Serialize, Deserialize)]`.
+//!
+//! The JSON API also provides an enum `serde::json::Value` and a method `to_value` to serialize
+//! objects.  A `serde::json::Value` value can be serialized as a string or buffer using the
+//! functions described above.  You can also use the `json::Serializer` object, which implements the
+//! `Serializer` trait.
+//!
+//! # Examples of use
+//!
+//! ## Parsing a `str` to `Value` and reading the result
+//!
+//! ```rust
+//! //#![feature(custom_derive, plugin)]
+//! //#![plugin(serde_macros)]
+//!
+//! extern crate serde;
+//!
+//! use serde::json::{self, Value};
+//!
+//! fn main() {
+//!     let data: Value = json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
+//!     println!("data: {:?}", data);
+//!     // data: {"bar":"baz","foo":13}
+//!     println!("object? {}", data.is_object());
+//!     // object? true
+//!
+//!     let obj = data.as_object().unwrap();
+//!     let foo = obj.get("foo").unwrap();
+//!
+//!     println!("array? {:?}", foo.as_array());
+//!     // array? None
+//!     println!("u64? {:?}", foo.as_u64());
+//!     // u64? Some(13u64)
+//!
+//!     for (key, value) in obj.iter() {
+//!         println!("{}: {}", key, match *value {
+//!             Value::U64(v) => format!("{} (u64)", v),
+//!             Value::String(ref v) => format!("{} (string)", v),
+//!             _ => format!("other")
+//!         });
+//!     }
+//!     // bar: baz (string)
+//!     // foo: 13 (u64)
+//! }
+//! ```
+
+pub use self::de::{Deserializer, from_str};
+pub use self::error::{Error, ErrorCode};
+pub use self::ser::{
+    Serializer,
+    to_writer,
+    to_writer_pretty,
+    to_vec,
+    to_vec_pretty,
+    to_string,
+    to_string_pretty,
+    escape_str,
+};
+pub use self::value::{Value, to_value, from_value};
+
+pub mod builder;
+pub mod de;
+pub mod error;
+pub mod ser;
+pub mod value;

serde/src/json/ser.rs

@@ -0,0 +1,524 @@
+use std::io;
+use std::num::FpCategory;
+use std::string::FromUtf8Error;
+
+use ser;
+
+/// A structure for implementing serialization to JSON.
+pub struct Serializer<W, F=CompactFormatter> {
+    writer: W,
+    formatter: F,
+
+    /// `first` is used to signify if we should print a comma when we are walking through a
+    /// sequence.
+    first: bool,
+}
+
+impl<W> Serializer<W>
+    where W: io::Write,
+{
+    /// Creates a new JSON serializer.
+    #[inline]
+    pub fn new(writer: W) -> Self {
+        Serializer::with_formatter(writer, CompactFormatter)
+    }
+}
+
+impl<'a, W> Serializer<W, PrettyFormatter<'a>>
+    where W: io::Write,
+{
+    /// Creates a new JSON pretty print serializer.
+    #[inline]
+    pub fn pretty(writer: W) -> Self {
+        Serializer::with_formatter(writer, PrettyFormatter::new())
+    }
+}
+
+impl<W, F> Serializer<W, F>
+    where W: io::Write,
+          F: Formatter,
+{
+    /// Creates a new JSON visitor whose output will be written to the writer
+    /// specified.
+    #[inline]
+    pub fn with_formatter(writer: W, formatter: F) -> Self {
+        Serializer {
+            writer: writer,
+            formatter: formatter,
+            first: false,
+        }
+    }
+
+    /// Unwrap the `Writer` from the `Serializer`.
+    #[inline]
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+}
+
+impl<W, F> ser::Serializer for Serializer<W, F>
+    where W: io::Write,
+          F: Formatter,
+{
+    type Error = io::Error;
+
+    #[inline]
+    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
+        if value {
+            self.writer.write_all(b"true")
+        } else {
+            self.writer.write_all(b"false")
+        }
+    }
+
+    #[inline]
+    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
+        fmt_f32_or_null(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
+        fmt_f64_or_null(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_char(&mut self, value: char) -> io::Result<()> {
+        escape_char(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_str(&mut self, value: &str) -> io::Result<()> {
+        escape_str(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_none(&mut self) -> io::Result<()> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
+        where V: ser::Serialize
+    {
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_unit(&mut self) -> io::Result<()> {
+        self.writer.write_all(b"null")
+    }
+
+    #[inline]
+    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> io::Result<()> {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.writer.write_all(b"[]"));
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
+        where V: ser::SeqVisitor,
+    {
+        match visitor.len() {
+            Some(len) if len == 0 => {
+                self.writer.write_all(b"[]")
+            }
+            _ => {
+                try!(self.formatter.open(&mut self.writer, b'['));
+
+                self.first = true;
+
+                while let Some(()) = try!(visitor.visit(self)) { }
+
+                self.formatter.close(&mut self.writer, b']')
+            }
+        }
+
+    }
+
+    #[inline]
+    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.visit_seq(visitor));
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_seq_elt<T>(&mut self, value: T) -> io::Result<()>
+        where T: ser::Serialize,
+    {
+        try!(self.formatter.comma(&mut self.writer, self.first));
+        self.first = false;
+
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
+        where V: ser::MapVisitor,
+    {
+        match visitor.len() {
+            Some(len) if len == 0 => {
+                self.writer.write_all(b"{}")
+            }
+            _ => {
+                try!(self.formatter.open(&mut self.writer, b'{'));
+
+                self.first = true;
+
+                while let Some(()) = try!(visitor.visit(self)) { }
+
+                self.formatter.close(&mut self.writer, b'}')
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.visit_map(visitor));
+
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> io::Result<()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        try!(self.formatter.comma(&mut self.writer, self.first));
+        self.first = false;
+
+        try!(key.serialize(self));
+        try!(self.formatter.colon(&mut self.writer));
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+pub trait Formatter {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write;
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write;
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write;
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write;
+}
+
+pub struct CompactFormatter;
+
+impl Formatter for CompactFormatter {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(&[ch])
+    }
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write,
+    {
+        if first {
+            Ok(())
+        } else {
+            writer.write_all(b",")
+        }
+    }
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(b":")
+    }
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(&[ch])
+    }
+}
+
+pub struct PrettyFormatter<'a> {
+    current_indent: usize,
+    indent: &'a [u8],
+}
+
+impl<'a> PrettyFormatter<'a> {
+    fn new() -> Self {
+        PrettyFormatter::with_indent(b"  ")
+    }
+
+    fn with_indent(indent: &'a [u8]) -> Self {
+        PrettyFormatter {
+            current_indent: 0,
+            indent: indent,
+        }
+    }
+}
+
+impl<'a> Formatter for PrettyFormatter<'a> {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        self.current_indent += 1;
+        writer.write_all(&[ch])
+    }
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write,
+    {
+        if first {
+            try!(writer.write_all(b"\n"));
+        } else {
+            try!(writer.write_all(b",\n"));
+        }
+
+        indent(writer, self.current_indent, self.indent)
+    }
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(b": ")
+    }
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        self.current_indent -= 1;
+        try!(writer.write(b"\n"));
+        try!(indent(writer, self.current_indent, self.indent));
+
+        writer.write_all(&[ch])
+    }
+}
+
+#[inline]
+pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
+    where W: io::Write
+{
+    try!(wr.write_all(b"\""));
+
+    let mut start = 0;
+
+    for (i, byte) in bytes.iter().enumerate() {
+        let escaped = match *byte {
+            b'"' => b"\\\"",
+            b'\\' => b"\\\\",
+            b'\x08' => b"\\b",
+            b'\x0c' => b"\\f",
+            b'\n' => b"\\n",
+            b'\r' => b"\\r",
+            b'\t' => b"\\t",
+            _ => { continue; }
+        };
+
+        if start < i {
+            try!(wr.write_all(&bytes[start..i]));
+        }
+
+        try!(wr.write_all(escaped));
+
+        start = i + 1;
+    }
+
+    if start != bytes.len() {
+        try!(wr.write_all(&bytes[start..]));
+    }
+
+    try!(wr.write_all(b"\""));
+    Ok(())
+}
+
+#[inline]
+pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
+    where W: io::Write
+{
+    escape_bytes(wr, value.as_bytes())
+}
+
+#[inline]
+fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
+    where W: io::Write
+{
+    // FIXME: this allocation is required in order to be compatible with stable
+    // rust, which doesn't support encoding a `char` into a stack buffer.
+    escape_bytes(wr, value.to_string().as_bytes())
+}
+
+fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
+        _ => {
+            let s = format!("{:?}", value);
+            try!(wr.write_all(s.as_bytes()));
+            if !s.contains('.') {
+                try!(wr.write_all(b".0"))
+            }
+            Ok(())
+        }
+    }
+}
+
+fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
+        _ => {
+            let s = format!("{:?}", value);
+            try!(wr.write_all(s.as_bytes()));
+            if !s.contains('.') {
+                try!(wr.write_all(b".0"))
+            }
+            Ok(())
+        }
+    }
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
+    where W: io::Write,
+          T: ser::Serialize,
+{
+    let mut ser = Serializer::new(writer);
+    try!(value.serialize(&mut ser));
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
+    where W: io::Write,
+          T: ser::Serialize,
+{
+    let mut ser = Serializer::pretty(writer);
+    try!(value.serialize(&mut ser));
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec<T>(value: &T) -> Vec<u8>
+    where T: ser::Serialize,
+{
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let mut writer = Vec::with_capacity(128);
+    to_writer(&mut writer, value).unwrap();
+    writer
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec_pretty<T>(value: &T) -> Vec<u8>
+    where T: ser::Serialize,
+{
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let mut writer = Vec::with_capacity(128);
+    to_writer_pretty(&mut writer, value).unwrap();
+    writer
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
+    where T: ser::Serialize
+{
+    let vec = to_vec(value);
+    String::from_utf8(vec)
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string_pretty<T>(value: &T) -> Result<String, FromUtf8Error>
+    where T: ser::Serialize
+{
+    let vec = to_vec_pretty(value);
+    String::from_utf8(vec)
+}
+
+fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
+    where W: io::Write,
+{
+    for _ in 0 .. n {
+        try!(wr.write_all(s));
+    }
+
+    Ok(())
+}

serde/src/json/value.rs

@@ -0,0 +1,915 @@
+use std::collections::{BTreeMap, btree_map};
+use std::fmt;
+use std::io;
+use std::str;
+use std::vec;
+
+use num::NumCast;
+
+use de;
+use ser;
+use super::error::Error;
+
+#[derive(Clone, PartialEq)]
+pub enum Value {
+    Null,
+    Bool(bool),
+    I64(i64),
+    U64(u64),
+    F64(f64),
+    String(String),
+    Array(Vec<Value>),
+    Object(BTreeMap<String, Value>),
+}
+
+impl Value {
+    /// If the `Value` is an Object, returns the value associated with the provided key.
+    /// Otherwise, returns None.
+    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Value>{
+        match self {
+            &Value::Object(ref map) => map.get(key),
+            _ => None
+        }
+    }
+
+    /// Attempts to get a nested Value Object for each key in `keys`.
+    /// If any key is found not to exist, find_path will return None.
+    /// Otherwise, it will return the `Value` associated with the final key.
+    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Value>{
+        let mut target = self;
+        for key in keys {
+            match target.find(key) {
+                Some(t) => { target = t; },
+                None => return None
+            }
+        }
+        Some(target)
+    }
+
+    /// Looks up a value by path.
+    ///
+    /// This is a convenience method that splits the path by `'.'`
+    /// and then feeds the sequence of keys into the `find_path`
+    /// method.
+    ///
+    /// ``` ignore
+    /// let obj: Value = json::from_str(r#"{"x": {"a": 1}}"#).unwrap();
+    ///
+    /// assert!(obj.lookup("x.a").unwrap() == &Value::U64(1));
+    /// ```
+    pub fn lookup<'a>(&'a self, path: &str) -> Option<&'a Value> {
+        let mut target = self;
+        for key in path.split('.') {
+            match target.find(key) {
+                Some(t) => { target = t; },
+                None => return None
+            }
+        }
+        Some(target)
+    }
+
+    /// If the `Value` is an Object, performs a depth-first search until
+    /// a value associated with the provided key is found. If no value is found
+    /// or the `Value` is not an Object, returns None.
+    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Value> {
+        match self {
+            &Value::Object(ref map) => {
+                match map.get(key) {
+                    Some(json_value) => Some(json_value),
+                    None => {
+                        for (_, v) in map.iter() {
+                            match v.search(key) {
+                                x if x.is_some() => return x,
+                                _ => ()
+                            }
+                        }
+                        None
+                    }
+                }
+            },
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is an Object. Returns false otherwise.
+    pub fn is_object<'a>(&'a self) -> bool {
+        self.as_object().is_some()
+    }
+
+    /// If the `Value` is an Object, returns the associated BTreeMap.
+    /// Returns None otherwise.
+    pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
+        match self {
+            &Value::Object(ref map) => Some(map),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is an Object, returns the associated mutable BTreeMap.
+    /// Returns None otherwise.
+    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut BTreeMap<String, Value>> {
+        match self {
+            &mut Value::Object(ref mut map) => Some(map),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is an Array. Returns false otherwise.
+    pub fn is_array<'a>(&'a self) -> bool {
+        self.as_array().is_some()
+    }
+
+    /// If the `Value` is an Array, returns the associated vector.
+    /// Returns None otherwise.
+    pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
+        match self {
+            &Value::Array(ref array) => Some(&*array),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is an Array, returns the associated mutable vector.
+    /// Returns None otherwise.
+    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Vec<Value>> {
+        match self {
+            &mut Value::Array(ref mut list) => Some(list),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a String. Returns false otherwise.
+    pub fn is_string<'a>(&'a self) -> bool {
+        self.as_string().is_some()
+    }
+
+    /// If the `Value` is a String, returns the associated str.
+    /// Returns None otherwise.
+    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
+        match *self {
+            Value::String(ref s) => Some(&s),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Number. Returns false otherwise.
+    pub fn is_number(&self) -> bool {
+        match *self {
+            Value::I64(_) | Value::U64(_) | Value::F64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a i64. Returns false otherwise.
+    pub fn is_i64(&self) -> bool {
+        match *self {
+            Value::I64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a u64. Returns false otherwise.
+    pub fn is_u64(&self) -> bool {
+        match *self {
+            Value::U64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a f64. Returns false otherwise.
+    pub fn is_f64(&self) -> bool {
+        match *self {
+            Value::F64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a i64.
+    /// Returns None otherwise.
+    pub fn as_i64(&self) -> Option<i64> {
+        match *self {
+            Value::I64(n) => Some(n),
+            Value::U64(n) => NumCast::from(n),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a u64.
+    /// Returns None otherwise.
+    pub fn as_u64(&self) -> Option<u64> {
+        match *self {
+            Value::I64(n) => NumCast::from(n),
+            Value::U64(n) => Some(n),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a f64.
+    /// Returns None otherwise.
+    pub fn as_f64(&self) -> Option<f64> {
+        match *self {
+            Value::I64(n) => NumCast::from(n),
+            Value::U64(n) => NumCast::from(n),
+            Value::F64(n) => Some(n),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
+    pub fn is_boolean(&self) -> bool {
+        self.as_boolean().is_some()
+    }
+
+    /// If the `Value` is a Boolean, returns the associated bool.
+    /// Returns None otherwise.
+    pub fn as_boolean(&self) -> Option<bool> {
+        match self {
+            &Value::Bool(b) => Some(b),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Null. Returns false otherwise.
+    pub fn is_null(&self) -> bool {
+        self.as_null().is_some()
+    }
+
+    /// If the `Value` is a Null, returns ().
+    /// Returns None otherwise.
+    pub fn as_null(&self) -> Option<()> {
+        match self {
+            &Value::Null => Some(()),
+            _ => None
+        }
+    }
+}
+
+impl ser::Serialize for Value {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        match *self {
+            Value::Null => serializer.visit_unit(),
+            Value::Bool(v) => serializer.visit_bool(v),
+            Value::I64(v) => serializer.visit_i64(v),
+            Value::U64(v) => serializer.visit_u64(v),
+            Value::F64(v) => serializer.visit_f64(v),
+            Value::String(ref v) => serializer.visit_str(&v),
+            Value::Array(ref v) => v.serialize(serializer),
+            Value::Object(ref v) => v.serialize(serializer),
+        }
+    }
+}
+
+impl de::Deserialize for Value {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
+        where D: de::Deserializer,
+    {
+        struct ValueVisitor;
+
+        impl de::Visitor for ValueVisitor {
+            type Value = Value;
+
+            #[inline]
+            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
+                Ok(Value::Bool(value))
+            }
+
+            #[inline]
+            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
+                if value < 0 {
+                    Ok(Value::I64(value))
+                } else {
+                    Ok(Value::U64(value as u64))
+                }
+            }
+
+            #[inline]
+            fn visit_u64<E>(&mut self, value: u64) -> Result<Value, E> {
+                Ok(Value::U64(value))
+            }
+
+            #[inline]
+            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
+                Ok(Value::F64(value))
+            }
+
+            #[inline]
+            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
+                where E: de::Error,
+            {
+                self.visit_string(value.to_string())
+            }
+
+            #[inline]
+            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
+                Ok(Value::String(value))
+            }
+
+            #[inline]
+            fn visit_none<E>(&mut self) -> Result<Value, E> {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Value, D::Error>
+                where D: de::Deserializer,
+            {
+                de::Deserialize::deserialize(deserializer)
+            }
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<Value, E> {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::SeqVisitor,
+            {
+                let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
+                Ok(Value::Array(values))
+            }
+
+            #[inline]
+            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::MapVisitor,
+            {
+                let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
+                Ok(Value::Object(values))
+            }
+        }
+
+        deserializer.visit(ValueVisitor)
+    }
+}
+
+struct WriterFormatter<'a, 'b: 'a> {
+    inner: &'a mut fmt::Formatter<'b>,
+}
+
+impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
+            Ok(_) => Ok(buf.len()),
+            Err(_) => Err(io::Error::last_os_error()),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl fmt::Debug for Value {
+    /// Serializes a json value into a string
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut wr = WriterFormatter { inner: f };
+        super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
+    }
+}
+
+#[derive(Debug)]
+enum State {
+    Value(Value),
+    Array(Vec<Value>),
+    Object(BTreeMap<String, Value>),
+}
+
+pub struct Serializer {
+    state: Vec<State>,
+}
+
+impl Serializer {
+    pub fn new() -> Serializer {
+        Serializer {
+            state: Vec::with_capacity(4),
+        }
+    }
+
+    pub fn unwrap(mut self) -> Value {
+        match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        }
+    }
+}
+
+impl ser::Serializer for Serializer {
+    type Error = ();
+
+    #[inline]
+    fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
+        self.state.push(State::Value(Value::Bool(value)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_i64(&mut self, value: i64) -> Result<(), ()> {
+        if value < 0 {
+            self.state.push(State::Value(Value::I64(value)));
+        } else {
+            self.state.push(State::Value(Value::U64(value as u64)));
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_u64(&mut self, value: u64) -> Result<(), ()> {
+        self.state.push(State::Value(Value::U64(value)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_f64(&mut self, value: f64) -> Result<(), ()> {
+        self.state.push(State::Value(Value::F64(value as f64)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_char(&mut self, value: char) -> Result<(), ()> {
+        self.state.push(State::Value(Value::String(value.to_string())));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_str(&mut self, value: &str) -> Result<(), ()> {
+        self.state.push(State::Value(Value::String(value.to_string())));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_none(&mut self) -> Result<(), ()> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
+        where V: ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_unit(&mut self) -> Result<(), ()> {
+        self.state.push(State::Value(Value::Null));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> Result<(), ()> {
+        let mut values = BTreeMap::new();
+        values.insert(variant.to_string(), Value::Array(vec![]));
+
+        self.state.push(State::Value(Value::Object(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor,
+    {
+        let len = visitor.len().unwrap_or(0);
+        let values = Vec::with_capacity(len);
+
+        self.state.push(State::Array(values));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        let values = match self.state.pop().unwrap() {
+            State::Array(values) => values,
+            state => panic!("Expected array, found {:?}", state),
+        };
+
+        self.state.push(State::Value(Value::Array(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.visit_seq(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        try!(value.serialize(self));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        match *self.state.last_mut().unwrap() {
+            State::Array(ref mut values) => { values.push(value); }
+            ref state => panic!("expected array, found {:?}", state),
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor,
+    {
+        let values = BTreeMap::new();
+
+        self.state.push(State::Object(values));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        let values = match self.state.pop().unwrap() {
+            State::Object(values) => values,
+            state => panic!("expected object, found {:?}", state),
+        };
+
+        self.state.push(State::Value(Value::Object(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.visit_map(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        try!(key.serialize(self));
+
+        let key = match self.state.pop().unwrap() {
+            State::Value(Value::String(value)) => value,
+            state => panic!("expected key, found {:?}", state),
+        };
+
+        try!(value.serialize(self));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        match *self.state.last_mut().unwrap() {
+            State::Object(ref mut values) => { values.insert(key, value); }
+            ref state => panic!("expected object, found {:?}", state),
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+pub struct Deserializer {
+    value: Option<Value>,
+}
+
+impl Deserializer {
+    /// Creates a new deserializer instance for deserializing the specified JSON value.
+    pub fn new(value: Value) -> Deserializer {
+        Deserializer {
+            value: Some(value),
+        }
+    }
+}
+
+impl de::Deserializer for Deserializer {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        let value = match self.value.take() {
+            Some(value) => value,
+            None => { return Err(de::Error::end_of_stream_error()); }
+        };
+
+        match value {
+            Value::Null => visitor.visit_unit(),
+            Value::Bool(v) => visitor.visit_bool(v),
+            Value::I64(v) => visitor.visit_i64(v),
+            Value::U64(v) => visitor.visit_u64(v),
+            Value::F64(v) => visitor.visit_f64(v),
+            Value::String(v) => visitor.visit_string(v),
+            Value::Array(v) => {
+                let len = v.len();
+                visitor.visit_seq(SeqDeserializer {
+                    de: self,
+                    iter: v.into_iter(),
+                    len: len,
+                })
+            }
+            Value::Object(v) => {
+                let len = v.len();
+                visitor.visit_map(MapDeserializer {
+                    de: self,
+                    iter: v.into_iter(),
+                    value: None,
+                    len: len,
+                })
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.value {
+            Some(Value::Null) => visitor.visit_none(),
+            Some(_) => visitor.visit_some(self),
+            None => Err(de::Error::end_of_stream_error()),
+        }
+    }
+
+    #[inline]
+    fn visit_enum<V>(&mut self, _name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        let value = match self.value.take() {
+            Some(Value::Object(value)) => value,
+            Some(_) => { return Err(de::Error::syntax_error()); }
+            None => { return Err(de::Error::end_of_stream_error()); }
+        };
+
+        let mut iter = value.into_iter();
+
+        let value = match iter.next() {
+            Some((variant, Value::Array(fields))) => {
+                self.value = Some(Value::String(variant));
+
+                let len = fields.len();
+                try!(visitor.visit(SeqDeserializer {
+                    de: self,
+                    iter: fields.into_iter(),
+                    len: len,
+                }))
+            }
+            Some((variant, Value::Object(fields))) => {
+                let len = fields.len();
+                try!(visitor.visit(MapDeserializer {
+                    de: self,
+                    iter: fields.into_iter(),
+                    value: Some(Value::String(variant)),
+                    len: len,
+                }))
+            }
+            Some(_) => { return Err(de::Error::syntax_error()); }
+            None => { return Err(de::Error::syntax_error()); }
+        };
+
+        match iter.next() {
+            Some(_) => Err(de::Error::syntax_error()),
+            None => Ok(value)
+        }
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+struct SeqDeserializer<'a> {
+    de: &'a mut Deserializer,
+    iter: vec::IntoIter<Value>,
+    len: usize,
+}
+
+impl<'a> de::Deserializer for SeqDeserializer<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        if self.len == 0 {
+            visitor.visit_unit()
+        } else {
+            visitor.visit_seq(self)
+        }
+    }
+}
+
+impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize
+    {
+        match self.iter.next() {
+            Some(value) => {
+                self.len -= 1;
+                self.de.value = Some(value);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream_error())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+impl<'a> de::VariantVisitor for SeqDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self.de)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error>
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+}
+
+struct MapDeserializer<'a> {
+    de: &'a mut Deserializer,
+    iter: btree_map::IntoIter<String, Value>,
+    value: Option<Value>,
+    len: usize,
+}
+
+impl<'a> de::MapVisitor for MapDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.len -= 1;
+                self.value = Some(value);
+                self.de.value = Some(Value::String(key));
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize
+    {
+        let value = self.value.take().unwrap();
+        self.de.value = Some(value);
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream_error())
+        }
+    }
+
+    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        // See if the type can deserialize from a unit.
+        struct UnitDeserializer;
+
+        impl de::Deserializer for UnitDeserializer {
+            type Error = Error;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                visitor.visit_unit()
+            }
+
+            fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                visitor.visit_none()
+            }
+        }
+
+        Ok(try!(de::Deserialize::deserialize(&mut UnitDeserializer)))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+impl<'a> de::Deserializer for MapDeserializer<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        println!("MapDeserializer!");
+        visitor.visit_map(self)
+    }
+}
+
+impl<'a> de::VariantVisitor for MapDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        self.de.value = self.value.take();
+        de::Deserialize::deserialize(self.de)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+}
+
+/// Shortcut function to encode a `T` into a JSON `Value`
+pub fn to_value<T>(value: &T) -> Value
+    where T: ser::Serialize
+{
+    let mut ser = Serializer::new();
+    value.serialize(&mut ser).ok().unwrap();
+    ser.unwrap()
+}
+
+/// Shortcut function to decode a JSON `Value` into a `T`
+pub fn from_value<T>(value: Value) -> Result<T, Error>
+    where T: de::Deserialize
+{
+    let mut de = Deserializer::new(value);
+    de::Deserialize::deserialize(&mut de)
+}

serde/src/lib.rs

@@ -1,285 +1,19 @@
-//! # Serde
+//! Serde Serialization Framework
 //!
-//! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
-//! structures efficiently and generically.
-//!
-//! The Serde ecosystem consists of data structures that know how to serialize
-//! and deserialize themselves along with data formats that know how to
-//! serialize and deserialize other things. Serde provides the layer by which
-//! these two groups interact with each other, allowing any supported data
-//! structure to be serialized and deserialized using any supported data format.
-//!
-//! See the Serde website <https://serde.rs> for additional documentation and
-//! usage examples.
-//!
-//! ## Design
-//!
-//! Where many other languages rely on runtime reflection for serializing data,
-//! Serde is instead built on Rust's powerful trait system. A data structure
-//! that knows how to serialize and deserialize itself is one that implements
-//! Serde's `Serialize` and `Deserialize` traits (or uses Serde's derive
-//! attribute to automatically generate implementations at compile time). This
-//! avoids any overhead of reflection or runtime type information. In fact in
-//! many situations the interaction between data structure and data format can
-//! be completely optimized away by the Rust compiler, leaving Serde
-//! serialization to perform the same speed as a handwritten serializer for the
-//! specific selection of data structure and data format.
-//!
-//! ## Data formats
-//!
-//! The following is a partial list of data formats that have been implemented
-//! for Serde by the community.
-//!
-//! - [JSON], the ubiquitous JavaScript Object Notation used by many HTTP APIs.
-//! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
-//! - [CBOR], a Concise Binary Object Representation designed for small message
-//!   size without the need for version negotiation.
-//! - [YAML], a self-proclaimed human-friendly configuration language that ain't
-//!   markup language.
-//! - [MessagePack], an efficient binary format that resembles a compact JSON.
-//! - [TOML], a minimal configuration format used by [Cargo].
-//! - [Pickle], a format common in the Python world.
-//! - [RON], a Rusty Object Notation.
-//! - [BSON], the data storage and network transfer format used by MongoDB.
-//! - [Avro], a binary format used within Apache Hadoop, with support for schema
-//!   definition.
-//! - [JSON5], a superset of JSON including some productions from ES5.
-//! - [URL] query strings, in the x-www-form-urlencoded format.
-//! - [Starlark], the format used for describing build targets by the Bazel and
-//!   Buck build systems. *(serialization only)*
-//! - [Envy], a way to deserialize environment variables into Rust structs.
-//!   *(deserialization only)*
-//! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
-//!   Rust structs. *(deserialization only)*
-//! - [S-expressions], the textual representation of code and data used by the
-//!   Lisp language family.
-//! - [D-Bus]'s binary wire format.
-//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy
-//!   serialization format.
-//! - [Bencode], a simple binary format used in the BitTorrent protocol.
-//! - [Token streams], for processing Rust procedural macro input.
-//!   *(deserialization only)*
-//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
-//!   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
-//! [CBOR]: https://github.com/enarx/ciborium
-//! [YAML]: https://github.com/dtolnay/serde-yaml
-//! [MessagePack]: https://github.com/3Hren/msgpack-rust
-//! [TOML]: https://docs.rs/toml
-//! [Pickle]: https://github.com/birkenfeld/serde-pickle
-//! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/mongodb/bson-rust
-//! [Avro]: https://docs.rs/apache-avro
-//! [JSON5]: https://github.com/callum-oakley/json5-rs
-//! [URL]: https://docs.rs/serde_qs
-//! [Starlark]: https://github.com/dtolnay/serde-starlark
-//! [Envy]: https://github.com/softprops/envy
-//! [Envy Store]: https://github.com/softprops/envy-store
-//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
-//! [S-expressions]: https://github.com/rotty/lexpr-rs
-//! [D-Bus]: https://docs.rs/zvariant
-//! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
-//! [Bencode]: https://github.com/P3KI/bendy
-//! [Token streams]: https://github.com/oxidecomputer/serde_tokenstream
-//! [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 is a powerful framework that enables serialization libraries to generically serialize
+//! Rust data structures without the overhead of runtime type information. In many situations, the
+//! handshake protocol between serializers and serializees can be completely optimized away,
+//! leaving serde to perform roughly the same speed as a hand written serializer for a specific
+//! type.
+#![doc(html_root_url="http://erickt.github.io/rust-serde")]
 
-////////////////////////////////////////////////////////////////////////////////
+extern crate num;
 
-// Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.228")]
-// 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(docsrs, feature(doc_cfg, rustdoc_internals))]
-#![cfg_attr(docsrs, allow(internal_features))]
-// Unstable functionality only if the user asks for it. For tracking and
-// discussion of these features please refer to this issue:
-//
-//    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(never_type))]
-#![allow(
-    unknown_lints,
-    bare_trait_objects,
-    deprecated,
-    mismatched_lifetime_syntaxes
-)]
-// Ignored clippy and clippy_pedantic lints
-#![allow(
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-    clippy::unnested_or_patterns,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
-    clippy::semicolon_if_nothing_returned,
-    // not available in our oldest supported compiler
-    clippy::empty_enums,
-    clippy::type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
-    // 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::single_match_else,
-    clippy::type_complexity,
-    clippy::use_self,
-    clippy::zero_prefixed_literal,
-    // correctly used
-    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,
-    clippy::result_unit_err,
-    clippy::wildcard_imports,
-    // not practical
-    clippy::needless_pass_by_value,
-    clippy::similar_names,
-    clippy::too_many_lines,
-    // preference
-    clippy::doc_markdown,
-    clippy::elidable_lifetime_names,
-    clippy::needless_lifetimes,
-    clippy::unseparated_literal_suffix,
-    // false positive
-    clippy::needless_doctest_main,
-    // noisy
-    clippy::missing_errors_doc,
-    clippy::must_use_candidate,
-)]
-// Restrictions
-#![deny(clippy::question_mark_used)]
-// Rustc lints.
-#![deny(missing_docs, unused_imports)]
+pub use ser::{Serialize, Serializer};
+pub use de::{Deserialize, Deserializer, Error};
 
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "alloc")]
-extern crate alloc;
-
-// Rustdoc has a lot of shortcomings related to cross-crate re-exports that make
-// the rendered documentation of serde_core traits in serde more challenging to
-// understand than the equivalent documentation of the same items in serde_core.
-// https://github.com/rust-lang/rust/labels/A-cross-crate-reexports
-// So, just for the purpose of docs.rs documentation, we inline the contents of
-// serde_core into serde. This sidesteps all the cross-crate rustdoc bugs.
-#[cfg(docsrs)]
-#[macro_use]
-#[path = "core/crate_root.rs"]
-mod crate_root;
-
-#[cfg(docsrs)]
-#[macro_use]
-#[path = "core/macros.rs"]
-mod macros;
-
-#[cfg(not(docsrs))]
-macro_rules! crate_root {
-    () => {
-        /// A facade around all the types we need from the `std`, `core`, and `alloc`
-        /// crates. This avoids elaborate import wrangling having to happen in every
-        /// module.
-        mod lib {
-            mod core {
-                #[cfg(not(feature = "std"))]
-                pub use core::*;
-                #[cfg(feature = "std")]
-                pub use std::*;
-            }
-
-            pub use self::core::{f32, f64};
-            pub use self::core::{ptr, str};
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            pub use self::core::slice;
-
-            pub use self::core::clone;
-            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::option;
-            pub use self::core::result;
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::borrow::{Cow, ToOwned};
-            #[cfg(feature = "std")]
-            pub use std::borrow::{Cow, ToOwned};
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::string::{String, ToString};
-            #[cfg(feature = "std")]
-            pub use std::string::{String, ToString};
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::vec::Vec;
-            #[cfg(feature = "std")]
-            pub use std::vec::Vec;
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::boxed::Box;
-            #[cfg(feature = "std")]
-            pub use std::boxed::Box;
-        }
-
-        // None of this crate's error handling needs the `From::from` error conversion
-        // performed implicitly by the `?` operator or the standard library's `try!`
-        // macro. This simplified macro gives a 5.5% improvement in compile time
-        // compared to standard `try!`, and 9% improvement compared to `?`.
-        #[cfg(not(no_serde_derive))]
-        macro_rules! tri {
-            ($expr:expr) => {
-                match $expr {
-                    Ok(val) => val,
-                    Err(err) => return Err(err),
-                }
-            };
-        }
-
-        ////////////////////////////////////////////////////////////////////////////////
-
-        pub use serde_core::{
-            de, forward_to_deserialize_any, ser, Deserialize, Deserializer, Serialize, Serializer,
-        };
-
-        // Used by generated code and doc tests. Not public API.
-        #[doc(hidden)]
-        mod private;
-
-        include!(concat!(env!("OUT_DIR"), "/private.rs"));
-    };
-}
-
-crate_root!();
-
-mod integer128;
-
-// Re-export #[derive(Serialize, Deserialize)].
-//
-// The reason re-exporting is not enabled by default is that disabling it would
-// be annoying for crates that provide handwritten impls or data formats. They
-// would need to disable default features and then explicitly re-enable std.
-#[cfg(feature = "serde_derive")]
-extern crate serde_derive;
-
-/// Derive macro available if serde is built with `features = ["derive"]`.
-#[cfg(feature = "serde_derive")]
-#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
-pub use serde_derive::{Deserialize, Serialize};
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __require_serde_not_serde_core {
-    () => {};
-}
+pub mod bytes;
+pub mod de;
+pub mod iter;
+pub mod json;
+pub mod ser;

serde/src/private/mod.rs

@@ -1,18 +0,0 @@
-#[cfg(not(no_serde_derive))]
-pub mod de;
-#[cfg(not(no_serde_derive))]
-pub mod ser;
-
-pub use crate::lib::clone::Clone;
-pub use crate::lib::convert::{From, Into, TryFrom};
-pub use crate::lib::default::Default;
-pub use crate::lib::fmt::{self, Formatter};
-pub use crate::lib::marker::PhantomData;
-pub use crate::lib::option::Option::{self, None, Some};
-pub use crate::lib::ptr;
-pub use crate::lib::result::Result::{self, Err, Ok};
-
-pub use crate::serde_core_private::string::from_utf8_lossy;
-
-#[cfg(any(feature = "alloc", feature = "std"))]
-pub use crate::lib::{ToString, Vec};

serde/src/ser/impls.rs

@@ -0,0 +1,537 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::hash::Hash;
+use std::path;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use super::{
+    Serialize,
+    Serializer,
+    SeqVisitor,
+    MapVisitor,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! impl_visit {
+    ($ty:ty, $method:ident) => {
+        impl Serialize for $ty {
+            #[inline]
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: Serializer,
+            {
+                serializer.$method(*self)
+            }
+        }
+    }
+}
+
+impl_visit!(bool, visit_bool);
+impl_visit!(isize, visit_isize);
+impl_visit!(i8, visit_i8);
+impl_visit!(i16, visit_i16);
+impl_visit!(i32, visit_i32);
+impl_visit!(i64, visit_i64);
+impl_visit!(usize, visit_usize);
+impl_visit!(u8, visit_u8);
+impl_visit!(u16, visit_u16);
+impl_visit!(u32, visit_u32);
+impl_visit!(u64, visit_u64);
+impl_visit!(f32, visit_f32);
+impl_visit!(f64, visit_f64);
+impl_visit!(char, visit_char);
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for str {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_str(self)
+    }
+}
+
+impl Serialize for String {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (&self[..]).serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> Serialize for Option<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        match *self {
+            Some(ref value) => serializer.visit_some(value),
+            None => serializer.visit_none(),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct SeqIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<T, Iter> SeqIteratorVisitor<Iter>
+    where Iter: Iterator<Item=T>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> SeqIteratorVisitor<Iter> {
+        SeqIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
+    where T: Serialize,
+          Iter: Iterator<Item=T>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some(value) => {
+                let value = try!(serializer.visit_seq_elt(value));
+                Ok(Some(value))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a, T> Serialize for &'a [T]
+    where T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+macro_rules! array_impls {
+    ($len:expr) => {
+        impl<T> Serialize for [T; $len] where T: Serialize {
+            #[inline]
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: Serializer,
+            {
+                serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some($len)))
+            }
+        }
+    }
+}
+
+array_impls!(0);
+array_impls!(1);
+array_impls!(2);
+array_impls!(3);
+array_impls!(4);
+array_impls!(5);
+array_impls!(6);
+array_impls!(7);
+array_impls!(8);
+array_impls!(9);
+array_impls!(10);
+array_impls!(11);
+array_impls!(12);
+array_impls!(13);
+array_impls!(14);
+array_impls!(15);
+array_impls!(16);
+array_impls!(17);
+array_impls!(18);
+array_impls!(19);
+array_impls!(20);
+array_impls!(21);
+array_impls!(22);
+array_impls!(23);
+array_impls!(24);
+array_impls!(25);
+array_impls!(26);
+array_impls!(27);
+array_impls!(28);
+array_impls!(29);
+array_impls!(30);
+array_impls!(31);
+array_impls!(32);
+
+impl<T> Serialize for Vec<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (&self[..]).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for BTreeSet<T>
+    where T: Serialize + Ord,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<T> Serialize for HashSet<T>
+    where T: Serialize + Eq + Hash,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for () {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_unit()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// FIXME(rust #19630) Remove this work-around
+macro_rules! e {
+    ($e:expr) => { $e }
+}
+
+macro_rules! tuple_impls {
+    ($(
+        $TupleVisitor:ident ($len:expr, $($T:ident),+) {
+            $($state:pat => $idx:tt,)+
+        }
+    )+) => {
+        $(
+            pub struct $TupleVisitor<'a, $($T: 'a),+> {
+                tuple: &'a ($($T,)+),
+                state: u8,
+            }
+
+            impl<'a, $($T: 'a),+> $TupleVisitor<'a, $($T),+> {
+                pub fn new(tuple: &'a ($($T,)+)) -> $TupleVisitor<'a, $($T),+> {
+                    $TupleVisitor {
+                        tuple: tuple,
+                        state: 0,
+                    }
+                }
+            }
+
+            impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+>
+                where $($T: Serialize),+
+            {
+                fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+                    where S: Serializer,
+                {
+                    match self.state {
+                        $(
+                            $state => {
+                                self.state += 1;
+                                Ok(Some(try!(serializer.visit_seq_elt(&e!(self.tuple.$idx)))))
+                            }
+                        )+
+                        _ => {
+                            Ok(None)
+                        }
+                    }
+                }
+
+                fn len(&self) -> Option<usize> {
+                    Some($len)
+                }
+            }
+
+            impl<$($T),+> Serialize for ($($T,)+)
+                where $($T: Serialize),+
+            {
+                #[inline]
+                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
+                    serializer.visit_seq($TupleVisitor::new(self))
+                }
+            }
+        )+
+    }
+}
+
+tuple_impls! {
+    TupleVisitor1 (1, T0) {
+        0 => 0,
+    }
+    TupleVisitor2 (2, T0, T1) {
+        0 => 0,
+        1 => 1,
+    }
+    TupleVisitor3 (3, T0, T1, T2) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+    }
+    TupleVisitor4 (4, T0, T1, T2, T3) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+    }
+    TupleVisitor5 (5, T0, T1, T2, T3, T4) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+    }
+    TupleVisitor6 (6, T0, T1, T2, T3, T4, T5) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+    }
+    TupleVisitor7 (7, T0, T1, T2, T3, T4, T5, T6) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+    }
+    TupleVisitor8 (8, T0, T1, T2, T3, T4, T5, T6, T7) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+    }
+    TupleVisitor9 (9, T0, T1, T2, T3, T4, T5, T6, T7, T8) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+    }
+    TupleVisitor10 (10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+    }
+    TupleVisitor11 (11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+        10 => 10,
+    }
+    TupleVisitor12 (12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+        10 => 10,
+        11 => 11,
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct MapIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<K, V, Iter> MapIteratorVisitor<Iter>
+    where Iter: Iterator<Item=(K, V)>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
+        MapIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
+    where K: Serialize,
+          V: Serialize,
+          I: Iterator<Item=(K, V)>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                let value = try!(serializer.visit_map_elt(key, value));
+                Ok(Some(value))
+            }
+            None => Ok(None)
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<K, V> Serialize for BTreeMap<K, V>
+    where K: Serialize + Ord,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<K, V> Serialize for HashMap<K, V>
+    where K: Serialize + Eq + Hash,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+// FIXME: `VecMap` is unstable.
+/*
+impl<V> Serialize for VecMap<V>
+    where V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+*/
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a, T: ?Sized> Serialize for &'a T where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for Rc<T> where T: Serialize, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for Arc<T> where T: Serialize, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for path::Path {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_str().unwrap().serialize(serializer)
+    }
+}
+
+impl Serialize for path::PathBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_str().unwrap().serialize(serializer)
+    }
+}

serde/src/ser/mod.rs

@@ -0,0 +1,212 @@
+//! Generic serialization framework.
+
+pub mod impls;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Serialize {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Serializer {
+    type Error;
+
+    /// `visit_bool` serializes a `bool` value.
+    fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
+
+    /// `visit_isize` serializes a `isize` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_isize(&mut self, v: isize) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i8` serializes a `i8` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i8(&mut self, v: i8) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i16` serializes a `i16` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i16(&mut self, v: i16) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i32` serializes a `i32` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i32(&mut self, v: i32) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i64` serializes a `i64` value.
+    #[inline]
+    fn visit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
+
+    /// `visit_usize` serializes a `usize` value. By default it casts the value to a `u64` and
+    /// passes it to the `visit_u64` method.
+    #[inline]
+    fn visit_usize(&mut self, v: usize) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u8` serializes a `u8` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u8(&mut self, v: u8) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u32` serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u16(&mut self, v: u16) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u32` serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u32(&mut self, v: u32) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u64` serializes a `u64` value.
+    #[inline]
+    fn visit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
+
+    /// `visit_f32` serializes a `f32` value. By default it casts the value to a `f64` and passes
+    /// it to the `visit_f64` method.
+    #[inline]
+    fn visit_f32(&mut self, v: f32) -> Result<(), Self::Error> {
+        self.visit_f64(v as f64)
+    }
+
+    /// `visit_f64` serializes a `f64` value.
+    fn visit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
+
+    /// `visit_char` serializes a character. By default it serializes it as a `&str` containing a
+    /// single character.
+    #[inline]
+    fn visit_char(&mut self, v: char) -> Result<(), Self::Error> {
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.visit_str(&v.to_string())
+    }
+
+    /// `visit_str` serializes a `&str`.
+    fn visit_str(&mut self, value: &str) -> Result<(), Self::Error>;
+
+    /// `visit_bytes` is a hook that enables those serialization formats that support serializing
+    /// byte slices separately from generic arrays. By default it serializes as a regular array.
+    #[inline]
+    fn visit_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+        self.visit_seq(impls::SeqIteratorVisitor::new(value.iter(), Some(value.len())))
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn visit_named_unit(&mut self, _name: &str) -> Result<(), Self::Error> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_enum_unit(&mut self,
+                       _name: &str,
+                       _variant: &str) -> Result<(), Self::Error> {
+        self.visit_unit()
+    }
+
+    fn visit_none(&mut self) -> Result<(), Self::Error>;
+
+    fn visit_some<V>(&mut self, value: V) -> Result<(), Self::Error>
+        where V: Serialize;
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor;
+
+    #[inline]
+    fn visit_named_seq<V>(&mut self,
+                          _name: &'static str,
+                          visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    #[inline]
+    fn visit_enum_seq<V>(&mut self,
+                         _name: &'static str,
+                         _variant: &'static str,
+                         visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize;
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor;
+
+    #[inline]
+    fn visit_named_map<V>(&mut self,
+                          _name: &'static str,
+                          visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    #[inline]
+    fn visit_enum_map<V>(&mut self,
+                          _name: &'static str,
+                          _variant: &'static str,
+                          visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
+        where K: Serialize,
+              V: Serialize;
+
+    /// Specify a format string for the serializer.
+    ///
+    /// The serializer format is used to determine which format
+    /// specific field attributes should be used with the serializer.
+    fn format() -> &'static str {
+        ""
+    }
+}
+
+pub trait SeqVisitor {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer;
+
+    /// Return the length of the sequence if known.
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        None
+    }
+}
+
+pub trait MapVisitor {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer;
+
+    /// Return the length of the map if known.
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        None
+    }
+}

serde_codegen/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "serde_codegen"
+version = "0.4.2"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Macros to auto-generate implementations for the serde framework"
+repository = "https://github.com/erickt/rust-serde"
+build = "build.rs"
+
+[features]
+default = ["with-syntex"]
+nightly = ["quasi_macros"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+
+[build-dependencies]
+quasi_codegen = { verision = "*", optional = true }
+syntex = { version = "*", optional = true }
+
+[dependencies]
+aster = { version = "*", default-features = false }
+quasi = { verision = "*", default-features = false }
+quasi_macros = { version = "*", optional = true }
+syntex = { version = "*", optional = true }
+syntex_syntax = { version = "*", optional = true }

serde_codegen/build.rs

@@ -0,0 +1,28 @@
+#[cfg(feature = "with-syntex")]
+mod inner {
+    extern crate syntex;
+    extern crate quasi_codegen;
+
+    use std::env;
+    use std::path::Path;
+
+    pub fn main() {
+        let out_dir = env::var_os("OUT_DIR").unwrap();
+        let mut registry = syntex::Registry::new();
+        quasi_codegen::register(&mut registry);
+
+        let src = Path::new("src/lib.rs.in");
+        let dst = Path::new(&out_dir).join("lib.rs");
+
+        registry.expand("", &src, &dst).unwrap();
+    }
+}
+
+#[cfg(not(feature = "with-syntex"))]
+mod inner {
+    pub fn main() {}
+}
+
+fn main() {
+    inner::main();
+}

serde_codegen/src/attr.rs

@@ -0,0 +1,108 @@
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+use syntax::ast;
+use syntax::ext::base::ExtCtxt;
+use syntax::ptr::P;
+
+/// Represents field name information
+pub enum FieldNames {
+    Global(P<ast::Expr>),
+    Format{
+        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
+        default: P<ast::Expr>,
+    }
+}
+
+/// Represents field attribute information
+pub struct FieldAttrs {
+    names: FieldNames,
+    use_default: bool,
+}
+
+impl FieldAttrs {
+
+    /// Create a FieldAttr with a single default field name
+    pub fn new(default_value: bool, name: P<ast::Expr>) -> FieldAttrs {
+        FieldAttrs {
+            names: FieldNames::Global(name),
+            use_default: default_value,
+        }
+    }
+
+    /// Create a FieldAttr with format specific field names
+    pub fn new_with_formats(
+        default_value: bool,
+        default_name: P<ast::Expr>,
+        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
+        ) -> FieldAttrs {
+        FieldAttrs {
+            names:  FieldNames::Format {
+                formats: formats,
+                default: default_name,
+            },
+            use_default: default_value,
+        }
+    }
+
+    /// Return a set of formats that the field has attributes for.
+    pub fn formats(&self) -> HashSet<P<ast::Expr>> {
+        match self.names {
+            FieldNames::Format{ref formats, default: _} => {
+                let mut set = HashSet::new();
+                for (fmt, _) in formats.iter() {
+                    set.insert(fmt.clone());
+                };
+                set
+            },
+            _ => HashSet::new()
+        }
+    }
+
+    /// Return an expression for the field key name for serialisation.
+    ///
+    /// The resulting expression assumes that `S` refers to a type
+    /// that implements `Serializer`.
+    pub fn serializer_key_expr(self, cx: &ExtCtxt) -> P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(x) => x,
+            FieldNames::Format{formats, default} => {
+                let arms = formats.iter()
+                    .map(|(fmt, lit)| {
+                        quote_arm!(cx, $fmt => { $lit })
+                    })
+                    .collect::<Vec<_>>();
+                quote_expr!(cx,
+                            {
+                                match S::format() {
+                                    $arms
+                                    _ => { $default }
+                                }
+                            })
+            },
+        }
+    }
+
+    /// Return the default field name for the field.
+    pub fn default_key_expr(&self) -> &P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(ref expr) => expr,
+            FieldNames::Format{formats: _, ref default} => default
+        }
+    }
+
+    /// Return the field name for the field in the specified format.
+    pub fn key_expr(&self, format: &P<ast::Expr>) -> &P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(ref expr) =>
+                expr,
+            FieldNames::Format{ref formats, ref default} =>
+                formats.get(format).unwrap_or(default)
+        }
+    }
+
+    /// Predicate for using a field's default value
+    pub fn use_default(&self) -> bool {
+        self.use_default
+    }
+}

serde_codegen/src/de.rs

@@ -0,0 +1,833 @@
+use std::collections::HashSet;
+
+use aster;
+
+use syntax::ast::{
+    self,
+    Ident,
+    MetaItem,
+    Item,
+    Expr,
+    StructDef,
+    EnumDef,
+};
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ext::build::AstBuilder;
+use syntax::owned_slice::OwnedSlice;
+use syntax::ptr::P;
+
+use attr;
+use field;
+
+pub fn expand_derive_deserialize(
+    cx: &mut ExtCtxt,
+    span: Span,
+    meta_item: &MetaItem,
+    annotatable: &Annotatable,
+    push: &mut FnMut(Annotatable)
+) {
+    let item = match *annotatable {
+        Annotatable::Item(ref item) => item,
+        _ => {
+            cx.span_err(
+                meta_item.span,
+                "`derive` may only be applied to structs and enums");
+            return;
+        }
+    };
+
+    let builder = aster::AstBuilder::new().span(span);
+
+    let generics = match item.node {
+        ast::ItemStruct(_, ref generics) => generics,
+        ast::ItemEnum(_, ref generics) => generics,
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Deserialize)]")
+    };
+
+    let impl_generics = builder.from_generics(generics.clone())
+        .add_ty_param_bound(
+            builder.path().global().ids(&["serde", "de", "Deserialize"]).build()
+        )
+        .build();
+
+    let ty = builder.ty().path()
+        .segment(item.ident).with_generics(impl_generics.clone()).build()
+        .build();
+
+    let body = deserialize_body(
+        cx,
+        &builder,
+        &item,
+        &impl_generics,
+        ty.clone(),
+    );
+
+    let where_clause = &impl_generics.where_clause;
+
+    let impl_item = quote_item!(cx,
+        #[automatically_derived]
+        impl $impl_generics ::serde::de::Deserialize for $ty $where_clause {
+            fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<$ty, __D::Error>
+                where __D: ::serde::de::Deserializer,
+            {
+                $body
+            }
+        }
+    ).unwrap();
+
+    push(Annotatable::Item(impl_item))
+}
+
+fn deserialize_body(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+) -> P<ast::Expr> {
+    match item.node {
+        ast::ItemStruct(ref struct_def, _) => {
+            deserialize_item_struct(
+                cx,
+                builder,
+                item,
+                impl_generics,
+                ty,
+                struct_def,
+            )
+        }
+        ast::ItemEnum(ref enum_def, _) => {
+            deserialize_item_enum(
+                cx,
+                builder,
+                item.ident,
+                impl_generics,
+                ty,
+                enum_def,
+            )
+        }
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Deserialize)]")
+    }
+}
+
+fn deserialize_item_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+) -> P<ast::Expr> {
+    let mut named_fields = vec![];
+    let mut unnamed_fields = 0;
+
+    for field in struct_def.fields.iter() {
+        match field.node.kind {
+            ast::NamedField(name, _) => { named_fields.push(name); }
+            ast::UnnamedField(_) => { unnamed_fields += 1; }
+        }
+    }
+
+    match (named_fields.is_empty(), unnamed_fields == 0) {
+        (true, true) => {
+            deserialize_unit_struct(
+                cx,
+                &builder,
+                item.ident,
+            )
+        }
+        (true, false) => {
+            deserialize_tuple_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                unnamed_fields,
+            )
+        }
+        (false, true) => {
+            deserialize_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                struct_def,
+            )
+        }
+        (false, false) => {
+            cx.bug("struct has named and unnamed fields")
+        }
+    }
+}
+
+
+// Build `__Visitor<A, B, ...>(PhantomData<A>, PhantomData<B>, ...)`
+fn deserialize_visitor(
+    builder: &aster::AstBuilder,
+    trait_generics: &ast::Generics,
+    forward_ty_params: Vec<ast::TyParam>,
+    forward_tys: Vec<P<ast::Ty>>
+) -> (P<ast::Item>, P<ast::Ty>, P<ast::Expr>, ast::Generics) {
+    if trait_generics.ty_params.is_empty() && forward_tys.is_empty() {
+        (
+            builder.item().tuple_struct("__Visitor").build(),
+            builder.ty().id("__Visitor"),
+            builder.expr().id("__Visitor"),
+            trait_generics.clone(),
+        )
+    } else {
+        let placeholders : Vec<_> = trait_generics.ty_params.iter()
+            .map(|t| builder.ty().id(t.ident))
+            .collect();
+        let mut trait_generics = trait_generics.clone();
+        let mut ty_params = forward_ty_params.clone();
+        ty_params.extend(trait_generics.ty_params.into_vec());
+        trait_generics.ty_params = OwnedSlice::from_vec(ty_params);
+
+        (
+            builder.item().tuple_struct("__Visitor")
+                .generics().with(trait_generics.clone()).build()
+                .with_tys(
+                    trait_generics.ty_params.iter().map(|ty_param| {
+                        builder.ty().phantom_data().id(ty_param.ident)
+                    })
+                )
+                .build(),
+            builder.ty().path()
+                .segment("__Visitor").with_generics(trait_generics.clone()).build()
+                .build(),
+            builder.expr().call()
+                .path().segment("__Visitor")
+                .with_tys(forward_tys)
+                .with_tys(placeholders)
+                .build().build()
+                .with_args(
+                    trait_generics.ty_params.iter().map(|_| {
+                        builder.expr().phantom_data()
+                    })
+                )
+                .build(),
+            trait_generics,
+        )
+    }
+}
+
+fn deserializer_ty_param(builder: &aster::AstBuilder) -> ast::TyParam {
+    builder.ty_param("__D")
+        .trait_bound(builder.path()
+                     .global()
+                     .segment("serde").build()
+                     .segment("de").build()
+                     .id("Deserializer")
+                     .build())
+        .build()
+        .build()
+}
+
+fn deserializer_ty_arg(builder: &aster::AstBuilder) -> P<ast::Ty>{
+    builder.ty().id("__D")
+}
+
+fn deserialize_unit_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+) -> P<ast::Expr> {
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        struct __Visitor;
+
+        impl ::serde::de::Visitor for __Visitor {
+            type Value = $type_ident;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> ::std::result::Result<$type_ident, E>
+                where E: ::serde::de::Error,
+            {
+                Ok($type_ident)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, mut visitor: V) -> ::std::result::Result<$type_ident, V::Error>
+                where V: ::serde::de::SeqVisitor,
+            {
+                try!(visitor.end());
+                self.visit_unit()
+            }
+        }
+
+        deserializer.visit_named_unit($type_name, __Visitor)
+    })
+}
+
+fn deserialize_tuple_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    fields: usize,
+) -> P<ast::Expr> {
+    let where_clause = &impl_generics.where_clause;
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            impl_generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+        );
+
+    let visit_seq_expr = deserialize_seq(
+        cx,
+        builder,
+        builder.path().id(type_ident).build(),
+        fields,
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::SeqVisitor,
+            {
+                $visit_seq_expr
+            }
+        }
+
+        deserializer.visit_named_seq($type_name, $visitor_expr)
+    })
+}
+
+fn deserialize_seq(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_path: ast::Path,
+    fields: usize,
+) -> P<ast::Expr> {
+    let let_values: Vec<P<ast::Stmt>> = (0 .. fields)
+        .map(|i| {
+            let name = builder.id(format!("__field{}", i));
+            quote_stmt!(cx,
+                let $name = match try!(visitor.visit()) {
+                    Some(value) => { value },
+                    None => {
+                        return Err(::serde::de::Error::end_of_stream_error());
+                    }
+                };
+            ).unwrap()
+        })
+        .collect();
+
+    let result = builder.expr().call()
+        .build_path(struct_path)
+        .with_args((0 .. fields).map(|i| builder.expr().id(format!("__field{}", i))))
+        .build();
+
+    quote_expr!(cx, {
+        $let_values
+
+        try!(visitor.end());
+
+        Ok($result)
+    })
+}
+
+fn deserialize_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &StructDef,
+) -> P<ast::Expr> {
+    let where_clause = &impl_generics.where_clause;
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            &impl_generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+                );
+
+    let (field_visitor, visit_map_expr) = deserialize_struct_visitor(
+        cx,
+        builder,
+        struct_def,
+        builder.path().id(type_ident).build(),
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $field_visitor
+
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::MapVisitor,
+            {
+                $visit_map_expr
+            }
+        }
+
+        deserializer.visit_named_map($type_name, $visitor_expr)
+    })
+}
+
+fn deserialize_item_enum(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    enum_def: &EnumDef,
+) -> P<ast::Expr> {
+    let where_clause = &impl_generics.where_clause;
+
+    let type_name = builder.expr().str(type_ident);
+
+    let variant_visitor = deserialize_field_visitor(
+        cx,
+        builder,
+        enum_def.variants.iter()
+            .map(|variant|
+                 attr::FieldAttrs::new(
+                     true,
+                     builder.expr().str(variant.node.name)))
+            .collect()
+    );
+
+    // Match arms to extract a variant from a string
+    let variant_arms: Vec<_> = enum_def.variants.iter()
+        .enumerate()
+        .map(|(i, variant)| {
+            let variant_name = builder.pat().enum_()
+                .id("__Field").id(format!("__field{}", i)).build()
+                .build();
+
+            let expr = deserialize_variant(
+                cx,
+                builder,
+                type_ident,
+                impl_generics,
+                ty.clone(),
+                variant,
+            );
+
+            quote_arm!(cx, $variant_name => { $expr })
+        })
+        .collect();
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            impl_generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+                );
+
+    quote_expr!(cx, {
+        $variant_visitor
+
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::EnumVisitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            fn visit<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::VariantVisitor,
+            {
+                match try!(visitor.visit_variant()) {
+                    $variant_arms
+                }
+            }
+        }
+
+        deserializer.visit_enum($type_name, $visitor_expr)
+    })
+}
+
+fn deserialize_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    variant: &ast::Variant,
+) -> P<ast::Expr> {
+    let variant_ident = variant.node.name;
+
+    match variant.node.kind {
+        ast::TupleVariantKind(ref args) if args.is_empty() => {
+            quote_expr!(cx, {
+                try!(visitor.visit_unit());
+                Ok($type_ident::$variant_ident)
+            })
+        }
+        ast::TupleVariantKind(ref args) => {
+            deserialize_tuple_variant(
+                cx,
+                builder,
+                type_ident,
+                variant_ident,
+                generics,
+                ty,
+                args.len(),
+            )
+        }
+        ast::StructVariantKind(ref struct_def) => {
+            deserialize_struct_variant(
+                cx,
+                builder,
+                type_ident,
+                variant_ident,
+                generics,
+                ty,
+                struct_def,
+            )
+        }
+    }
+}
+
+fn deserialize_tuple_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: ast::Ident,
+    variant_ident: ast::Ident,
+    generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    fields: usize,
+) -> P<ast::Expr> {
+    let where_clause = &generics.where_clause;
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+                );
+
+    let visit_seq_expr = deserialize_seq(
+        cx,
+        builder,
+        builder.path().id(type_ident).id(variant_ident).build(),
+        fields,
+    );
+
+    quote_expr!(cx, {
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::SeqVisitor,
+            {
+                $visit_seq_expr
+            }
+        }
+
+        visitor.visit_seq($visitor_expr)
+    })
+}
+
+fn deserialize_struct_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: ast::Ident,
+    variant_ident: ast::Ident,
+    generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+) -> P<ast::Expr> {
+    let where_clause = &generics.where_clause;
+
+    let (field_visitor, field_expr) = deserialize_struct_visitor(
+        cx,
+        builder,
+        struct_def,
+        builder.path().id(type_ident).id(variant_ident).build(),
+    );
+
+    let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
+        deserialize_visitor(
+            builder,
+            generics,
+            vec![deserializer_ty_param(builder)],
+            vec![deserializer_ty_arg(builder)],
+                );
+
+    quote_expr!(cx, {
+        $field_visitor
+
+        $visitor_item
+
+        impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
+            type Value = $ty;
+
+            fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
+                where __V: ::serde::de::MapVisitor,
+            {
+                $field_expr
+            }
+        }
+
+        visitor.visit_map($visitor_expr)
+    })
+}
+
+fn deserialize_field_visitor(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    field_attrs: Vec<attr::FieldAttrs>,
+) -> Vec<P<ast::Item>> {
+    // Create the field names for the fields.
+    let field_idents: Vec<ast::Ident> = (0 .. field_attrs.len())
+        .map(|i| builder.id(format!("__field{}", i)))
+        .collect();
+
+    let field_enum = builder.item()
+        .attr().allow(&["non_camel_case_types"])
+        .enum_("__Field")
+        .with_variants(
+            field_idents.iter().map(|field_ident| {
+                builder.variant(field_ident).tuple().build()
+            })
+        )
+        .build();
+
+    // A set of all the formats that have specialized field attributes
+    let formats = field_attrs.iter()
+        .fold(HashSet::new(), |mut set, field_expr| {
+            set.extend(field_expr.formats());
+            set
+        });
+
+    // Match arms to extract a field from a string
+    let default_field_arms: Vec<_> = field_idents.iter()
+        .zip(field_attrs.iter())
+        .map(|(field_ident, field_expr)| {
+            let expr = field_expr.default_key_expr();
+            quote_arm!(cx, $expr => { Ok(__Field::$field_ident) })
+        })
+        .collect();
+
+    let body = if formats.is_empty() {
+        // No formats specific attributes, so no match on format required
+        quote_expr!(cx,
+                    match value {
+                        $default_field_arms
+                        _ => { Err(::serde::de::Error::unknown_field_error(value)) }
+                    })
+    } else {
+        let field_arms : Vec<_> = formats.iter()
+            .map(|fmt| {
+                field_idents.iter()
+                    .zip(field_attrs.iter())
+                    .map(|(field_ident, field_expr)| {
+                        let expr = field_expr.key_expr(fmt);
+                        quote_arm!(cx, $expr => { Ok(__Field::$field_ident) })
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect();
+
+        let fmt_matches : Vec<_> = formats.iter()
+            .zip(field_arms.iter())
+            .map(|(ref fmt, ref arms)| {
+                quote_arm!(cx, $fmt => {
+                    match value {
+                        $arms
+                        _ => {
+                            Err(::serde::de::Error::unknown_field_error(value))
+                        }
+                    }})
+            })
+            .collect();
+
+        quote_expr!(cx,
+                    match __D::format() {
+                        $fmt_matches
+                        _ => match value {
+                            $default_field_arms
+                            _ => { Err(::serde::de::Error::unknown_field_error(value)) }
+                        }
+                    })
+    };
+
+    let impl_item = quote_item!(cx,
+        impl ::serde::de::Deserialize for __Field {
+            #[inline]
+            fn deserialize<D>(deserializer: &mut D) -> ::std::result::Result<__Field, D::Error>
+                where D: ::serde::de::Deserializer,
+            {
+                use std::marker::PhantomData;
+
+                struct __FieldVisitor<D> {
+                    phantom: PhantomData<D>
+                }
+
+                impl<__D> ::serde::de::Visitor for __FieldVisitor<__D>
+                    where __D: ::serde::de::Deserializer
+                {
+                    type Value = __Field;
+
+                    fn visit_str<E>(&mut self, value: &str) -> ::std::result::Result<__Field, E>
+                        where E: ::serde::de::Error,
+                    {
+                        $body
+                    }
+
+                    fn visit_bytes<E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, E>
+                        where E: ::serde::de::Error,
+                    {
+                        // TODO: would be better to generate a byte string literal match
+                        match ::std::str::from_utf8(value) {
+                            Ok(s) => self.visit_str(s),
+                            _ => Err(::serde::de::Error::syntax_error()),
+                        }
+                    }
+                }
+
+                deserializer.visit(
+                    __FieldVisitor::<D>{ phantom: PhantomData })
+            }
+        }
+    ).unwrap();
+
+    vec![field_enum, impl_item]
+}
+
+fn deserialize_struct_visitor(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_def: &ast::StructDef,
+    struct_path: ast::Path,
+) -> (Vec<P<ast::Item>>, P<ast::Expr>) {
+    let field_visitor = deserialize_field_visitor(
+        cx,
+        builder,
+        field::struct_field_attrs(cx, builder, struct_def),
+    );
+
+    let visit_map_expr = deserialize_map(
+        cx,
+        builder,
+        struct_path,
+        struct_def,
+    );
+
+    (field_visitor, visit_map_expr)
+}
+
+fn deserialize_map(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_path: ast::Path,
+    struct_def: &StructDef,
+) -> P<ast::Expr> {
+    // Create the field names for the fields.
+    let field_names: Vec<ast::Ident> = (0 .. struct_def.fields.len())
+        .map(|i| builder.id(format!("__field{}", i)))
+        .collect();
+
+    // Declare each field.
+    let let_values: Vec<P<ast::Stmt>> = field_names.iter()
+        .map(|field_name| quote_stmt!(cx, let mut $field_name = None;).unwrap())
+        .collect();
+
+    // Match arms to extract a value for a field.
+    let value_arms: Vec<ast::Arm> = field_names.iter()
+        .map(|field_name| {
+            quote_arm!(cx,
+                __Field::$field_name => {
+                    $field_name = Some(try!(visitor.visit_value()));
+                }
+            )
+        })
+        .collect();
+
+    let extract_values: Vec<P<ast::Stmt>> = field_names.iter()
+        .zip(field::struct_field_attrs(cx, builder, struct_def).iter())
+        .map(|(field_name, field_attr)| {
+            let missing_expr = if field_attr.use_default() {
+                quote_expr!(cx, ::std::default::Default::default())
+            } else {
+                let formats = field_attr.formats();
+                let arms : Vec<_> = formats.iter()
+                    .map(|format| {
+                        let key_expr = field_attr.key_expr(format);
+                        quote_arm!(cx, $format => { $key_expr })
+                    })
+                    .collect();
+                let default = field_attr.default_key_expr();
+                if arms.is_empty() {
+                    quote_expr!(cx, try!(visitor.missing_field($default)))
+                } else {
+                    quote_expr!(
+                        cx,
+                        try!(visitor.missing_field(
+                            match __D::format() {
+                                $arms
+                                _ => { $default }
+                            })))
+                }
+            };
+
+            quote_stmt!(cx,
+                let $field_name = match $field_name {
+                    Some($field_name) => $field_name,
+                    None => $missing_expr
+                };
+            ).unwrap()
+        })
+        .collect();
+
+    let result = builder.expr().struct_path(struct_path)
+        .with_id_exprs(
+            struct_def.fields.iter()
+                .zip(field_names.iter())
+                .map(|(field, field_name)| {
+                    (
+                        match field.node.kind {
+                            ast::NamedField(name, _) => name.clone(),
+                            ast::UnnamedField(_) => panic!("struct contains unnamed fields"),
+                        },
+                        builder.expr().id(field_name),
+                    )
+                })
+        )
+        .build();
+
+    quote_expr!(cx, {
+        $let_values
+
+        while let Some(key) = try!(visitor.visit_key()) {
+            match key {
+                $value_arms
+            }
+        }
+
+        $extract_values
+
+        try!(visitor.end());
+
+        Ok($result)
+    })
+}

serde_codegen/src/field.rs

@@ -0,0 +1,133 @@
+use std::collections::HashMap;
+
+use aster;
+
+use syntax::ast;
+use syntax::attr;
+use syntax::ext::base::ExtCtxt;
+use syntax::ptr::P;
+
+use attr::FieldAttrs;
+
+enum Rename<'a> {
+    None,
+    Global(&'a ast::Lit),
+    Format(HashMap<P<ast::Expr>, &'a ast::Lit>)
+}
+
+fn rename<'a>(
+    builder: &aster::AstBuilder,
+    mi: &'a ast::MetaItem,
+    ) -> Option<Rename<'a>>
+{
+    match mi.node {
+        ast::MetaNameValue(ref n, ref lit) => {
+            if n == &"rename" {
+                Some(Rename::Global(lit))
+            } else {
+                None
+            }
+        },
+        ast::MetaList(ref n, ref items) => {
+            if n == &"rename" {
+                let mut m = HashMap::new();
+                m.extend(
+                    items.iter()
+                        .filter_map(
+                            |item|
+                            match item.node {
+                                ast::MetaNameValue(ref n, ref lit) =>
+                                    Some((builder.expr().str(n),
+                                          lit)),
+                                _ => None
+                            }));
+                Some(Rename::Format(m))
+            } else {
+                None
+            }
+        },
+        _ => None
+    }
+}
+
+fn default_value(mi: &ast::MetaItem) -> bool {
+    if let ast::MetaItem_::MetaWord(ref n) = mi.node {
+        n == &"default"
+    } else {
+        false
+    }
+}
+
+fn field_attrs<'a>(
+    builder: &aster::AstBuilder,
+    field: &'a ast::StructField,
+) -> (Rename<'a>, bool) {
+    field.node.attrs.iter()
+        .find(|sa| {
+            if let ast::MetaList(ref n, _) = sa.node.value.node {
+                n == &"serde"
+            } else {
+                false
+            }
+        })
+        .and_then(|sa| {
+            if let ast::MetaList(_, ref vals) = sa.node.value.node {
+                attr::mark_used(&sa);
+                Some((vals.iter()
+                      .fold(None, |v, mi| v.or(rename(builder, mi)))
+                      .unwrap_or(Rename::None),
+                      vals.iter().any(|mi| default_value(mi))))
+            } else {
+                Some((Rename::None, false))
+            }
+        })
+        .unwrap_or((Rename::None, false))
+}
+
+pub fn struct_field_attrs(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_def: &ast::StructDef,
+) -> Vec<FieldAttrs> {
+    struct_def.fields.iter()
+        .map(|field| {
+            match field_attrs(builder, field) {
+                (Rename::Global(rename), default_value) =>
+                    FieldAttrs::new(
+                        default_value,
+                        builder.expr().build_lit(P(rename.clone()))),
+                (Rename::Format(renames), default_value) => {
+                    let mut res = HashMap::new();
+                    res.extend(
+                        renames.into_iter()
+                            .map(|(k,v)|
+                                 (k, builder.expr().build_lit(P(v.clone())))));
+                    FieldAttrs::new_with_formats(
+                        default_value,
+                        default_field_name(cx, builder, field.node.kind),
+                        res)
+                },
+                (Rename::None, default_value) => {
+                    FieldAttrs::new(
+                        default_value,
+                        default_field_name(cx, builder, field.node.kind))
+                }
+            }
+        })
+        .collect()
+}
+
+fn default_field_name(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    kind: ast::StructFieldKind,
+) -> P<ast::Expr> {
+    match kind {
+        ast::NamedField(name, _) => {
+            builder.expr().str(name)
+        }
+        ast::UnnamedField(_) => {
+            cx.bug("struct has named and unnamed fields")
+        }
+    }
+}

serde_codegen/src/lib.rs

@@ -0,0 +1,73 @@
+#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
+#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
+
+extern crate aster;
+extern crate quasi;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex_syntax as syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate rustc;
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");
+
+#[cfg(feature = "with-syntex")]
+pub fn register(reg: &mut syntex::Registry) {
+    use syntax::{ast, fold};
+
+    reg.add_attr("feature(custom_derive)");
+    reg.add_attr("feature(custom_attribute)");
+
+    reg.add_decorator("derive_Serialize", ser::expand_derive_serialize);
+    reg.add_decorator("derive_Deserialize", de::expand_derive_deserialize);
+
+    reg.add_post_expansion_pass(strip_attributes);
+
+    /// Strip the serde attributes from the crate.
+    #[cfg(feature = "with-syntex")]
+    fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+        /// Helper folder that strips the serde attributes after the extensions have been expanded.
+        struct StripAttributeFolder;
+
+        impl fold::Folder for StripAttributeFolder {
+            fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
+                match attr.node.value.node {
+                    ast::MetaList(ref n, _) if n == &"serde" => { return None; }
+                    _ => {}
+                }
+
+                Some(attr)
+            }
+
+            fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
+                fold::noop_fold_mac(mac, self)
+            }
+        }
+
+        fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
+    }
+}
+
+#[cfg(not(feature = "with-syntex"))]
+pub fn register(reg: &mut rustc::plugin::Registry) {
+    reg.register_syntax_extension(
+        syntax::parse::token::intern("derive_Serialize"),
+        syntax::ext::base::MultiDecorator(
+            Box::new(ser::expand_derive_serialize)));
+
+    reg.register_syntax_extension(
+        syntax::parse::token::intern("derive_Deserialize"),
+        syntax::ext::base::MultiDecorator(
+            Box::new(de::expand_derive_deserialize)));
+}

serde_codegen/src/lib.rs.in

@@ -0,0 +1,4 @@
+mod attr;
+mod de;
+mod field;
+mod ser;

serde_codegen/src/ser.rs

@@ -0,0 +1,623 @@
+use aster;
+
+use syntax::ast::{
+    Ident,
+    MetaItem,
+    Item,
+    Expr,
+    StructDef,
+};
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ext::build::AstBuilder;
+use syntax::ptr::P;
+
+use field::struct_field_attrs;
+
+pub fn expand_derive_serialize(
+    cx: &mut ExtCtxt,
+    span: Span,
+    meta_item: &MetaItem,
+    annotatable: &Annotatable,
+    push: &mut FnMut(Annotatable)
+) {
+    let item = match *annotatable {
+        Annotatable::Item(ref item) => item,
+        _ => {
+            cx.span_err(
+                meta_item.span,
+                "`derive` may only be applied to structs and enums");
+            return;
+        }
+    };
+
+    let builder = aster::AstBuilder::new().span(span);
+
+    let generics = match item.node {
+        ast::ItemStruct(_, ref generics) => generics,
+        ast::ItemEnum(_, ref generics) => generics,
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+    };
+
+    let impl_generics = builder.from_generics(generics.clone())
+        .add_ty_param_bound(
+            builder.path().global().ids(&["serde", "ser", "Serialize"]).build()
+        )
+        .build();
+
+    let ty = builder.ty().path()
+        .segment(item.ident).with_generics(impl_generics.clone()).build()
+        .build();
+
+    let body = serialize_body(
+        cx,
+        &builder,
+        &item,
+        &impl_generics,
+        builder.ty()
+            .ref_()
+            .lifetime("'__a")
+            .build_ty(ty.clone()),
+    );
+
+    let where_clause = &impl_generics.where_clause;
+
+    let impl_item = quote_item!(cx,
+        #[automatically_derived]
+        impl $impl_generics ::serde::ser::Serialize for $ty $where_clause {
+            fn serialize<__S>(&self, serializer: &mut __S) -> ::std::result::Result<(), __S::Error>
+                where __S: ::serde::ser::Serializer,
+            {
+                $body
+            }
+        }
+    ).unwrap();
+
+    push(Annotatable::Item(impl_item))
+}
+
+fn serialize_body(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+) -> P<ast::Expr> {
+    match item.node {
+        ast::ItemStruct(ref struct_def, _) => {
+            serialize_item_struct(
+                cx,
+                builder,
+                item,
+                impl_generics,
+                ty,
+                struct_def,
+            )
+        }
+        ast::ItemEnum(ref enum_def, _) => {
+            serialize_item_enum(
+                cx,
+                builder,
+                item.ident,
+                impl_generics,
+                ty,
+                enum_def,
+            )
+        }
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+    }
+}
+
+fn serialize_item_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+) -> P<ast::Expr> {
+    let mut named_fields = vec![];
+    let mut unnamed_fields = 0;
+
+    for field in struct_def.fields.iter() {
+        match field.node.kind {
+            ast::NamedField(name, _) => { named_fields.push(name); }
+            ast::UnnamedField(_) => { unnamed_fields += 1; }
+        }
+    }
+
+    match (named_fields.is_empty(), unnamed_fields == 0) {
+        (true, true) => {
+            serialize_unit_struct(
+                cx,
+                &builder,
+                item.ident,
+            )
+        }
+        (true, false) => {
+            serialize_tuple_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                unnamed_fields,
+            )
+        }
+        (false, true) => {
+            serialize_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                struct_def,
+                named_fields,
+            )
+        }
+        (false, false) => {
+            cx.bug("struct has named and unnamed fields")
+        }
+    }
+}
+
+fn serialize_unit_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident
+) -> P<ast::Expr> {
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, serializer.visit_named_unit($type_name))
+}
+
+fn serialize_tuple_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    fields: usize,
+) -> P<ast::Expr> {
+    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+        cx,
+        builder,
+        ty.clone(),
+        ty,
+        fields,
+        impl_generics,
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_named_seq($type_name, Visitor {
+            value: self,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData,
+        })
+    })
+}
+
+fn serialize_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &StructDef,
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
+        cx,
+        builder,
+        ty.clone(),
+        ty,
+        struct_def,
+        impl_generics,
+        fields.iter().map(|field| quote_expr!(cx, &self.value.$field)),
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_named_map($type_name, Visitor {
+            value: self,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData,
+        })
+    })
+}
+
+fn serialize_item_enum(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    enum_def: &ast::EnumDef,
+) -> P<ast::Expr> {
+    let arms: Vec<ast::Arm> = enum_def.variants.iter()
+        .map(|variant| {
+            serialize_variant(
+                cx,
+                builder,
+                type_ident,
+                impl_generics,
+                ty.clone(),
+                variant,
+            )
+        })
+        .collect();
+
+    quote_expr!(cx,
+        match *self {
+            $arms
+        }
+    )
+}
+
+fn serialize_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    variant: &ast::Variant,
+) -> ast::Arm {
+    let type_name = builder.expr().str(type_ident);
+    let variant_ident = variant.node.name;
+    let variant_name = builder.expr().str(variant_ident);
+
+    match variant.node.kind {
+        ast::TupleVariantKind(ref args) if args.is_empty() => {
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .build();
+
+            quote_arm!(cx,
+                $pat => {
+                    ::serde::ser::Serializer::visit_enum_unit(
+                        serializer,
+                        $type_name,
+                        $variant_name,
+                    )
+                }
+            )
+        }
+        ast::TupleVariantKind(ref args) => {
+            let fields: Vec<ast::Ident> = (0 .. args.len())
+                .map(|i| builder.id(format!("__field{}", i)))
+                .collect();
+
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(fields.iter().map(|field| builder.pat().ref_id(field)))
+                .build();
+
+            let expr = serialize_tuple_variant(
+                cx,
+                builder,
+                type_name,
+                variant_name,
+                generics,
+                ty,
+                args,
+                fields,
+            );
+
+            quote_arm!(cx, $pat => { $expr })
+        }
+        ast::StructVariantKind(ref struct_def) => {
+            let fields: Vec<_> = (0 .. struct_def.fields.len())
+                .map(|i| builder.id(format!("__field{}", i)))
+                .collect();
+
+            let pat = builder.pat().struct_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(
+                    fields.iter()
+                        .zip(struct_def.fields.iter())
+                        .map(|(id, field)| {
+                            let name = match field.node.kind {
+                                ast::NamedField(name, _) => name,
+                                ast::UnnamedField(_) => {
+                                    cx.bug("struct variant has unnamed fields")
+                                }
+                            };
+
+                            (name, builder.pat().ref_id(id))
+                        })
+                )
+                .build();
+
+            let expr = serialize_struct_variant(
+                cx,
+                builder,
+                type_name,
+                variant_name,
+                generics,
+                ty,
+                struct_def,
+                fields,
+            );
+
+            quote_arm!(cx, $pat => { $expr })
+        }
+    }
+}
+
+fn serialize_tuple_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_name: P<ast::Expr>,
+    variant_name: P<ast::Expr>,
+    generics: &ast::Generics,
+    structure_ty: P<ast::Ty>,
+    args: &[ast::VariantArg],
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let variant_ty = builder.ty().tuple()
+        .with_tys(
+            args.iter().map(|arg| {
+                builder.ty()
+                    .ref_()
+                    .lifetime("'__a")
+                    .build_ty(arg.ty.clone())
+            })
+        )
+        .build();
+
+    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+        cx,
+        builder,
+        structure_ty,
+        variant_ty,
+        args.len(),
+        generics,
+    );
+
+    let value_expr = builder.expr().tuple()
+        .with_exprs(
+            fields.iter().map(|field| {
+                builder.expr()
+                    .addr_of()
+                    .id(field)
+            })
+        )
+        .build();
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_enum_seq($type_name, $variant_name, Visitor {
+            value: $value_expr,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData,
+        })
+    })
+}
+
+fn serialize_struct_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_name: P<ast::Expr>,
+    variant_name: P<ast::Expr>,
+    generics: &ast::Generics,
+    structure_ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let value_ty = builder.ty().tuple()
+        .with_tys(
+            struct_def.fields.iter().map(|field| {
+                builder.ty()
+                    .ref_()
+                    .lifetime("'__a")
+                    .build_ty(field.node.ty.clone())
+            })
+        )
+        .build();
+
+    let value_expr = builder.expr().tuple()
+        .with_exprs(
+            fields.iter().map(|field| {
+                builder.expr()
+                    .addr_of()
+                    .id(field)
+            })
+        )
+        .build();
+
+    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
+        cx,
+        builder,
+        structure_ty,
+        value_ty,
+        struct_def,
+        generics,
+        (0 .. fields.len()).map(|i| {
+            builder.expr()
+                .tup_field(i)
+                .field("value").self_()
+        })
+    );
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_enum_map($type_name, $variant_name, Visitor {
+            value: $value_expr,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData,
+        })
+    })
+}
+
+fn serialize_tuple_struct_visitor(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    structure_ty: P<ast::Ty>,
+    variant_ty: P<ast::Ty>,
+    fields: usize,
+    generics: &ast::Generics
+) -> (P<ast::Item>, P<ast::Item>) {
+    let arms: Vec<ast::Arm> = (0 .. fields)
+        .map(|i| {
+            let expr = builder.expr()
+                .tup_field(i)
+                .field("value").self_();
+
+            quote_arm!(cx,
+                $i => {
+                    self.state += 1;
+                    let v = try!(serializer.visit_seq_elt(&$expr));
+                    Ok(Some(v))
+                }
+            )
+        })
+        .collect();
+
+    let visitor_impl_generics = builder.from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let where_clause = &visitor_impl_generics.where_clause;
+
+    let visitor_generics = builder.from_generics(visitor_impl_generics.clone())
+        .strip_bounds()
+        .build();
+
+    // Variants don't necessarily reference all generic lifetimes and type parameters,
+    // so to avoid a compilation failure, we'll just add a phantom type to capture these
+    // unused values.
+    let structure_ty = builder.ty()
+        .phantom_data()
+        .build(structure_ty);
+
+    (
+        quote_item!(cx,
+            struct Visitor $visitor_impl_generics $where_clause {
+                state: usize,
+                value: $variant_ty,
+                _structure_ty: $structure_ty,
+            }
+        ).unwrap(),
+
+        quote_item!(cx,
+            impl $visitor_impl_generics ::serde::ser::SeqVisitor
+            for Visitor $visitor_generics
+            $where_clause {
+                #[inline]
+                fn visit<S>(&mut self, serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
+                    where S: ::serde::ser::Serializer
+                {
+                    match self.state {
+                        $arms
+                        _ => Ok(None)
+                    }
+                }
+
+                #[inline]
+                fn len(&self) -> Option<usize> {
+                    Some($fields)
+                }
+            }
+        ).unwrap(),
+    )
+}
+
+fn serialize_struct_visitor<I>(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    structure_ty: P<ast::Ty>,
+    variant_ty: P<ast::Ty>,
+    struct_def: &StructDef,
+    generics: &ast::Generics,
+    value_exprs: I,
+) -> (P<ast::Item>, P<ast::Item>)
+    where I: Iterator<Item=P<ast::Expr>>,
+{
+    let len = struct_def.fields.len();
+
+    let field_attrs = struct_field_attrs(cx, builder, struct_def);
+
+    let arms: Vec<ast::Arm> = field_attrs.into_iter()
+        .zip(value_exprs)
+        .enumerate()
+        .map(|(i, (field, value_expr))| {
+            let key_expr = field.serializer_key_expr(cx);
+            quote_arm!(cx,
+                $i => {
+                    self.state += 1;
+                    Ok(
+                        Some(
+                            try!(
+                                serializer.visit_map_elt(
+                                    $key_expr,
+                                    $value_expr,
+                                )
+                            )
+                        )
+                    )
+                }
+            )
+        })
+        .collect();
+
+    let visitor_impl_generics = builder.from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let where_clause = &visitor_impl_generics.where_clause;
+
+    let visitor_generics = builder.from_generics(visitor_impl_generics.clone())
+        .strip_bounds()
+        .build();
+
+    // Variants don't necessarily reference all generic lifetimes and type parameters,
+    // so to avoid a compilation failure, we'll just add a phantom type to capture these
+    // unused values.
+    let structure_ty = builder.ty()
+        .phantom_data()
+        .build(structure_ty);
+
+    (
+        quote_item!(cx,
+            struct Visitor $visitor_impl_generics $where_clause {
+                state: usize,
+                value: $variant_ty,
+                _structure_ty: $structure_ty,
+            }
+        ).unwrap(),
+
+        quote_item!(cx,
+            impl $visitor_impl_generics
+            ::serde::ser::MapVisitor
+            for Visitor $visitor_generics
+            $where_clause {
+                #[inline]
+                fn visit<S>(&mut self, serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
+                    where S: ::serde::ser::Serializer,
+                {
+                    match self.state {
+                        $arms
+                        _ => Ok(None)
+                    }
+                }
+
+                #[inline]
+                fn len(&self) -> Option<usize> {
+                    Some($len)
+                }
+            }
+        ).unwrap(),
+    )
+}

serde_core/Cargo.toml

@@ -1,70 +0,0 @@
-[package]
-name = "serde_core"
-version = "1.0.228"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-build = "build.rs"
-categories = ["encoding", "no-std", "no-std::no-alloc"]
-description = "Serde traits only, with no support for derive -- use the `serde` crate instead"
-documentation = "https://docs.rs/serde_core"
-edition = "2021"
-homepage = "https://serde.rs"
-keywords = ["serde", "serialization", "no_std"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/serde-rs/serde"
-rust-version = "1.56"
-
-[dev-dependencies]
-serde = { version = "1", path = "../serde" }
-serde_derive = { version = "1", path = "../serde_derive" }
-
-[package.metadata.playground]
-features = ["rc", "result"]
-
-[package.metadata.docs.rs]
-features = ["rc", "result", "unstable"]
-targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = [
-    "--generate-link-to-definition",
-    "--generate-macro-expansion",
-    "--extern-html-root-url=core=https://doc.rust-lang.org",
-    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
-    "--extern-html-root-url=std=https://doc.rust-lang.org",
-]
-
-# 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.228", path = "../serde_derive" }
-
-
-### FEATURES #################################################################
-
-[features]
-default = ["std", "result"]
-
-# Provide impls for common standard library types like Vec<T> and HashMap<K, V>.
-# Requires a dependency on the Rust standard library.
-std = []
-
-# Provide impls for types that require unstable functionality. For tracking and
-# discussion of unstable functionality please refer to this issue:
-#
-#    https://github.com/serde-rs/serde/issues/812
-unstable = []
-
-# Provide impls for types in the Rust core allocation and collections library
-# including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
-# be enabled without depending on all of std.
-alloc = []
-
-# Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
-# does not preserve identity and may result in multiple copies of the same data.
-# Be sure that this is what you want before enabling this feature.
-rc = []
-
-# Provide impls for Result<T, E>. Convenient in some contexts but can lead to
-# confusion if ? or unwrap are used incautiously.
-result = []

serde_core/LICENSE-APACHE

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

serde_core/LICENSE-MIT

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

serde_core/README.md

@@ -1,28 +0,0 @@
-The `serde_core` crate contains Serde's trait definitions with **no support for
-#\[derive()\]**.
-
-In crates that derive an implementation of `Serialize` or `Deserialize`, you
-must depend on the [`serde`] crate, not `serde_core`.
-
-[`serde`]: https://crates.io/crates/serde
-
-In crates that handwrite implementations of Serde traits, or only use them as
-trait bounds, depending on `serde_core` is permitted. But `serde` re-exports all
-of these traits and can be used for this use case too. If in doubt, disregard
-`serde_core` and always use `serde`.
-
-Crates that depend on `serde_core` instead of `serde` are able to compile in
-parallel with `serde_derive` even when `serde`'s "derive" feature is turned on,
-as shown in the following build timings.
-
-<br>
-
-| When `serde_json` depends on `serde` |
-|---|
-| <img src="https://github.com/user-attachments/assets/78dc179c-6ab1-4059-928c-1474b0d9d0bb"> |
-
-<br>
-
-| When `serde_json` depends on `serde_core` |
-|---|
-| <img src="https://github.com/user-attachments/assets/6b6cff5e-3e45-4ac7-9db1-d99ee8b9f5f7"> |

serde_core/build.rs

@@ -1,113 +0,0 @@
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-use std::process::Command;
-use std::str;
-
-const PRIVATE: &str = "\
-#[doc(hidden)]
-pub mod __private$$ {
-    #[doc(hidden)]
-    pub use crate::private::*;
-}
-";
-
-// The rustc-cfg strings below are *not* public API. Please let us know by
-// opening a GitHub issue if your build environment requires some way to enable
-// these cfgs other than by executing our build script.
-fn main() {
-    println!("cargo:rerun-if-changed=build.rs");
-
-    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let patch_version = env::var("CARGO_PKG_VERSION_PATCH").unwrap();
-    let module = PRIVATE.replace("$$", &patch_version);
-    fs::write(out_dir.join("private.rs"), module).unwrap();
-
-    let minor = match rustc_minor_version() {
-        Some(minor) => minor,
-        None => return,
-    };
-
-    if minor >= 77 {
-        println!("cargo:rustc-check-cfg=cfg(if_docsrs_then_no_serde_core)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_cstr)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_error)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_net)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_num_saturating)");
-        println!("cargo:rustc-check-cfg=cfg(no_diagnostic_namespace)");
-        println!("cargo:rustc-check-cfg=cfg(no_serde_derive)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic64)");
-        println!("cargo:rustc-check-cfg=cfg(no_target_has_atomic)");
-    }
-
-    let target = env::var("TARGET").unwrap();
-    let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten";
-
-    // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60.
-    if minor < 60 {
-        println!("cargo:rustc-cfg=no_target_has_atomic");
-        // Allowlist of archs that support std::sync::atomic module. This is
-        // based on rustc's compiler/rustc_target/src/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el")
-            || target.starts_with("riscv64");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if minor < 34 || !has_atomic64 {
-            println!("cargo:rustc-cfg=no_std_atomic64");
-        }
-        if minor < 34 || !has_atomic32 {
-            println!("cargo:rustc-cfg=no_std_atomic");
-        }
-    }
-
-    // Support for core::ffi::CStr and alloc::ffi::CString stabilized in Rust 1.64.
-    // https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html#c-compatible-ffi-types-in-core-and-alloc
-    if minor < 64 {
-        println!("cargo:rustc-cfg=no_core_cstr");
-    }
-
-    // Current minimum supported version of serde_derive crate is Rust 1.68.
-    if minor < 68 {
-        println!("cargo:rustc-cfg=no_serde_derive");
-    }
-
-    // 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");
-    }
-
-    // Support for core::net stabilized in Rust 1.77.
-    // https://blog.rust-lang.org/2024/03/21/Rust-1.77.0.html
-    if minor < 77 {
-        println!("cargo:rustc-cfg=no_core_net");
-    }
-
-    // Support for the `#[diagnostic]` tool attribute namespace
-    // https://blog.rust-lang.org/2024/05/02/Rust-1.78.0.html#diagnostic-attributes
-    if minor < 78 {
-        println!("cargo:rustc-cfg=no_diagnostic_namespace");
-    }
-
-    // The Error trait became available in core in 1.81.
-    // https://blog.rust-lang.org/2024/09/05/Rust-1.81.0.html#coreerrorerror
-    if minor < 81 {
-        println!("cargo:rustc-cfg=no_core_error");
-    }
-}
-
-fn rustc_minor_version() -> Option<u32> {
-    let rustc = env::var_os("RUSTC")?;
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return None;
-    }
-    pieces.next()?.parse().ok()
-}

serde_core/src/crate_root.rs

@@ -1,171 +0,0 @@
-macro_rules! crate_root {
-    () => {
-        /// A facade around all the types we need from the `std`, `core`, and `alloc`
-        /// crates. This avoids elaborate import wrangling having to happen in every
-        /// module.
-        mod lib {
-            mod core {
-                #[cfg(not(feature = "std"))]
-                pub use core::*;
-                #[cfg(feature = "std")]
-                pub use std::*;
-            }
-
-            pub use self::core::{f32, f64};
-            pub use self::core::{iter, num, str};
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            pub use self::core::{cmp, mem};
-
-            pub use self::core::cell::{Cell, RefCell};
-            pub use self::core::cmp::Reverse;
-            pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
-            pub use self::core::marker::PhantomData;
-            pub use self::core::num::Wrapping;
-            pub use self::core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
-            pub use self::core::result;
-            pub use self::core::time::Duration;
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::borrow::{Cow, ToOwned};
-            #[cfg(feature = "std")]
-            pub use std::borrow::{Cow, ToOwned};
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::string::{String, ToString};
-            #[cfg(feature = "std")]
-            pub use std::string::{String, ToString};
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::vec::Vec;
-            #[cfg(feature = "std")]
-            pub use std::vec::Vec;
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::boxed::Box;
-            #[cfg(feature = "std")]
-            pub use std::boxed::Box;
-
-            #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-            pub use alloc::rc::{Rc, Weak as RcWeak};
-            #[cfg(all(feature = "rc", feature = "std"))]
-            pub use std::rc::{Rc, Weak as RcWeak};
-
-            #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-            pub use alloc::sync::{Arc, Weak as ArcWeak};
-            #[cfg(all(feature = "rc", feature = "std"))]
-            pub use std::sync::{Arc, Weak as ArcWeak};
-
-            #[cfg(all(feature = "alloc", not(feature = "std")))]
-            pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-            #[cfg(feature = "std")]
-            pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-
-            #[cfg(all(not(no_core_cstr), not(feature = "std")))]
-            pub use self::core::ffi::CStr;
-            #[cfg(feature = "std")]
-            pub use std::ffi::CStr;
-
-            #[cfg(all(not(no_core_cstr), feature = "alloc", not(feature = "std")))]
-            pub use alloc::ffi::CString;
-            #[cfg(feature = "std")]
-            pub use std::ffi::CString;
-
-            #[cfg(all(not(no_core_net), not(feature = "std")))]
-            pub use self::core::net;
-            #[cfg(feature = "std")]
-            pub use std::net;
-
-            #[cfg(feature = "std")]
-            pub use std::error;
-
-            #[cfg(feature = "std")]
-            pub use std::collections::{HashMap, HashSet};
-            #[cfg(feature = "std")]
-            pub use std::ffi::{OsStr, OsString};
-            #[cfg(feature = "std")]
-            pub use std::hash::{BuildHasher, Hash};
-            #[cfg(feature = "std")]
-            pub use std::io::Write;
-            #[cfg(feature = "std")]
-            pub use std::path::{Path, PathBuf};
-            #[cfg(feature = "std")]
-            pub use std::sync::{Mutex, RwLock};
-            #[cfg(feature = "std")]
-            pub use std::time::{SystemTime, UNIX_EPOCH};
-
-            #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic)))]
-            pub use std::sync::atomic::{
-                AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32,
-                AtomicU8, AtomicUsize, Ordering,
-            };
-            #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))]
-            pub use std::sync::atomic::{AtomicI64, AtomicU64};
-
-            #[cfg(all(feature = "std", not(no_target_has_atomic)))]
-            pub use std::sync::atomic::Ordering;
-            #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))]
-            pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
-            #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))]
-            pub use std::sync::atomic::{AtomicI16, AtomicU16};
-            #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))]
-            pub use std::sync::atomic::{AtomicI32, AtomicU32};
-            #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))]
-            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
-        // performed implicitly by the `?` operator or the standard library's `try!`
-        // macro. This simplified macro gives a 5.5% improvement in compile time
-        // compared to standard `try!`, and 9% improvement compared to `?`.
-        macro_rules! tri {
-            ($expr:expr) => {
-                match $expr {
-                    Ok(val) => val,
-                    Err(err) => return Err(err),
-                }
-            };
-        }
-
-        #[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/de/mod.rs")]
-        pub mod de;
-        #[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/ser/mod.rs")]
-        pub mod ser;
-
-        #[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/format.rs")]
-        mod format;
-
-        #[doc(inline)]
-        pub use crate::de::{Deserialize, Deserializer};
-        #[doc(inline)]
-        pub use crate::ser::{Serialize, Serializer};
-
-        // Used by generated code. Not public API.
-        #[doc(hidden)]
-        #[cfg_attr(
-            all(docsrs, if_docsrs_then_no_serde_core),
-            path = "core/private/mod.rs"
-        )]
-        mod private;
-
-        // Used by declarative macro generated code. Not public API.
-        #[doc(hidden)]
-        pub mod __private {
-            #[doc(hidden)]
-            pub use crate::private::doc;
-            #[doc(hidden)]
-            pub use core::result::Result;
-        }
-
-        include!(concat!(env!("OUT_DIR"), "/private.rs"));
-
-        #[cfg(all(not(feature = "std"), no_core_error))]
-        #[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/std_error.rs")]
-        mod std_error;
-    };
-}

serde_core/src/de/ignored_any.rs

@@ -1,238 +0,0 @@
-use crate::lib::*;
-
-use crate::de::{
-    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
-};
-
-/// An efficient way of discarding data from a deserializer.
-///
-/// Think of this like `serde_json::Value` in that it can be deserialized from
-/// any type, except that it does not store any information about the data that
-/// gets deserialized.
-///
-/// ```edition2021
-/// use serde::de::{
-///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
-/// };
-/// use std::fmt;
-/// use std::marker::PhantomData;
-///
-/// /// A seed that can be used to deserialize only the `n`th element of a sequence
-/// /// while efficiently discarding elements of any type before or after index `n`.
-/// ///
-/// /// For example to deserialize only the element at index 3:
-/// ///
-/// /// ```
-/// /// NthElement::new(3).deserialize(deserializer)
-/// /// ```
-/// pub struct NthElement<T> {
-///     n: usize,
-///     marker: PhantomData<T>,
-/// }
-///
-/// impl<T> NthElement<T> {
-///     pub fn new(n: usize) -> Self {
-///         NthElement {
-///             n: n,
-///             marker: PhantomData,
-///         }
-///     }
-/// }
-///
-/// impl<'de, T> Visitor<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(
-///             formatter,
-///             "a sequence in which we care about element {}",
-///             self.n
-///         )
-///     }
-///
-///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-///     where
-///         A: SeqAccess<'de>,
-///     {
-///         // Skip over the first `n` elements.
-///         for i in 0..self.n {
-///             // It is an error if the sequence ends before we get to element `n`.
-///             if seq.next_element::<IgnoredAny>()?.is_none() {
-///                 return Err(de::Error::invalid_length(i, &self));
-///             }
-///         }
-///
-///         // Deserialize the one we care about.
-///         let nth = match seq.next_element()? {
-///             Some(nth) => nth,
-///             None => {
-///                 return Err(de::Error::invalid_length(self.n, &self));
-///             }
-///         };
-///
-///         // Skip over any remaining elements in the sequence after `n`.
-///         while let Some(IgnoredAny) = seq.next_element()? {
-///             // ignore
-///         }
-///
-///         Ok(nth)
-///     }
-/// }
-///
-/// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///     where
-///         D: Deserializer<'de>,
-///     {
-///         deserializer.deserialize_seq(self)
-///     }
-/// }
-///
-/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// # where
-/// #     D: Deserializer<'de>,
-/// # {
-/// // Deserialize only the sequence element at index 3 from this deserializer.
-/// // The element at index 3 is required to be a string. Elements before and
-/// // after index 3 are allowed to be of any type.
-/// let s: String = NthElement::new(3).deserialize(deserializer)?;
-/// #     Ok(())
-/// # }
-/// ```
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct IgnoredAny;
-
-impl<'de> Visitor<'de> for IgnoredAny {
-    type Value = IgnoredAny;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("anything at all")
-    }
-
-    #[inline]
-    fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_i64<E>(self, x: i64) -> 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]
-    fn visit_u64<E>(self, x: u64) -> 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]
-    fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = s;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_none<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        while let Some(IgnoredAny) = tri!(seq.next_element()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-    where
-        A: MapAccess<'de>,
-    {
-        while let Some((IgnoredAny, IgnoredAny)) = tri!(map.next_entry()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = bytes;
-        Ok(IgnoredAny)
-    }
-
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        tri!(data.variant::<IgnoredAny>()).1.newtype_variant()
-    }
-}
-
-impl<'de> Deserialize<'de> for IgnoredAny {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_ignored_any(IgnoredAny)
-    }
-}

serde_core/src/format.rs

@@ -1,30 +0,0 @@
-use crate::lib::fmt::{self, Write};
-use crate::lib::str;
-
-pub(super) struct Buf<'a> {
-    bytes: &'a mut [u8],
-    offset: usize,
-}
-
-impl<'a> Buf<'a> {
-    pub fn new(bytes: &'a mut [u8]) -> Self {
-        Buf { bytes, offset: 0 }
-    }
-
-    pub fn as_str(&self) -> &str {
-        let slice = &self.bytes[..self.offset];
-        unsafe { str::from_utf8_unchecked(slice) }
-    }
-}
-
-impl<'a> Write for Buf<'a> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        if self.offset + s.len() > self.bytes.len() {
-            Err(fmt::Error)
-        } else {
-            self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes());
-            self.offset += s.len();
-            Ok(())
-        }
-    }
-}

serde_core/src/lib.rs

@@ -1,121 +0,0 @@
-//! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
-//! structures efficiently and generically.
-//!
-//! The `serde_core` crate contains Serde's trait definitions with **no support
-//! for #\[derive()\]**.
-//!
-//! In crates that derive an implementation of `Serialize` or `Deserialize`, you
-//! must depend on the [`serde`] crate, not `serde_core`.
-//!
-//! [`serde`]: https://crates.io/crates/serde
-//!
-//! In crates that handwrite implementations of Serde traits, or only use them
-//! as trait bounds, depending on `serde_core` is permitted. But `serde`
-//! re-exports all of these traits and can be used for this use case too. If in
-//! doubt, disregard `serde_core` and always use `serde`.
-//!
-//! Crates that depend on `serde_core` instead of `serde` are able to compile in
-//! parallel with `serde_derive` even when `serde`'s "derive" feature is turned on,
-//! as shown in the following build timings.
-//!
-//! <br>
-//!
-//! <table>
-//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde</code></td></tr>
-//! <tr><td><img src="https://github.com/user-attachments/assets/78dc179c-6ab1-4059-928c-1474b0d9d0bb"></td></tr>
-//! </table>
-//!
-//! <br>
-//!
-//! <table>
-//! <tr><td align="center">When <code>serde_json</code> depends on <code>serde_core</code></td></tr>
-//! <tr><td><img src="https://github.com/user-attachments/assets/6b6cff5e-3e45-4ac7-9db1-d99ee8b9f5f7"></td></tr>
-//! </table>
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde_core/1.0.228")]
-// 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(docsrs, feature(doc_cfg, rustdoc_internals))]
-#![cfg_attr(docsrs, allow(internal_features))]
-// Unstable functionality only if the user asks for it. For tracking and
-// discussion of these features please refer to this issue:
-//
-//    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(never_type))]
-#![allow(unknown_lints, bare_trait_objects, deprecated)]
-// Ignored clippy and clippy_pedantic lints
-#![allow(
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-    clippy::unnested_or_patterns,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
-    clippy::semicolon_if_nothing_returned,
-    // not available in our oldest supported compiler
-    clippy::empty_enums,
-    clippy::type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
-    // 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::single_match_else,
-    clippy::type_complexity,
-    clippy::use_self,
-    clippy::zero_prefixed_literal,
-    // correctly used
-    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,
-    clippy::result_unit_err,
-    clippy::wildcard_imports,
-    // not practical
-    clippy::needless_pass_by_value,
-    clippy::similar_names,
-    clippy::too_many_lines,
-    // preference
-    clippy::doc_markdown,
-    clippy::elidable_lifetime_names,
-    clippy::needless_lifetimes,
-    clippy::unseparated_literal_suffix,
-    // false positive
-    clippy::needless_doctest_main,
-    // noisy
-    clippy::missing_errors_doc,
-    clippy::must_use_candidate,
-)]
-// Restrictions
-#![deny(clippy::question_mark_used)]
-// Rustc lints.
-#![deny(missing_docs, unused_imports)]
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "alloc")]
-extern crate alloc;
-
-#[macro_use]
-mod crate_root;
-#[macro_use]
-mod macros;
-
-crate_root!();
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! __require_serde_not_serde_core {
-    () => {
-        ::core::compile_error!(
-            "Serde derive requires a dependency on the serde crate, not serde_core"
-        );
-    };
-}

serde_core/src/macros.rs

@@ -1,230 +0,0 @@
-// Super explicit first paragraph because this shows up at the top level and
-// trips up people who are just looking for basic Serialize / Deserialize
-// documentation.
-/// Helper macro when implementing the `Deserializer` part of a new data format
-/// for Serde.
-///
-/// Some [`Deserializer`] implementations for self-describing formats do not
-/// care what hint the [`Visitor`] gives them, they just want to blindly call
-/// the [`Visitor`] method corresponding to the data they can tell is in the
-/// input. This requires repetitive implementations of all the [`Deserializer`]
-/// trait methods.
-///
-/// ```edition2021
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// #
-/// # struct MyDeserializer;
-/// #
-/// # impl<'de> Deserializer<'de> for MyDeserializer {
-/// #     type Error = value::Error;
-/// #
-/// #     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
-/// #     where
-/// #         V: Visitor<'de>,
-/// #     {
-/// #         unimplemented!()
-/// #     }
-/// #
-/// #[inline]
-/// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-/// where
-///     V: Visitor<'de>,
-/// {
-///     self.deserialize_any(visitor)
-/// }
-/// #
-/// #     forward_to_deserialize_any! {
-/// #         i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-/// #         bytes byte_buf option unit unit_struct newtype_struct seq tuple
-/// #         tuple_struct map struct enum identifier ignored_any
-/// #     }
-/// # }
-/// ```
-///
-/// The `forward_to_deserialize_any!` macro implements these simple forwarding
-/// methods so that they forward directly to [`Deserializer::deserialize_any`].
-/// You can choose which methods to forward.
-///
-/// ```edition2021
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// #
-/// # struct MyDeserializer;
-/// #
-/// impl<'de> Deserializer<'de> for MyDeserializer {
-/// #   type Error = value::Error;
-/// #
-///     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-///     where
-///         V: Visitor<'de>,
-///     {
-///         /* ... */
-/// #       let _ = visitor;
-/// #       unimplemented!()
-///     }
-///
-///     forward_to_deserialize_any! {
-///         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-///         bytes byte_buf option unit unit_struct newtype_struct seq tuple
-///         tuple_struct map struct enum identifier ignored_any
-///     }
-/// }
-/// ```
-///
-/// The macro assumes the convention that your `Deserializer` lifetime parameter
-/// is called `'de` and that the `Visitor` type parameters on each method are
-/// called `V`. A different type parameter and a different lifetime can be
-/// specified explicitly if necessary.
-///
-/// ```edition2021
-/// # use serde::forward_to_deserialize_any;
-/// # use serde::de::{value, Deserializer, Visitor};
-/// # use std::marker::PhantomData;
-/// #
-/// # struct MyDeserializer<V>(PhantomData<V>);
-/// #
-/// # impl<'q, V> Deserializer<'q> for MyDeserializer<V> {
-/// #     type Error = value::Error;
-/// #
-/// #     fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error>
-/// #     where
-/// #         W: Visitor<'q>,
-/// #     {
-/// #         unimplemented!()
-/// #     }
-/// #
-/// forward_to_deserialize_any! {
-///     <W: Visitor<'q>>
-///     bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-///     bytes byte_buf option unit unit_struct newtype_struct seq tuple
-///     tuple_struct map struct enum identifier ignored_any
-/// }
-/// # }
-/// ```
-///
-/// [`Deserializer`]: crate::Deserializer
-/// [`Visitor`]: crate::de::Visitor
-/// [`Deserializer::deserialize_any`]: crate::Deserializer::deserialize_any
-#[macro_export(local_inner_macros)]
-macro_rules! forward_to_deserialize_any {
-    (<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => {
-        $(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})*
-    };
-    // This case must be after the previous one.
-    ($($func:ident)*) => {
-        $(forward_to_deserialize_any_helper!{$func<'de, V>})*
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-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 as $crate::de::Deserializer<$l>>::Error>
-        where
-            $v: $crate::de::Visitor<$l>,
-        {
-            $(
-                let _ = $arg;
-            )*
-            self.deserialize_any(visitor)
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! forward_to_deserialize_any_helper {
-    (bool<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()}
-    };
-    (i8<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i8<$l, $v>()}
-    };
-    (i16<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i16<$l, $v>()}
-    };
-    (i32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i32<$l, $v>()}
-    };
-    (i64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
-    };
-    (i128<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
-    };
-    (u8<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
-    };
-    (u16<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u16<$l, $v>()}
-    };
-    (u32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u32<$l, $v>()}
-    };
-    (u64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
-    };
-    (u128<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
-    };
-    (f32<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
-    };
-    (f64<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_f64<$l, $v>()}
-    };
-    (char<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_char<$l, $v>()}
-    };
-    (str<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_str<$l, $v>()}
-    };
-    (string<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_string<$l, $v>()}
-    };
-    (bytes<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_bytes<$l, $v>()}
-    };
-    (byte_buf<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_byte_buf<$l, $v>()}
-    };
-    (option<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_option<$l, $v>()}
-    };
-    (unit<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_unit<$l, $v>()}
-    };
-    (unit_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_unit_struct<$l, $v>(name: &'static str)}
-    };
-    (newtype_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_newtype_struct<$l, $v>(name: &'static str)}
-    };
-    (seq<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_seq<$l, $v>()}
-    };
-    (tuple<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_tuple<$l, $v>(len: usize)}
-    };
-    (tuple_struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_tuple_struct<$l, $v>(name: &'static str, len: usize)}
-    };
-    (map<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_map<$l, $v>()}
-    };
-    (struct<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_struct<$l, $v>(name: &'static str, fields: &'static [&'static str])}
-    };
-    (enum<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_enum<$l, $v>(name: &'static str, variants: &'static [&'static str])}
-    };
-    (identifier<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_identifier<$l, $v>()}
-    };
-    (ignored_any<$l:tt, $v:ident>) => {
-        forward_to_deserialize_any_method!{deserialize_ignored_any<$l, $v>()}
-    };
-}

serde_core/src/private/content.rs

@@ -1,39 +0,0 @@
-use crate::lib::*;
-
-// Used from generated code to buffer the contents of the Deserializer when
-// deserializing untagged enums and internally tagged enums.
-//
-// Not public API. Use serde-value instead.
-//
-// Obsoleted by format-specific buffer types (https://github.com/serde-rs/serde/pull/2912).
-#[doc(hidden)]
-pub enum Content<'de> {
-    Bool(bool),
-
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-
-    F32(f32),
-    F64(f64),
-
-    Char(char),
-    String(String),
-    Str(&'de str),
-    ByteBuf(Vec<u8>),
-    Bytes(&'de [u8]),
-
-    None,
-    Some(Box<Content<'de>>),
-
-    Unit,
-    Newtype(Box<Content<'de>>),
-    Seq(Vec<Content<'de>>),
-    Map(Vec<(Content<'de>, Content<'de>)>),
-}

serde_core/src/private/doc.rs

@@ -1,165 +0,0 @@
-// Used only by Serde doc tests. Not public API.
-
-use crate::lib::*;
-
-use crate::ser;
-
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct Error;
-
-#[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)]
-impl ser::Error for Error {
-    fn custom<T>(_: T) -> Self
-    where
-        T: Display,
-    {
-        unimplemented!()
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        unimplemented!()
-    }
-}
-
-#[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)]
-impl Display for Error {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        unimplemented!()
-    }
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __private_serialize {
-    () => {
-        trait Serialize {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::Serializer;
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! __serialize_unimplemented {
-    ($($func:ident)*) => {
-        $(
-            __serialize_unimplemented_helper!($func);
-        )*
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __serialize_unimplemented_method {
-    ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error>
-        where
-            $($t: ?Sized + $crate::Serialize,)*
-        {
-            unimplemented!()
-        }
-    };
-}
-
-#[doc(hidden)]
-#[macro_export(local_inner_macros)]
-macro_rules! __serialize_unimplemented_helper {
-    (bool) => {
-        __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
-    };
-    (i8) => {
-        __serialize_unimplemented_method!(serialize_i8(i8) -> Ok);
-    };
-    (i16) => {
-        __serialize_unimplemented_method!(serialize_i16(i16) -> Ok);
-    };
-    (i32) => {
-        __serialize_unimplemented_method!(serialize_i32(i32) -> Ok);
-    };
-    (i64) => {
-        __serialize_unimplemented_method!(serialize_i64(i64) -> Ok);
-    };
-    (u8) => {
-        __serialize_unimplemented_method!(serialize_u8(u8) -> Ok);
-    };
-    (u16) => {
-        __serialize_unimplemented_method!(serialize_u16(u16) -> Ok);
-    };
-    (u32) => {
-        __serialize_unimplemented_method!(serialize_u32(u32) -> Ok);
-    };
-    (u64) => {
-        __serialize_unimplemented_method!(serialize_u64(u64) -> Ok);
-    };
-    (f32) => {
-        __serialize_unimplemented_method!(serialize_f32(f32) -> Ok);
-    };
-    (f64) => {
-        __serialize_unimplemented_method!(serialize_f64(f64) -> Ok);
-    };
-    (char) => {
-        __serialize_unimplemented_method!(serialize_char(char) -> Ok);
-    };
-    (str) => {
-        __serialize_unimplemented_method!(serialize_str(&str) -> Ok);
-    };
-    (bytes) => {
-        __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok);
-    };
-    (none) => {
-        __serialize_unimplemented_method!(serialize_none() -> Ok);
-    };
-    (some) => {
-        __serialize_unimplemented_method!(serialize_some<T>(&T) -> Ok);
-    };
-    (unit) => {
-        __serialize_unimplemented_method!(serialize_unit() -> Ok);
-    };
-    (unit_struct) => {
-        __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok);
-    };
-    (unit_variant) => {
-        __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok);
-    };
-    (newtype_struct) => {
-        __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str, &T) -> Ok);
-    };
-    (newtype_variant) => {
-        __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str, u32, &str, &T) -> Ok);
-    };
-    (seq) => {
-        type SerializeSeq = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_seq(Option<usize>) -> SerializeSeq);
-    };
-    (tuple) => {
-        type SerializeTuple = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple);
-    };
-    (tuple_struct) => {
-        type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct);
-    };
-    (tuple_variant) => {
-        type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant);
-    };
-    (map) => {
-        type SerializeMap = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_map(Option<usize>) -> SerializeMap);
-    };
-    (struct) => {
-        type SerializeStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct);
-    };
-    (struct_variant) => {
-        type SerializeStructVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
-        __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant);
-    };
-}

serde_core/src/private/mod.rs

@@ -1,21 +0,0 @@
-#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
-mod content;
-mod seed;
-
-// FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed.
-#[doc(hidden)]
-pub mod doc;
-
-#[doc(hidden)]
-pub mod size_hint;
-
-#[doc(hidden)]
-pub mod string;
-
-#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
-#[doc(hidden)]
-pub use self::content::Content;
-#[doc(hidden)]
-pub use self::seed::InPlaceSeed;
-#[doc(hidden)]
-pub use crate::lib::result::Result;

serde_core/src/private/seed.rs

@@ -1,20 +0,0 @@
-use crate::de::{Deserialize, DeserializeSeed, Deserializer};
-
-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-#[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)]
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
-    }
-}

serde_core/src/private/size_hint.rs

@@ -1,30 +0,0 @@
-#[cfg(any(feature = "std", feature = "alloc"))]
-use crate::lib::*;
-
-pub fn from_bounds<I>(iter: &I) -> Option<usize>
-where
-    I: Iterator,
-{
-    helper(iter.size_hint())
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub fn cautious<Element>(hint: Option<usize>) -> usize {
-    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
-
-    if mem::size_of::<Element>() == 0 {
-        0
-    } else {
-        cmp::min(
-            hint.unwrap_or(0),
-            MAX_PREALLOC_BYTES / mem::size_of::<Element>(),
-        )
-    }
-}
-
-fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
-    match bounds {
-        (lower, Some(upper)) if lower == upper => Some(upper),
-        _ => None,
-    }
-}

serde_core/src/private/string.rs

@@ -1,23 +0,0 @@
-use crate::lib::*;
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[doc(hidden)]
-pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<'_, str> {
-    String::from_utf8_lossy(bytes)
-}
-
-// The generated code calls this like:
-//
-//     let value = &_serde::__private::from_utf8_lossy(bytes);
-//     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-//
-// so it is okay for the return type to be different from the std case as long
-// as the above works.
-#[cfg(not(any(feature = "std", feature = "alloc")))]
-#[doc(hidden)]
-pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
-    // Three unicode replacement characters if it fails. They look like a
-    // white-on-black question mark. The user will recognize it as invalid
-    // UTF-8.
-    str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-}

serde_core/src/ser/fmt.rs

@@ -1,170 +0,0 @@
-use crate::lib::*;
-use crate::ser::{Error, Impossible, Serialize, Serializer};
-
-impl Error for fmt::Error {
-    fn custom<T: Display>(_msg: T) -> Self {
-        fmt::Error
-    }
-}
-
-macro_rules! fmt_primitives {
-    ($($f:ident: $t:ty,)*) => {
-        $(
-            fn $f(self, v: $t) -> fmt::Result {
-                Display::fmt(&v, self)
-            }
-        )*
-    };
-}
-
-/// ```edition2021
-/// use serde::ser::Serialize;
-/// use serde_derive::Serialize;
-/// use std::fmt::{self, Display};
-///
-/// #[derive(Serialize)]
-/// #[serde(rename_all = "kebab-case")]
-/// pub enum MessageType {
-///     StartRequest,
-///     EndRequest,
-/// }
-///
-/// impl Display for MessageType {
-///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-///         self.serialize(f)
-///     }
-/// }
-/// ```
-impl<'a> Serializer for &mut fmt::Formatter<'a> {
-    type Ok = ();
-    type Error = fmt::Error;
-    type SerializeSeq = Impossible<(), fmt::Error>;
-    type SerializeTuple = Impossible<(), fmt::Error>;
-    type SerializeTupleStruct = Impossible<(), fmt::Error>;
-    type SerializeTupleVariant = Impossible<(), fmt::Error>;
-    type SerializeMap = Impossible<(), fmt::Error>;
-    type SerializeStruct = Impossible<(), fmt::Error>;
-    type SerializeStructVariant = Impossible<(), fmt::Error>;
-
-    fmt_primitives! {
-        serialize_bool: bool,
-        serialize_i8: i8,
-        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,
-        serialize_str: &str,
-        serialize_unit_struct: &'static str,
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> fmt::Result {
-        Display::fmt(variant, self)
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> fmt::Result
-    where
-        T: ?Sized + Serialize,
-    {
-        Serialize::serialize(value, self)
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_none(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> fmt::Result
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_unit(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> fmt::Result
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn collect_str<T>(self, value: &T) -> fmt::Result
-    where
-        T: ?Sized + Display,
-    {
-        Display::fmt(value, self)
-    }
-}

serde_core/src/ser/impossible.rs

@@ -1,216 +0,0 @@
-//! This module contains `Impossible` serializer and its implementations.
-
-use crate::lib::*;
-
-use crate::ser::{
-    self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
-    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
-};
-
-/// Helper type for implementing a `Serializer` that does not support
-/// serializing one of the compound types.
-///
-/// This type cannot be instantiated, but implements every one of the traits
-/// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],
-/// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
-/// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
-///
-/// ```edition2021
-/// # use serde::ser::{Serializer, Impossible};
-/// # use serde_core::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     type SerializeSeq = Impossible<(), Error>;
-///     /* other associated types */
-///
-///     /// This data format does not support serializing sequences.
-///     fn serialize_seq(self,
-///                      len: Option<usize>)
-///                      -> Result<Self::SerializeSeq, Error> {
-///         // Given Impossible cannot be instantiated, the only
-///         // thing we can do here is to return an error.
-/// #         stringify! {
-///         Err(...)
-/// #         };
-/// #         unimplemented!()
-///     }
-///
-///     /* other Serializer methods */
-/// #     serde_core::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// [`Serializer`]: crate::Serializer
-/// [`SerializeSeq`]: crate::ser::SerializeSeq
-/// [`SerializeTuple`]: crate::ser::SerializeTuple
-/// [`SerializeTupleStruct`]: crate::ser::SerializeTupleStruct
-/// [`SerializeTupleVariant`]: crate::ser::SerializeTupleVariant
-/// [`SerializeMap`]: crate::ser::SerializeMap
-/// [`SerializeStruct`]: crate::ser::SerializeStruct
-/// [`SerializeStructVariant`]: crate::ser::SerializeStructVariant
-pub struct Impossible<Ok, Error> {
-    void: Void,
-    ok: PhantomData<Ok>,
-    error: PhantomData<Error>,
-}
-
-enum Void {}
-
-impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = key;
-        match self.void {}
-    }
-
-    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: ?Sized + Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}

serde_core/src/std_error.rs

@@ -1,48 +0,0 @@
-use crate::lib::{Debug, Display};
-
-/// Either a re-export of std::error::Error or a new identical trait, depending
-/// on whether Serde's "std" feature is enabled.
-///
-/// Serde's error traits [`serde::ser::Error`] and [`serde::de::Error`] require
-/// [`std::error::Error`] as a supertrait, but only when Serde is built with
-/// "std" enabled. Data formats that don't care about no\_std support should
-/// generally provide their error types with a `std::error::Error` impl
-/// directly:
-///
-/// ```edition2021
-/// #[derive(Debug)]
-/// struct MySerError {...}
-///
-/// impl serde::ser::Error for MySerError {...}
-///
-/// impl std::fmt::Display for MySerError {...}
-///
-/// // We don't support no_std!
-/// impl std::error::Error for MySerError {}
-/// ```
-///
-/// Data formats that *do* support no\_std may either have a "std" feature of
-/// their own:
-///
-/// ```toml
-/// [features]
-/// std = ["serde/std"]
-/// ```
-///
-/// ```edition2021
-/// #[cfg(feature = "std")]
-/// impl std::error::Error for MySerError {}
-/// ```
-///
-/// ... or else provide the std Error impl unconditionally via Serde's
-/// re-export:
-///
-/// ```edition2021
-/// impl serde::ser::StdError for MySerError {}
-/// ```
-pub trait Error: Debug + Display {
-    /// The underlying cause of this error, if any.
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        None
-    }
-}

serde_derive/Cargo.toml

@@ -1,42 +0,0 @@
-[package]
-name = "serde_derive"
-version = "1.0.228"
-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 = "2021"
-exclude = ["build.rs"]
-homepage = "https://serde.rs"
-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.68"
-
-[features]
-default = []
-deserialize_in_place = []
-
-[lib]
-name = "serde_derive"
-proc-macro = true
-
-[dependencies]
-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" }
-
-[package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu"]
-rustdoc-args = [
-    "--generate-link-to-definition",
-    "--generate-macro-expansion",
-    "--extern-html-root-url=core=https://doc.rust-lang.org",
-    "--extern-html-root-url=alloc=https://doc.rust-lang.org",
-    "--extern-html-root-url=std=https://doc.rust-lang.org",
-    "--extern-html-root-url=proc_macro=https://doc.rust-lang.org",
-]

serde_derive/LICENSE-APACHE

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

serde_derive/LICENSE-MIT

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

serde_derive/README.md

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

serde_derive/build.rs

@@ -1,8 +0,0 @@
-fn main() {
-    // Warning: build.rs is not published to crates.io.
-
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rustc-cfg=check_cfg");
-    println!("cargo:rustc-check-cfg=cfg(check_cfg)");
-    println!("cargo:rustc-check-cfg=cfg(exhaustive)");
-}

serde_derive/crates-io.md

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

serde_derive/src/bound.rs

@@ -1,410 +0,0 @@
-use crate::internals::ast::{Container, Data};
-use crate::internals::{attr, ungroup};
-use proc_macro2::Span;
-use std::collections::HashSet;
-use syn::punctuated::{Pair, Punctuated};
-use syn::Token;
-
-// Remove the default from every type parameter because in the generated impls
-// they look like associated types: "error: associated type bindings are not
-// allowed here".
-pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
-    syn::Generics {
-        params: generics
-            .params
-            .iter()
-            .map(|param| match param {
-                syn::GenericParam::Type(param) => syn::GenericParam::Type(syn::TypeParam {
-                    eq_token: None,
-                    default: None,
-                    ..param.clone()
-                }),
-                _ => param.clone(),
-            })
-            .collect(),
-        ..generics.clone()
-    }
-}
-
-pub fn with_where_predicates(
-    generics: &syn::Generics,
-    predicates: &[syn::WherePredicate],
-) -> syn::Generics {
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(predicates.iter().cloned());
-    generics
-}
-
-pub fn with_where_predicates_from_fields(
-    cont: &Container,
-    generics: &syn::Generics,
-    from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
-) -> syn::Generics {
-    let predicates = cont
-        .data
-        .all_fields()
-        .filter_map(|field| from_field(&field.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
-    let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
-    generics
-}
-
-pub fn with_where_predicates_from_variants(
-    cont: &Container,
-    generics: &syn::Generics,
-    from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
-) -> syn::Generics {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return generics.clone();
-        }
-    };
-
-    let predicates = variants
-        .iter()
-        .filter_map(|variant| from_variant(&variant.attrs))
-        .flat_map(<[syn::WherePredicate]>::to_vec);
-
-    let mut generics = generics.clone();
-    generics.make_where_clause().predicates.extend(predicates);
-    generics
-}
-
-// Puts the given bound on any generic type parameters that are used in fields
-// for which filter returns true.
-//
-// For example, the following struct needs the bound `A: Serialize, B:
-// Serialize`.
-//
-//     struct S<'b, A, B: 'b, C> {
-//         a: A,
-//         b: Option<&'b B>
-//         #[serde(skip_serializing)]
-//         c: C,
-//     }
-pub fn with_bound(
-    cont: &Container,
-    generics: &syn::Generics,
-    filter: fn(&attr::Field, Option<&attr::Variant>) -> bool,
-    bound: &syn::Path,
-) -> syn::Generics {
-    struct FindTyParams<'ast> {
-        // Set of all generic type parameters on the current struct (A, B, C in
-        // the example). Initialized up front.
-        all_type_params: HashSet<syn::Ident>,
-
-        // Set of generic type parameters used in fields for which filter
-        // returns true (A and B in the example). Filled in as the visitor sees
-        // them.
-        relevant_type_params: HashSet<syn::Ident>,
-
-        // Fields whose type is an associated type of one of the generic type
-        // parameters.
-        associated_type_usage: Vec<&'ast syn::TypePath>,
-    }
-
-    impl<'ast> FindTyParams<'ast> {
-        fn visit_field(&mut self, field: &'ast syn::Field) {
-            if let syn::Type::Path(ty) = ungroup(&field.ty) {
-                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
-                    if self.all_type_params.contains(&t.ident) {
-                        self.associated_type_usage.push(ty);
-                    }
-                }
-            }
-            self.visit_type(&field.ty);
-        }
-
-        fn visit_path(&mut self, path: &'ast syn::Path) {
-            if let Some(seg) = path.segments.last() {
-                if seg.ident == "PhantomData" {
-                    // Hardcoded exception, because PhantomData<T> implements
-                    // Serialize and Deserialize whether or not T implements it.
-                    return;
-                }
-            }
-            if path.leading_colon.is_none() && path.segments.len() == 1 {
-                let id = &path.segments[0].ident;
-                if self.all_type_params.contains(id) {
-                    self.relevant_type_params.insert(id.clone());
-                }
-            }
-            for segment in &path.segments {
-                self.visit_path_segment(segment);
-            }
-        }
-
-        // Everything below is simply traversing the syntax tree.
-
-        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 {
-                        self.visit_type(&arg.ty);
-                    }
-                    self.visit_return_type(&ty.output);
-                }
-                syn::Type::Group(ty) => self.visit_type(&ty.elem),
-                syn::Type::ImplTrait(ty) => {
-                    for bound in &ty.bounds {
-                        self.visit_type_param_bound(bound);
-                    }
-                }
-                syn::Type::Macro(ty) => self.visit_macro(&ty.mac),
-                syn::Type::Paren(ty) => self.visit_type(&ty.elem),
-                syn::Type::Path(ty) => {
-                    if let Some(qself) = &ty.qself {
-                        self.visit_type(&qself.ty);
-                    }
-                    self.visit_path(&ty.path);
-                }
-                syn::Type::Ptr(ty) => self.visit_type(&ty.elem),
-                syn::Type::Reference(ty) => self.visit_type(&ty.elem),
-                syn::Type::Slice(ty) => self.visit_type(&ty.elem),
-                syn::Type::TraitObject(ty) => {
-                    for bound in &ty.bounds {
-                        self.visit_type_param_bound(bound);
-                    }
-                }
-                syn::Type::Tuple(ty) => {
-                    for elem in &ty.elems {
-                        self.visit_type(elem);
-                    }
-                }
-
-                syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
-
-                _ => {}
-            }
-        }
-
-        fn visit_path_segment(&mut self, segment: &'ast syn::PathSegment) {
-            self.visit_path_arguments(&segment.arguments);
-        }
-
-        fn visit_path_arguments(&mut self, arguments: &'ast syn::PathArguments) {
-            match arguments {
-                syn::PathArguments::None => {}
-                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(_) => {}
-                            _ => {}
-                        }
-                    }
-                }
-                syn::PathArguments::Parenthesized(arguments) => {
-                    for argument in &arguments.inputs {
-                        self.visit_type(argument);
-                    }
-                    self.visit_return_type(&arguments.output);
-                }
-            }
-        }
-
-        fn visit_return_type(&mut self, return_type: &'ast syn::ReturnType) {
-            match return_type {
-                syn::ReturnType::Default => {}
-                syn::ReturnType::Type(_, output) => self.visit_type(output),
-            }
-        }
-
-        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::PreciseCapture(_)
-                | syn::TypeParamBound::Verbatim(_) => {}
-                _ => {}
-            }
-        }
-
-        // Type parameter should not be considered used by a macro path.
-        //
-        //     struct TypeMacro<T> {
-        //         mac: T!(),
-        //         marker: PhantomData<T>,
-        //     }
-        fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
-    }
-
-    let all_type_params = generics
-        .type_params()
-        .map(|param| param.ident.clone())
-        .collect();
-
-    let mut visitor = FindTyParams {
-        all_type_params,
-        relevant_type_params: HashSet::new(),
-        associated_type_usage: Vec::new(),
-    };
-    match &cont.data {
-        Data::Enum(variants) => {
-            for variant in variants {
-                let relevant_fields = variant
-                    .fields
-                    .iter()
-                    .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
-                for field in relevant_fields {
-                    visitor.visit_field(field.original);
-                }
-            }
-        }
-        Data::Struct(_, fields) => {
-            for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
-                visitor.visit_field(field.original);
-            }
-        }
-    }
-
-    let relevant_type_params = visitor.relevant_type_params;
-    let associated_type_usage = visitor.associated_type_usage;
-    let new_predicates = generics
-        .type_params()
-        .map(|param| param.ident.clone())
-        .filter(|id| relevant_type_params.contains(id))
-        .map(|id| syn::TypePath {
-            qself: None,
-            path: id.into(),
-        })
-        .chain(associated_type_usage.into_iter().cloned())
-        .map(|bounded_ty| {
-            syn::WherePredicate::Type(syn::PredicateType {
-                lifetimes: None,
-                // the type parameter that is being bounded e.g. T
-                bounded_ty: syn::Type::Path(bounded_ty),
-                colon_token: <Token![:]>::default(),
-                // the bound e.g. Serialize
-                bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
-                    paren_token: None,
-                    modifier: syn::TraitBoundModifier::None,
-                    lifetimes: None,
-                    path: bound.clone(),
-                })]
-                .into_iter()
-                .collect(),
-            })
-        });
-
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .extend(new_predicates);
-    generics
-}
-
-pub fn with_self_bound(
-    cont: &Container,
-    generics: &syn::Generics,
-    bound: &syn::Path,
-) -> syn::Generics {
-    let mut generics = generics.clone();
-    generics
-        .make_where_clause()
-        .predicates
-        .push(syn::WherePredicate::Type(syn::PredicateType {
-            lifetimes: None,
-            // the type that is being bounded e.g. MyStruct<'a, T>
-            bounded_ty: type_of_item(cont),
-            colon_token: <Token![:]>::default(),
-            // the bound e.g. Default
-            bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
-                paren_token: None,
-                modifier: syn::TraitBoundModifier::None,
-                lifetimes: None,
-                path: bound.clone(),
-            })]
-            .into_iter()
-            .collect(),
-        }));
-    generics
-}
-
-pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
-    let bound = syn::Lifetime::new(lifetime, Span::call_site());
-    let def = syn::LifetimeParam {
-        attrs: Vec::new(),
-        lifetime: bound.clone(),
-        colon_token: None,
-        bounds: Punctuated::new(),
-    };
-
-    let params = Some(syn::GenericParam::Lifetime(def))
-        .into_iter()
-        .chain(generics.params.iter().cloned().map(|mut param| {
-            match &mut param {
-                syn::GenericParam::Lifetime(param) => {
-                    param.bounds.push(bound.clone());
-                }
-                syn::GenericParam::Type(param) => {
-                    param
-                        .bounds
-                        .push(syn::TypeParamBound::Lifetime(bound.clone()));
-                }
-                syn::GenericParam::Const(_) => {}
-            }
-            param
-        }))
-        .collect();
-
-    syn::Generics {
-        params,
-        ..generics.clone()
-    }
-}
-
-fn type_of_item(cont: &Container) -> syn::Type {
-    syn::Type::Path(syn::TypePath {
-        qself: None,
-        path: syn::Path {
-            leading_colon: None,
-            segments: vec![syn::PathSegment {
-                ident: cont.ident.clone(),
-                arguments: syn::PathArguments::AngleBracketed(
-                    syn::AngleBracketedGenericArguments {
-                        colon2_token: None,
-                        lt_token: <Token![<]>::default(),
-                        args: cont
-                            .generics
-                            .params
-                            .iter()
-                            .map(|param| match param {
-                                syn::GenericParam::Type(param) => {
-                                    syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
-                                        qself: None,
-                                        path: param.ident.clone().into(),
-                                    }))
-                                }
-                                syn::GenericParam::Lifetime(param) => {
-                                    syn::GenericArgument::Lifetime(param.lifetime.clone())
-                                }
-                                syn::GenericParam::Const(_) => {
-                                    panic!("Serde does not support const generics yet");
-                                }
-                            })
-                            .collect(),
-                        gt_token: <Token![>]>::default(),
-                    },
-                ),
-            }]
-            .into_iter()
-            .collect(),
-        },
-    })
-}

serde_derive/src/de.rs

@@ -1,976 +0,0 @@
-use crate::deprecated::allow_deprecated;
-use crate::fragment::{Expr, Fragment, Stmts};
-use crate::internals::ast::{Container, Data, Field, Style, Variant};
-use crate::internals::name::Name;
-use crate::internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
-use crate::{bound, dummy, pretend, private, this};
-use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned, ToTokens};
-use std::collections::BTreeSet;
-use std::ptr;
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{parse_quote, Ident, Index, Member};
-
-mod enum_;
-mod enum_adjacently;
-mod enum_externally;
-mod enum_internally;
-mod enum_untagged;
-mod identifier;
-mod struct_;
-mod tuple;
-mod unit;
-
-pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<TokenStream> {
-    replace_receiver(input);
-
-    let ctxt = Ctxt::new();
-    let Some(cont) = Container::from_ast(&ctxt, input, Derive::Deserialize, &private.ident())
-    else {
-        return Err(ctxt.check().unwrap_err());
-    };
-    precondition(&ctxt, &cont);
-    ctxt.check()?;
-
-    let ident = &cont.ident;
-    let params = Parameters::new(&cont);
-    let (de_impl_generics, _, ty_generics, where_clause) = params.generics_with_de_lifetime();
-    let body = Stmts(deserialize_body(&cont, &params));
-    let delife = params.borrowed.de_lifetime();
-    let allow_deprecated = allow_deprecated(input);
-
-    let impl_block = if let Some(remote) = cont.attrs.remote() {
-        let vis = &input.vis;
-        let used = pretend::pretend_used(&cont, params.is_packed);
-        quote! {
-            #[automatically_derived]
-            #allow_deprecated
-            impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> _serde::#private::Result<#remote #ty_generics, __D::Error>
-                where
-                    __D: _serde::Deserializer<#delife>,
-                {
-                    #used
-                    #body
-                }
-            }
-        }
-    } else {
-        let fn_deserialize_in_place = deserialize_in_place_body(&cont, &params);
-
-        quote! {
-            #[automatically_derived]
-            #allow_deprecated
-            impl #de_impl_generics _serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                fn deserialize<__D>(__deserializer: __D) -> _serde::#private::Result<Self, __D::Error>
-                where
-                    __D: _serde::Deserializer<#delife>,
-                {
-                    #body
-                }
-
-                #fn_deserialize_in_place
-            }
-        }
-    };
-
-    Ok(dummy::wrap_in_const(
-        cont.attrs.custom_serde_path(),
-        impl_block,
-    ))
-}
-
-fn precondition(cx: &Ctxt, cont: &Container) {
-    precondition_sized(cx, cont);
-    precondition_no_de_lifetime(cx, cont);
-}
-
-fn precondition_sized(cx: &Ctxt, cont: &Container) {
-    if let Data::Struct(_, fields) = &cont.data {
-        if let Some(last) = fields.last() {
-            if let syn::Type::Slice(_) = ungroup(last.ty) {
-                cx.error_spanned_by(
-                    cont.original,
-                    "cannot deserialize a dynamically sized struct",
-                );
-            }
-        }
-    }
-}
-
-fn precondition_no_de_lifetime(cx: &Ctxt, cont: &Container) {
-    if let BorrowedLifetimes::Borrowed(_) = borrowed_lifetimes(cont) {
-        for param in cont.generics.lifetimes() {
-            if param.lifetime.to_string() == "'de" {
-                cx.error_spanned_by(
-                    &param.lifetime,
-                    "cannot deserialize when there is a lifetime parameter called 'de",
-                );
-                return;
-            }
-        }
-    }
-}
-
-struct Parameters {
-    /// Name of the type the `derive` is on.
-    local: syn::Ident,
-
-    /// Path to the type the impl is for. Either a single `Ident` for local
-    /// types (does not include generic parameters) or `some::remote::Path` for
-    /// remote types.
-    this_type: syn::Path,
-
-    /// Same as `this_type` but using `::<T>` for generic parameters for use in
-    /// expression position.
-    this_value: syn::Path,
-
-    /// Generics including any explicit and inferred bounds for the impl.
-    generics: syn::Generics,
-
-    /// Lifetimes borrowed from the deserializer. These will become bounds on
-    /// the `'de` lifetime of the deserializer.
-    borrowed: BorrowedLifetimes,
-
-    /// At least one field has a serde(getter) attribute, implying that the
-    /// remote type has a private field.
-    has_getter: bool,
-
-    /// Type has a repr(packed) attribute.
-    is_packed: bool,
-}
-
-impl Parameters {
-    fn new(cont: &Container) -> Self {
-        let local = cont.ident.clone();
-        let this_type = this::this_type(cont);
-        let this_value = this::this_value(cont);
-        let borrowed = borrowed_lifetimes(cont);
-        let generics = build_generics(cont, &borrowed);
-        let has_getter = cont.data.has_getter();
-        let is_packed = cont.attrs.is_packed();
-
-        Parameters {
-            local,
-            this_type,
-            this_value,
-            generics,
-            borrowed,
-            has_getter,
-            is_packed,
-        }
-    }
-
-    /// Type name to use in error messages and `&'static str` arguments to
-    /// various Deserializer methods.
-    fn type_name(&self) -> String {
-        self.this_type.segments.last().unwrap().ident.to_string()
-    }
-
-    /// Split the data structure's generics into the pieces to use for its
-    /// `Deserialize` impl, augmented with an additional `'de` lifetime for use
-    /// as the `Deserialize` trait's lifetime.
-    fn generics_with_de_lifetime(
-        &self,
-    ) -> (
-        DeImplGenerics,
-        DeTypeGenerics,
-        syn::TypeGenerics,
-        Option<&syn::WhereClause>,
-    ) {
-        let de_impl_generics = DeImplGenerics(self);
-        let de_ty_generics = DeTypeGenerics(self);
-        let (_, ty_generics, where_clause) = self.generics.split_for_impl();
-        (de_impl_generics, de_ty_generics, ty_generics, where_clause)
-    }
-}
-
-// All the generics in the input, plus a bound `T: Deserialize` for each generic
-// field type that will be deserialized by us, plus a bound `T: Default` for
-// each generic field type that will be set to a default value.
-fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generics {
-    let generics = bound::without_defaults(cont.generics);
-
-    let generics = bound::with_where_predicates_from_fields(cont, &generics, attr::Field::de_bound);
-
-    let generics =
-        bound::with_where_predicates_from_variants(cont, &generics, attr::Variant::de_bound);
-
-    match cont.attrs.de_bound() {
-        Some(predicates) => bound::with_where_predicates(&generics, predicates),
-        None => {
-            let generics = match *cont.attrs.default() {
-                attr::Default::Default => bound::with_self_bound(
-                    cont,
-                    &generics,
-                    &parse_quote!(_serde::#private::Default),
-                ),
-                attr::Default::None | attr::Default::Path(_) => generics,
-            };
-
-            let delife = borrowed.de_lifetime();
-            let generics = bound::with_bound(
-                cont,
-                &generics,
-                needs_deserialize_bound,
-                &parse_quote!(_serde::Deserialize<#delife>),
-            );
-
-            bound::with_bound(
-                cont,
-                &generics,
-                requires_default,
-                &parse_quote!(_serde::#private::Default),
-            )
-        }
-    }
-}
-
-// Fields with a `skip_deserializing` or `deserialize_with` attribute, or which
-// belong to a variant with a `skip_deserializing` or `deserialize_with`
-// attribute, are not deserialized by us so we do not generate a bound. Fields
-// with a `bound` attribute specify their own bound so we do not generate one.
-// All other fields may need a `T: Deserialize` bound where T is the type of the
-// field.
-fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_deserializing()
-        && field.deserialize_with().is_none()
-        && field.de_bound().is_none()
-        && variant.map_or(true, |variant| {
-            !variant.skip_deserializing()
-                && variant.deserialize_with().is_none()
-                && variant.de_bound().is_none()
-        })
-}
-
-// Fields with a `default` attribute (not `default=...`), and fields with a
-// `skip_deserializing` attribute that do not also have `default=...`.
-fn requires_default(field: &attr::Field, _variant: Option<&attr::Variant>) -> bool {
-    if let attr::Default::Default = *field.default() {
-        true
-    } else {
-        false
-    }
-}
-
-enum BorrowedLifetimes {
-    Borrowed(BTreeSet<syn::Lifetime>),
-    Static,
-}
-
-impl BorrowedLifetimes {
-    fn de_lifetime(&self) -> syn::Lifetime {
-        match *self {
-            BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new("'de", Span::call_site()),
-            BorrowedLifetimes::Static => syn::Lifetime::new("'static", Span::call_site()),
-        }
-    }
-
-    fn de_lifetime_param(&self) -> Option<syn::LifetimeParam> {
-        match self {
-            BorrowedLifetimes::Borrowed(bounds) => Some(syn::LifetimeParam {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new("'de", Span::call_site()),
-                colon_token: None,
-                bounds: bounds.iter().cloned().collect(),
-            }),
-            BorrowedLifetimes::Static => None,
-        }
-    }
-}
-
-// The union of lifetimes borrowed by each field of the container.
-//
-// These turn into bounds on the `'de` lifetime of the Deserialize impl. If
-// lifetimes `'a` and `'b` are borrowed but `'c` is not, the impl is:
-//
-//     impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for S<'a, 'b, 'c>
-//
-// If any borrowed lifetime is `'static`, then `'de: 'static` would be redundant
-// and we use plain `'static` instead of `'de`.
-fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
-    let mut lifetimes = BTreeSet::new();
-    for field in cont.data.all_fields() {
-        if !field.attrs.skip_deserializing() {
-            lifetimes.extend(field.attrs.borrowed_lifetimes().iter().cloned());
-        }
-    }
-    if lifetimes.iter().any(|b| b.to_string() == "'static") {
-        BorrowedLifetimes::Static
-    } else {
-        BorrowedLifetimes::Borrowed(lifetimes)
-    }
-}
-
-fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
-    if cont.attrs.transparent() {
-        deserialize_transparent(cont, params)
-    } else if let Some(type_from) = cont.attrs.type_from() {
-        deserialize_from(type_from)
-    } else if let Some(type_try_from) = cont.attrs.type_try_from() {
-        deserialize_try_from(type_try_from)
-    } else if let attr::Identifier::No = cont.attrs.identifier() {
-        match &cont.data {
-            Data::Enum(variants) => enum_::deserialize(params, variants, &cont.attrs),
-            Data::Struct(Style::Struct, fields) => {
-                struct_::deserialize(params, fields, &cont.attrs, StructForm::Struct)
-            }
-            Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-                tuple::deserialize(params, fields, &cont.attrs, TupleForm::Tuple)
-            }
-            Data::Struct(Style::Unit, _) => unit::deserialize(params, &cont.attrs),
-        }
-    } else {
-        match &cont.data {
-            Data::Enum(variants) => identifier::deserialize_custom(params, variants, &cont.attrs),
-            Data::Struct(_, _) => unreachable!("checked in serde_derive_internals"),
-        }
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<Stmts> {
-    // Only remote derives have getters, and we do not generate
-    // deserialize_in_place for remote derives.
-    assert!(!params.has_getter);
-
-    if cont.attrs.transparent()
-        || cont.attrs.type_from().is_some()
-        || cont.attrs.type_try_from().is_some()
-        || cont.attrs.identifier().is_some()
-        || cont
-            .data
-            .all_fields()
-            .all(|f| f.attrs.deserialize_with().is_some())
-    {
-        return None;
-    }
-
-    let code = match &cont.data {
-        Data::Struct(Style::Struct, fields) => {
-            struct_::deserialize_in_place(params, fields, &cont.attrs)?
-        }
-        Data::Struct(Style::Tuple, fields) | Data::Struct(Style::Newtype, fields) => {
-            tuple::deserialize_in_place(params, fields, &cont.attrs)
-        }
-        Data::Enum(_) | Data::Struct(Style::Unit, _) => {
-            return None;
-        }
-    };
-
-    let delife = params.borrowed.de_lifetime();
-    let stmts = Stmts(code);
-
-    let fn_deserialize_in_place = quote_block! {
-        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::#private::Result<(), __D::Error>
-        where
-            __D: _serde::Deserializer<#delife>,
-        {
-            #stmts
-        }
-    };
-
-    Some(Stmts(fn_deserialize_in_place))
-}
-
-#[cfg(not(feature = "deserialize_in_place"))]
-fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<Stmts> {
-    None
-}
-
-/// Generates `Deserialize::deserialize` body for a type with `#[serde(transparent)]` attribute
-fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
-    let fields = match &cont.data {
-        Data::Struct(_, fields) => fields,
-        Data::Enum(_) => unreachable!(),
-    };
-
-    let this_value = &params.this_value;
-    let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
-
-    let path = match transparent_field.attrs.deserialize_with() {
-        Some(path) => quote!(#path),
-        None => {
-            let span = transparent_field.original.span();
-            quote_spanned!(span=> _serde::Deserialize::deserialize)
-        }
-    };
-
-    let assign = fields.iter().map(|field| {
-        let member = &field.member;
-        if ptr::eq(field, transparent_field) {
-            quote!(#member: __transparent)
-        } else {
-            let value = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::#private::Default::default()),
-                // If #path returns wrong type, error will be reported here (^^^^^).
-                // We attach span of the path to the function so it will be reported
-                // on the #[serde(default = "...")]
-                //                          ^^^^^
-                attr::Default::Path(path) => quote_spanned!(path.span()=> #path()),
-                attr::Default::None => quote!(_serde::#private::PhantomData),
-            };
-            quote!(#member: #value)
-        }
-    });
-
-    quote_block! {
-        _serde::#private::Result::map(
-            #path(__deserializer),
-            |__transparent| #this_value { #(#assign),* })
-    }
-}
-
-/// Generates `Deserialize::deserialize` body for a type with `#[serde(from)]` attribute
-fn deserialize_from(type_from: &syn::Type) -> Fragment {
-    quote_block! {
-        _serde::#private::Result::map(
-            <#type_from as _serde::Deserialize>::deserialize(__deserializer),
-            _serde::#private::From::from)
-    }
-}
-
-/// Generates `Deserialize::deserialize` body for a type with `#[serde(try_from)]` attribute
-fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
-    quote_block! {
-        _serde::#private::Result::and_then(
-            <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
-            |v| _serde::#private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
-    }
-}
-
-enum TupleForm<'a> {
-    Tuple,
-    /// Contains a variant name
-    ExternallyTagged(&'a syn::Ident),
-    /// Contains a variant name
-    Untagged(&'a syn::Ident),
-}
-
-fn deserialize_seq(
-    type_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    is_struct: bool,
-    cattrs: &attr::Container,
-    expecting: &str,
-) -> Fragment {
-    let vars = (0..fields.len()).map(field_i as fn(_) -> _);
-
-    let deserialized_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-    let expecting = if deserialized_count == 1 {
-        format!("{} with 1 element", expecting)
-    } else {
-        format!("{} with {} elements", expecting, deserialized_count)
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let mut index_in_seq = 0_usize;
-    let let_values = vars.clone().zip(fields).map(|(var, field)| {
-        if field.attrs.skip_deserializing() {
-            let default = Expr(expr_is_missing(field, cattrs));
-            quote! {
-                let #var = #default;
-            }
-        } else {
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    let field_ty = field.ty;
-                    let span = field.original.span();
-                    let func =
-                        quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
-                    quote!(#func(&mut __seq)?)
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        _serde::#private::Option::map(
-                            _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)?,
-                            |__wrap| __wrap.value)
-                    })
-                }
-            };
-            let value_if_none = expr_is_missing_seq(None, index_in_seq, field, cattrs, expecting);
-            let assign = quote! {
-                let #var = match #visit {
-                    _serde::#private::Some(__value) => __value,
-                    _serde::#private::None => #value_if_none,
-                };
-            };
-            index_in_seq += 1;
-            assign
-        }
-    });
-
-    let mut result = if is_struct {
-        let names = fields.iter().map(|f| &f.member);
-        quote! {
-            #type_path { #( #names: #vars ),* }
-        }
-    } else {
-        quote! {
-            #type_path ( #(#vars),* )
-        }
-    };
-
-    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
-        result = quote! {
-            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
-        };
-    }
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::#private::Default::default();
-        )),
-        // If #path returns wrong type, error will be reported here (^^^^^).
-        // We attach span of the path to the function so it will be reported
-        // on the #[serde(default = "...")]
-        //                          ^^^^^
-        attr::Default::Path(path) => Some(quote_spanned!(path.span()=>
-            let __default: Self::Value = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #let_default
-        #(#let_values)*
-        _serde::#private::Ok(#result)
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_seq_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    expecting: &str,
-) -> Fragment {
-    let deserialized_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-    let expecting = if deserialized_count == 1 {
-        format!("{} with 1 element", expecting)
-    } else {
-        format!("{} with {} elements", expecting, deserialized_count)
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let mut index_in_seq = 0usize;
-    let write_values = fields.iter().map(|field| {
-        let member = &field.member;
-
-        if field.attrs.skip_deserializing() {
-            let default = Expr(expr_is_missing(field, cattrs));
-            quote! {
-                self.place.#member = #default;
-            }
-        } else {
-            let value_if_none = expr_is_missing_seq(Some(quote!(self.place.#member = )), index_in_seq, field, cattrs, expecting);
-            let write = match field.attrs.deserialize_with() {
-                None => {
-                    quote! {
-                        if let _serde::#private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq,
-                            _serde::#private::de::InPlaceSeed(&mut self.place.#member))?
-                        {
-                            #value_if_none;
-                        }
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq) {
-                            _serde::#private::Ok(_serde::#private::Some(__wrap)) => {
-                                self.place.#member = __wrap.value;
-                            }
-                            _serde::#private::Ok(_serde::#private::None) => {
-                                #value_if_none;
-                            }
-                            _serde::#private::Err(__err) => {
-                                return _serde::#private::Err(__err);
-                            }
-                        }
-                    })
-                }
-            };
-            index_in_seq += 1;
-            write
-        }
-    });
-
-    let this_type = &params.this_type;
-    let (_, ty_generics, _) = params.generics.split_for_impl();
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: #this_type #ty_generics = _serde::#private::Default::default();
-        )),
-        // If #path returns wrong type, error will be reported here (^^^^^).
-        // We attach span of the path to the function so it will be reported
-        // on the #[serde(default = "...")]
-        //                          ^^^^^
-        attr::Default::Path(path) => Some(quote_spanned!(path.span()=>
-            let __default: #this_type #ty_generics = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #let_default
-        #(#write_values)*
-        _serde::#private::Ok(())
-    }
-}
-
-enum StructForm<'a> {
-    Struct,
-    /// Contains a variant name
-    ExternallyTagged(&'a syn::Ident),
-    /// Contains a variant name
-    InternallyTagged(&'a syn::Ident),
-    /// Contains a variant name
-    Untagged(&'a syn::Ident),
-}
-
-struct FieldWithAliases<'a> {
-    ident: Ident,
-    aliases: &'a BTreeSet<Name>,
-}
-
-fn field_i(i: usize) -> Ident {
-    Ident::new(&format!("__field{}", i), Span::call_site())
-}
-
-/// This function wraps the expression in `#[serde(deserialize_with = "...")]`
-/// in a trait to prevent it from accessing the internal `Deserialize` state.
-fn wrap_deserialize_with(
-    params: &Parameters,
-    value_ty: &TokenStream,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream) {
-    let this_type = &params.this_type;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-    let deserializer_var = quote!(__deserializer);
-
-    // If #deserialize_with returns wrong type, error will be reported here (^^^^^).
-    // We attach span of the path to the function so it will be reported
-    // on the #[serde(with = "...")]
-    //                       ^^^^^
-    let value = quote_spanned! {deserialize_with.span()=>
-        #deserialize_with(#deserializer_var)?
-    };
-    let wrapper = quote! {
-        #[doc(hidden)]
-        struct __DeserializeWith #de_impl_generics #where_clause {
-            value: #value_ty,
-            phantom: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
-            fn deserialize<__D>(#deserializer_var: __D) -> _serde::#private::Result<Self, __D::Error>
-            where
-                __D: _serde::Deserializer<#delife>,
-            {
-                _serde::#private::Ok(__DeserializeWith {
-                    value: #value,
-                    phantom: _serde::#private::PhantomData,
-                    lifetime: _serde::#private::PhantomData,
-                })
-            }
-        }
-    };
-
-    let wrapper_ty = quote!(__DeserializeWith #de_ty_generics);
-
-    (wrapper, wrapper_ty)
-}
-
-fn wrap_deserialize_field_with(
-    params: &Parameters,
-    field_ty: &syn::Type,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream) {
-    wrap_deserialize_with(params, &quote!(#field_ty), deserialize_with)
-}
-
-// Generates closure that converts single input parameter to the final value.
-fn unwrap_to_variant_closure(
-    params: &Parameters,
-    variant: &Variant,
-    with_wrapper: bool,
-) -> TokenStream {
-    let this_value = &params.this_value;
-    let variant_ident = &variant.ident;
-
-    let (arg, wrapper) = if with_wrapper {
-        (quote! { __wrap }, quote! { __wrap.value })
-    } else {
-        let field_tys = variant.fields.iter().map(|field| field.ty);
-        (quote! { __wrap: (#(#field_tys),*) }, quote! { __wrap })
-    };
-
-    let field_access = (0..variant.fields.len()).map(|n| {
-        Member::Unnamed(Index {
-            index: n as u32,
-            span: Span::call_site(),
-        })
-    });
-
-    match variant.style {
-        Style::Struct if variant.fields.len() == 1 => {
-            let member = &variant.fields[0].member;
-            quote! {
-                |#arg| #this_value::#variant_ident { #member: #wrapper }
-            }
-        }
-        Style::Struct => {
-            let members = variant.fields.iter().map(|field| &field.member);
-            quote! {
-                |#arg| #this_value::#variant_ident { #(#members: #wrapper.#field_access),* }
-            }
-        }
-        Style::Tuple => quote! {
-            |#arg| #this_value::#variant_ident(#(#wrapper.#field_access),*)
-        },
-        Style::Newtype => quote! {
-            |#arg| #this_value::#variant_ident(#wrapper)
-        },
-        Style::Unit => quote! {
-            |#arg| #this_value::#variant_ident
-        },
-    }
-}
-
-fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
-    match field.attrs.default() {
-        attr::Default::Default => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::#private::Default::default);
-            return quote_expr!(#func());
-        }
-        attr::Default::Path(path) => {
-            // If #path returns wrong type, error will be reported here (^^^^^).
-            // We attach span of the path to the function so it will be reported
-            // on the #[serde(default = "...")]
-            //                          ^^^^^
-            return Fragment::Expr(quote_spanned!(path.span()=> #path()));
-        }
-        attr::Default::None => { /* below */ }
-    }
-
-    match *cattrs.default() {
-        attr::Default::Default | attr::Default::Path(_) => {
-            let member = &field.member;
-            return quote_expr!(__default.#member);
-        }
-        attr::Default::None => { /* below */ }
-    }
-
-    let name = field.attrs.name().deserialize_name();
-    match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::#private::de::missing_field);
-            quote_expr! {
-                #func(#name)?
-            }
-        }
-        Some(_) => {
-            quote_expr! {
-                return _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
-            }
-        }
-    }
-}
-
-fn expr_is_missing_seq(
-    assign_to: Option<TokenStream>,
-    index: usize,
-    field: &Field,
-    cattrs: &attr::Container,
-    expecting: &str,
-) -> TokenStream {
-    match field.attrs.default() {
-        attr::Default::Default => {
-            let span = field.original.span();
-            return quote_spanned!(span=> #assign_to _serde::#private::Default::default());
-        }
-        attr::Default::Path(path) => {
-            // If #path returns wrong type, error will be reported here (^^^^^).
-            // We attach span of the path to the function so it will be reported
-            // on the #[serde(default = "...")]
-            //                          ^^^^^
-            return quote_spanned!(path.span()=> #assign_to #path());
-        }
-        attr::Default::None => { /* below */ }
-    }
-
-    match *cattrs.default() {
-        attr::Default::Default | attr::Default::Path(_) => {
-            let member = &field.member;
-            quote!(#assign_to __default.#member)
-        }
-        attr::Default::None => quote!(
-            return _serde::#private::Err(_serde::de::Error::invalid_length(#index, &#expecting))
-        ),
-    }
-}
-
-fn effective_style(variant: &Variant) -> Style {
-    match variant.style {
-        Style::Newtype if variant.fields[0].attrs.skip_deserializing() => Style::Unit,
-        other => other,
-    }
-}
-
-/// True if there is any field with a `#[serde(flatten)]` attribute, other than
-/// fields which are skipped.
-fn has_flatten(fields: &[Field]) -> bool {
-    fields
-        .iter()
-        .any(|field| field.attrs.flatten() && !field.attrs.skip_deserializing())
-}
-
-struct DeImplGenerics<'a>(&'a Parameters);
-#[cfg(feature = "deserialize_in_place")]
-struct InPlaceImplGenerics<'a>(&'a Parameters);
-
-impl<'a> ToTokens for DeImplGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
-            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (impl_generics, _, _) = generics.split_for_impl();
-        impl_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> ToTokens for InPlaceImplGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let place_lifetime = place_lifetime();
-        let mut generics = self.0.generics.clone();
-
-        // Add lifetime for `&'place mut Self, and `'a: 'place`
-        for param in &mut generics.params {
-            match param {
-                syn::GenericParam::Lifetime(param) => {
-                    param.bounds.push(place_lifetime.lifetime.clone());
-                }
-                syn::GenericParam::Type(param) => {
-                    param.bounds.push(syn::TypeParamBound::Lifetime(
-                        place_lifetime.lifetime.clone(),
-                    ));
-                }
-                syn::GenericParam::Const(_) => {}
-            }
-        }
-        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime))
-            .into_iter()
-            .chain(generics.params)
-            .collect();
-        if let Some(de_lifetime) = self.0.borrowed.de_lifetime_param() {
-            generics.params = Some(syn::GenericParam::Lifetime(de_lifetime))
-                .into_iter()
-                .chain(generics.params)
-                .collect();
-        }
-        let (impl_generics, _, _) = generics.split_for_impl();
-        impl_generics.to_tokens(tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> DeImplGenerics<'a> {
-    fn in_place(self) -> InPlaceImplGenerics<'a> {
-        InPlaceImplGenerics(self.0)
-    }
-}
-
-struct DeTypeGenerics<'a>(&'a Parameters);
-#[cfg(feature = "deserialize_in_place")]
-struct InPlaceTypeGenerics<'a>(&'a Parameters);
-
-fn de_type_generics_to_tokens(
-    mut generics: syn::Generics,
-    borrowed: &BorrowedLifetimes,
-    tokens: &mut TokenStream,
-) {
-    if borrowed.de_lifetime_param().is_some() {
-        let def = syn::LifetimeParam {
-            attrs: Vec::new(),
-            lifetime: syn::Lifetime::new("'de", Span::call_site()),
-            colon_token: None,
-            bounds: Punctuated::new(),
-        };
-        // Prepend 'de lifetime to list of generics
-        generics.params = Some(syn::GenericParam::Lifetime(def))
-            .into_iter()
-            .chain(generics.params)
-            .collect();
-    }
-    let (_, ty_generics, _) = generics.split_for_impl();
-    ty_generics.to_tokens(tokens);
-}
-
-impl<'a> ToTokens for DeTypeGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        de_type_generics_to_tokens(self.0.generics.clone(), &self.0.borrowed, tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut generics = self.0.generics.clone();
-        generics.params = Some(syn::GenericParam::Lifetime(place_lifetime()))
-            .into_iter()
-            .chain(generics.params)
-            .collect();
-
-        de_type_generics_to_tokens(generics, &self.0.borrowed, tokens);
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-impl<'a> DeTypeGenerics<'a> {
-    fn in_place(self) -> InPlaceTypeGenerics<'a> {
-        InPlaceTypeGenerics(self.0)
-    }
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn place_lifetime() -> syn::LifetimeParam {
-    syn::LifetimeParam {
-        attrs: Vec::new(),
-        lifetime: syn::Lifetime::new("'place", Span::call_site()),
-        colon_token: None,
-        bounds: Punctuated::new(),
-    }
-}

serde_derive/src/de/enum_.rs

@@ -1,96 +0,0 @@
-use crate::de::enum_adjacently;
-use crate::de::enum_externally;
-use crate::de::enum_internally;
-use crate::de::enum_untagged;
-use crate::de::identifier;
-use crate::de::{field_i, FieldWithAliases, Parameters};
-use crate::fragment::{Expr, Fragment, Stmts};
-use crate::internals::ast::Variant;
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::quote;
-
-/// Generates `Deserialize::deserialize` body for an `enum Enum {...}`
-pub(super) fn deserialize(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    // The variants have already been checked (in ast.rs) that all untagged variants appear at the end
-    match variants.iter().position(|var| var.attrs.untagged()) {
-        Some(variant_idx) => {
-            let (tagged, untagged) = variants.split_at(variant_idx);
-            let tagged_frag = Expr(deserialize_homogeneous_enum(params, tagged, cattrs));
-            // 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 = quote! {
-                if let _serde::#private::Result::<_, __D::Error>::Ok(__ok) = (|| #tagged_frag)() {
-                    return _serde::#private::Ok(__ok);
-                }
-            };
-            enum_untagged::deserialize(params, untagged, cattrs, Some(first_attempt))
-        }
-        None => deserialize_homogeneous_enum(params, variants, cattrs),
-    }
-}
-
-fn deserialize_homogeneous_enum(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    match cattrs.tag() {
-        attr::TagType::External => enum_externally::deserialize(params, variants, cattrs),
-        attr::TagType::Internal { tag } => {
-            enum_internally::deserialize(params, variants, cattrs, tag)
-        }
-        attr::TagType::Adjacent { tag, content } => {
-            enum_adjacently::deserialize(params, variants, cattrs, tag, content)
-        }
-        attr::TagType::None => enum_untagged::deserialize(params, variants, cattrs, None),
-    }
-}
-
-pub fn prepare_enum_variant_enum(variants: &[Variant]) -> (TokenStream, Stmts) {
-    let deserialized_variants = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_i, variant)| !variant.attrs.skip_deserializing());
-
-    let fallthrough = deserialized_variants
-        .clone()
-        .find(|(_i, variant)| variant.attrs.other())
-        .map(|(i, _variant)| {
-            let ignore_variant = field_i(i);
-            quote!(_serde::#private::Ok(__Field::#ignore_variant))
-        });
-
-    let variants_stmt = {
-        let variant_names = deserialized_variants
-            .clone()
-            .flat_map(|(_i, variant)| variant.attrs.aliases());
-        quote! {
-            #[doc(hidden)]
-            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
-        }
-    };
-
-    let deserialized_variants: Vec<_> = deserialized_variants
-        .map(|(i, variant)| FieldWithAliases {
-            ident: field_i(i),
-            aliases: variant.attrs.aliases(),
-        })
-        .collect();
-
-    let variant_visitor = Stmts(identifier::deserialize_generated(
-        &deserialized_variants,
-        false, // variant identifiers do not depend on the presence of flatten fields
-        true,
-        None,
-        fallthrough,
-    ));
-
-    (variants_stmt, variant_visitor)
-}

serde_derive/src/de/enum_adjacently.rs

@@ -1,325 +0,0 @@
-//! Deserialization for adjacently tagged enums:
-//!
-//! ```ignore
-//! #[serde(tag = "...", content = "...")]
-//! enum Enum {}
-//! ```
-
-use crate::de::enum_;
-use crate::de::enum_untagged;
-use crate::de::{field_i, Parameters};
-use crate::fragment::{Fragment, Match};
-use crate::internals::ast::{Style, Variant};
-use crate::internals::attr;
-use crate::private;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
-
-/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag, content)]` attributes
-pub(super) fn deserialize(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-    tag: &str,
-    content: &str,
-) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    let (variants_stmt, variant_visitor) = enum_::prepare_enum_variant_enum(variants);
-
-    let variant_arms: &Vec<_> = &variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_index = field_i(i);
-
-            let block = Match(enum_untagged::deserialize_variant(params, variant, cattrs));
-
-            quote! {
-                __Field::#variant_index => #block
-            }
-        })
-        .collect();
-
-    let rust_name = params.type_name();
-    let expecting = format!("adjacently tagged enum {}", rust_name);
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-    let type_name = cattrs.name().deserialize_name();
-    let deny_unknown_fields = cattrs.deny_unknown_fields();
-
-    // If unknown fields are allowed, we pick the visitor that can step over
-    // those. Otherwise we pick the visitor that fails on unknown keys.
-    let field_visitor_ty = if deny_unknown_fields {
-        quote! { _serde::#private::de::TagOrContentFieldVisitor }
-    } else {
-        quote! { _serde::#private::de::TagContentOtherFieldVisitor }
-    };
-
-    let mut missing_content = quote! {
-        _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
-    };
-    let mut missing_content_fallthrough = quote!();
-    let missing_content_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .filter_map(|(i, variant)| {
-            let variant_index = field_i(i);
-            let variant_ident = &variant.ident;
-
-            let arm = match variant.style {
-                Style::Unit => quote! {
-                    _serde::#private::Ok(#this_value::#variant_ident)
-                },
-                Style::Newtype if variant.attrs.deserialize_with().is_none() => {
-                    let span = variant.original.span();
-                    let func = quote_spanned!(span=> _serde::#private::de::missing_field);
-                    quote! {
-                        #func(#content).map(#this_value::#variant_ident)
-                    }
-                }
-                _ => {
-                    missing_content_fallthrough = quote!(_ => #missing_content);
-                    return None;
-                }
-            };
-            Some(quote! {
-                __Field::#variant_index => #arm,
-            })
-        })
-        .collect::<Vec<_>>();
-    if !missing_content_arms.is_empty() {
-        missing_content = quote! {
-            match __field {
-                #(#missing_content_arms)*
-                #missing_content_fallthrough
-            }
-        };
-    }
-
-    // Advance the map by one key, returning early in case of error.
-    let next_key = quote! {
-        _serde::de::MapAccess::next_key_seed(&mut __map, #field_visitor_ty {
-            tag: #tag,
-            content: #content,
-        })?
-    };
-
-    let variant_from_map = quote! {
-        _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::AdjacentlyTaggedEnumVariantSeed::<__Field> {
-            enum_name: #rust_name,
-            variants: VARIANTS,
-            fields_enum: _serde::#private::PhantomData
-        })?
-    };
-
-    // When allowing unknown fields, we want to transparently step through keys
-    // we don't care about until we find `tag`, `content`, or run out of keys.
-    let next_relevant_key = if deny_unknown_fields {
-        next_key
-    } else {
-        quote!({
-            let mut __rk : _serde::#private::Option<_serde::#private::de::TagOrContentField> = _serde::#private::None;
-            while let _serde::#private::Some(__k) = #next_key {
-                match __k {
-                    _serde::#private::de::TagContentOtherField::Other => {
-                        let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
-                        continue;
-                    },
-                    _serde::#private::de::TagContentOtherField::Tag => {
-                        __rk = _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag);
-                        break;
-                    }
-                    _serde::#private::de::TagContentOtherField::Content => {
-                        __rk = _serde::#private::Some(_serde::#private::de::TagOrContentField::Content);
-                        break;
-                    }
-                }
-            }
-
-            __rk
-        })
-    };
-
-    // Step through remaining keys, looking for duplicates of previously-seen
-    // keys. When unknown fields are denied, any key that isn't a duplicate will
-    // at this point immediately produce an error.
-    let visit_remaining_keys = quote! {
-        match #next_relevant_key {
-            _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag) => {
-                _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
-            }
-            _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
-                _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
-            }
-            _serde::#private::None => _serde::#private::Ok(__ret),
-        }
-    };
-
-    let finish_content_then_tag = if variant_arms.is_empty() {
-        quote! {
-            match #variant_from_map {}
-        }
-    } else {
-        quote! {
-            let __seed = __Seed {
-                variant: #variant_from_map,
-                marker: _serde::#private::PhantomData,
-                lifetime: _serde::#private::PhantomData,
-            };
-            let __deserializer = _serde::#private::de::ContentDeserializer::<__A::Error>::new(__content);
-            let __ret = _serde::de::DeserializeSeed::deserialize(__seed, __deserializer)?;
-            // Visit remaining keys, looking for duplicates.
-            #visit_remaining_keys
-        }
-    };
-
-    quote_block! {
-        #variant_visitor
-
-        #variants_stmt
-
-        #[doc(hidden)]
-        struct __Seed #de_impl_generics #where_clause {
-            variant: __Field,
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn deserialize<__D>(self, __deserializer: __D) -> _serde::#private::Result<Self::Value, __D::Error>
-            where
-                __D: _serde::Deserializer<#delife>,
-            {
-                match self.variant {
-                    #(#variant_arms)*
-                }
-            }
-        }
-
-        #[doc(hidden)]
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                // Visit the first relevant key.
-                match #next_relevant_key {
-                    // First key is the tag.
-                    _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag) => {
-                        // Parse the tag.
-                        let __field = #variant_from_map;
-                        // Visit the second key.
-                        match #next_relevant_key {
-                            // Second key is a duplicate of the tag.
-                            _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag) => {
-                                _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
-                            }
-                            // Second key is the content.
-                            _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
-                                let __ret = _serde::de::MapAccess::next_value_seed(&mut __map,
-                                    __Seed {
-                                        variant: __field,
-                                        marker: _serde::#private::PhantomData,
-                                        lifetime: _serde::#private::PhantomData,
-                                    })?;
-                                // Visit remaining keys, looking for duplicates.
-                                #visit_remaining_keys
-                            }
-                            // There is no second key; might be okay if the we have a unit variant.
-                            _serde::#private::None => #missing_content
-                        }
-                    }
-                    // First key is the content.
-                    _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
-                        // Buffer up the content.
-                        let __content = _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::ContentVisitor::new())?;
-                        // Visit the second key.
-                        match #next_relevant_key {
-                            // Second key is the tag.
-                            _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag) => {
-                                #finish_content_then_tag
-                            }
-                            // Second key is a duplicate of the content.
-                            _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
-                                _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
-                            }
-                            // There is no second key.
-                            _serde::#private::None => {
-                                _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
-                            }
-                        }
-                    }
-                    // There is no first key.
-                    _serde::#private::None => {
-                        _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
-                    }
-                }
-            }
-
-            fn visit_seq<__A>(self, mut __seq: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                // Visit the first element - the tag.
-                match _serde::de::SeqAccess::next_element(&mut __seq) {
-                    _serde::#private::Ok(_serde::#private::Some(__variant)) => {
-                        // Visit the second element - the content.
-                        match _serde::de::SeqAccess::next_element_seed(
-                            &mut __seq,
-                            __Seed {
-                                variant: __variant,
-                                marker: _serde::#private::PhantomData,
-                                lifetime: _serde::#private::PhantomData,
-                            },
-                        ) {
-                            _serde::#private::Ok(_serde::#private::Some(__ret)) => _serde::#private::Ok(__ret),
-                            // There is no second element.
-                            _serde::#private::Ok(_serde::#private::None) => {
-                                _serde::#private::Err(_serde::de::Error::invalid_length(1, &self))
-                            }
-                            _serde::#private::Err(__err) => _serde::#private::Err(__err),
-                        }
-                    }
-                    // There is no first element.
-                    _serde::#private::Ok(_serde::#private::None) => {
-                        _serde::#private::Err(_serde::de::Error::invalid_length(0, &self))
-                    }
-                    _serde::#private::Err(__err) => _serde::#private::Err(__err),
-                }
-            }
-        }
-
-        #[doc(hidden)]
-        const FIELDS: &'static [&'static str] = &[#tag, #content];
-        _serde::Deserializer::deserialize_struct(
-            __deserializer,
-            #type_name,
-            FIELDS,
-            __Visitor {
-                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::#private::PhantomData,
-            },
-        )
-    }
-}

serde_derive/src/de/enum_externally.rs

@@ -1,213 +0,0 @@
-//! Deserialization for externally tagged enums:
-//!
-//! ```ignore
-//! enum Enum {}
-//! ```
-
-use crate::de::enum_;
-use crate::de::struct_;
-use crate::de::tuple;
-use crate::de::{
-    expr_is_missing, field_i, unwrap_to_variant_closure, wrap_deserialize_field_with,
-    wrap_deserialize_with, Parameters, StructForm, TupleForm,
-};
-use crate::fragment::{Expr, Fragment, Match};
-use crate::internals::ast::{Field, Style, Variant};
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
-
-/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` without additional attributes
-pub(super) fn deserialize(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let this_type = &params.this_type;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    let type_name = cattrs.name().deserialize_name();
-    let expecting = format!("enum {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let (variants_stmt, variant_visitor) = enum_::prepare_enum_variant_enum(variants);
-
-    // Match arms to extract a variant from a string
-    let variant_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_name = field_i(i);
-
-            let block = Match(deserialize_externally_tagged_variant(
-                params, variant, cattrs,
-            ));
-
-            quote! {
-                _serde::#private::Ok((__Field::#variant_name, __variant)) => #block
-            }
-        });
-
-    let all_skipped = variants
-        .iter()
-        .all(|variant| variant.attrs.skip_deserializing());
-    let match_variant = if all_skipped {
-        // This is an empty enum like `enum Impossible {}` or an enum in which
-        // all variants have `#[serde(skip_deserializing)]`.
-        quote! {
-            // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::#private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
-            // _serde::#private::Err(__err)
-            _serde::#private::Result::map(
-                _serde::de::EnumAccess::variant::<__Field>(__data),
-                |(__impossible, _)| match __impossible {})
-        }
-    } else {
-        quote! {
-            match _serde::de::EnumAccess::variant(__data) {
-                #(#variant_arms)*
-                _serde::#private::Err(__err) => _serde::#private::Err(__err),
-            }
-        }
-    };
-
-    quote_block! {
-        #variant_visitor
-
-        #[doc(hidden)]
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            fn visit_enum<__A>(self, __data: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::EnumAccess<#delife>,
-            {
-                #match_variant
-            }
-        }
-
-        #variants_stmt
-
-        _serde::Deserializer::deserialize_enum(
-            __deserializer,
-            #type_name,
-            VARIANTS,
-            __Visitor {
-                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::#private::PhantomData,
-            },
-        )
-    }
-}
-
-fn deserialize_externally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-) -> Fragment {
-    if let Some(path) = variant.attrs.deserialize_with() {
-        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
-        return quote_block! {
-            #wrapper
-            _serde::#private::Result::map(
-                _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
-        };
-    }
-
-    let variant_ident = &variant.ident;
-
-    match variant.style {
-        Style::Unit => {
-            let this_value = &params.this_value;
-            quote_block! {
-                _serde::de::VariantAccess::unit_variant(__variant)?;
-                _serde::#private::Ok(#this_value::#variant_ident)
-            }
-        }
-        Style::Newtype => deserialize_externally_tagged_newtype_variant(
-            variant_ident,
-            params,
-            &variant.fields[0],
-            cattrs,
-        ),
-        Style::Tuple => tuple::deserialize(
-            params,
-            &variant.fields,
-            cattrs,
-            TupleForm::ExternallyTagged(variant_ident),
-        ),
-        Style::Struct => struct_::deserialize(
-            params,
-            &variant.fields,
-            cattrs,
-            StructForm::ExternallyTagged(variant_ident),
-        ),
-    }
-}
-
-fn wrap_deserialize_variant_with(
-    params: &Parameters,
-    variant: &Variant,
-    deserialize_with: &syn::ExprPath,
-) -> (TokenStream, TokenStream, TokenStream) {
-    let field_tys = variant.fields.iter().map(|field| field.ty);
-    let (wrapper, wrapper_ty) =
-        wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
-
-    let unwrap_fn = unwrap_to_variant_closure(params, variant, true);
-
-    (wrapper, wrapper_ty, unwrap_fn)
-}
-
-fn deserialize_externally_tagged_newtype_variant(
-    variant_ident: &syn::Ident,
-    params: &Parameters,
-    field: &Field,
-    cattrs: &attr::Container,
-) -> Fragment {
-    let this_value = &params.this_value;
-
-    if field.attrs.skip_deserializing() {
-        let default = Expr(expr_is_missing(field, cattrs));
-        return quote_block! {
-            _serde::de::VariantAccess::unit_variant(__variant)?;
-            _serde::#private::Ok(#this_value::#variant_ident(#default))
-        };
-    }
-
-    match field.attrs.deserialize_with() {
-        None => {
-            let field_ty = field.ty;
-            let span = field.original.span();
-            let func =
-                quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
-            quote_expr! {
-                _serde::#private::Result::map(#func(__variant), #this_value::#variant_ident)
-            }
-        }
-        Some(path) => {
-            let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-            quote_block! {
-                #wrapper
-                _serde::#private::Result::map(
-                    _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
-                    |__wrapper| #this_value::#variant_ident(__wrapper.value))
-            }
-        }
-    }
-}

serde_derive/src/de/enum_internally.rs

@@ -1,106 +0,0 @@
-//! Deserialization for internally tagged enums:
-//!
-//! ```ignore
-//! #[serde(tag = "...")]
-//! enum Enum {}
-//! ```
-
-use crate::de::enum_;
-use crate::de::enum_untagged;
-use crate::de::struct_;
-use crate::de::{
-    effective_style, expr_is_missing, field_i, unwrap_to_variant_closure, Parameters, StructForm,
-};
-use crate::fragment::{Expr, Fragment, Match};
-use crate::internals::ast::{Style, Variant};
-use crate::internals::attr;
-use crate::private;
-use quote::quote;
-
-/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(tag)]` attribute
-pub(super) fn deserialize(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-    tag: &str,
-) -> Fragment {
-    let (variants_stmt, variant_visitor) = enum_::prepare_enum_variant_enum(variants);
-
-    // Match arms to extract a variant from a string
-    let variant_arms = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| {
-            let variant_name = field_i(i);
-
-            let block = Match(deserialize_internally_tagged_variant(
-                params, variant, cattrs,
-            ));
-
-            quote! {
-                __Field::#variant_name => #block
-            }
-        });
-
-    let expecting = format!("internally tagged enum {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    quote_block! {
-        #variant_visitor
-
-        #variants_stmt
-
-        let (__tag, __content) = _serde::Deserializer::deserialize_any(
-            __deserializer,
-            _serde::#private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
-        let __deserializer = _serde::#private::de::ContentDeserializer::<__D::Error>::new(__content);
-
-        match __tag {
-            #(#variant_arms)*
-        }
-    }
-}
-
-// Generates significant part of the visit_seq and visit_map bodies of visitors
-// for the variants of internally tagged enum.
-fn deserialize_internally_tagged_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-) -> Fragment {
-    if let Some(path) = variant.attrs.deserialize_with() {
-        let unwrap_fn = unwrap_to_variant_closure(params, variant, false);
-        return quote_block! {
-            _serde::#private::Result::map(#path(__deserializer), #unwrap_fn)
-        };
-    }
-
-    let variant_ident = &variant.ident;
-
-    match effective_style(variant) {
-        Style::Unit => {
-            let this_value = &params.this_value;
-            let type_name = params.type_name();
-            let variant_name = variant.ident.to_string();
-            let default = variant.fields.first().map(|field| {
-                let default = Expr(expr_is_missing(field, cattrs));
-                quote!((#default))
-            });
-            quote_block! {
-                _serde::Deserializer::deserialize_any(__deserializer, _serde::#private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?;
-                _serde::#private::Ok(#this_value::#variant_ident #default)
-            }
-        }
-        Style::Newtype => {
-            enum_untagged::deserialize_newtype_variant(variant_ident, params, &variant.fields[0])
-        }
-        Style::Struct => struct_::deserialize(
-            params,
-            &variant.fields,
-            cattrs,
-            StructForm::InternallyTagged(variant_ident),
-        ),
-        Style::Tuple => unreachable!("checked in serde_derive_internals"),
-    }
-}

serde_derive/src/de/enum_untagged.rs

@@ -1,135 +0,0 @@
-//! Deserialization for untagged enums:
-//!
-//! ```ignore
-//! #[serde(untagged)]
-//! enum Enum {}
-//! ```
-
-use crate::de::struct_;
-use crate::de::tuple;
-use crate::de::{
-    effective_style, expr_is_missing, unwrap_to_variant_closure, Parameters, StructForm, TupleForm,
-};
-use crate::fragment::{Expr, Fragment};
-use crate::internals::ast::{Field, Style, Variant};
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
-
-/// Generates `Deserialize::deserialize` body for an `enum Enum {...}` with `#[serde(untagged)]` attribute
-pub(super) fn deserialize(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-    first_attempt: Option<TokenStream>,
-) -> Fragment {
-    let attempts = variants
-        .iter()
-        .filter(|variant| !variant.attrs.skip_deserializing())
-        .map(|variant| Expr(deserialize_variant(params, variant, cattrs)));
-    // 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
-    // largest number of fields. I'm not sure I like that. Maybe it would be
-    // better to save all the errors and combine them into one message that
-    // explains why none of the variants matched.
-    let fallthrough_msg = format!(
-        "data did not match any variant of untagged enum {}",
-        params.type_name()
-    );
-    let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
-
-    let private2 = private;
-    quote_block! {
-        let __content = _serde::de::DeserializeSeed::deserialize(_serde::#private::de::ContentVisitor::new(), __deserializer)?;
-        let __deserializer = _serde::#private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
-
-        #first_attempt
-
-        #(
-            if let _serde::#private2::Ok(__ok) = #attempts {
-                return _serde::#private2::Ok(__ok);
-            }
-        )*
-
-        _serde::#private::Err(_serde::de::Error::custom(#fallthrough_msg))
-    }
-}
-
-// Also used by adjacently tagged enums
-pub(super) fn deserialize_variant(
-    params: &Parameters,
-    variant: &Variant,
-    cattrs: &attr::Container,
-) -> Fragment {
-    if let Some(path) = variant.attrs.deserialize_with() {
-        let unwrap_fn = unwrap_to_variant_closure(params, variant, false);
-        return quote_block! {
-            _serde::#private::Result::map(#path(__deserializer), #unwrap_fn)
-        };
-    }
-
-    let variant_ident = &variant.ident;
-
-    match effective_style(variant) {
-        Style::Unit => {
-            let this_value = &params.this_value;
-            let type_name = params.type_name();
-            let variant_name = variant.ident.to_string();
-            let default = variant.fields.first().map(|field| {
-                let default = Expr(expr_is_missing(field, cattrs));
-                quote!((#default))
-            });
-            quote_expr! {
-                match _serde::Deserializer::deserialize_any(
-                    __deserializer,
-                    _serde::#private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
-                ) {
-                    _serde::#private::Ok(()) => _serde::#private::Ok(#this_value::#variant_ident #default),
-                    _serde::#private::Err(__err) => _serde::#private::Err(__err),
-                }
-            }
-        }
-        Style::Newtype => deserialize_newtype_variant(variant_ident, params, &variant.fields[0]),
-        Style::Tuple => tuple::deserialize(
-            params,
-            &variant.fields,
-            cattrs,
-            TupleForm::Untagged(variant_ident),
-        ),
-        Style::Struct => struct_::deserialize(
-            params,
-            &variant.fields,
-            cattrs,
-            StructForm::Untagged(variant_ident),
-        ),
-    }
-}
-
-// Also used by internally tagged enums
-// Implicitly (via `generate_variant`) used by adjacently tagged enums
-pub(super) fn deserialize_newtype_variant(
-    variant_ident: &syn::Ident,
-    params: &Parameters,
-    field: &Field,
-) -> Fragment {
-    let this_value = &params.this_value;
-    let field_ty = field.ty;
-    match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
-            quote_expr! {
-                _serde::#private::Result::map(#func(__deserializer), #this_value::#variant_ident)
-            }
-        }
-        Some(path) => {
-            quote_block! {
-                let __value: _serde::#private::Result<#field_ty, _> = #path(__deserializer);
-                _serde::#private::Result::map(__value, #this_value::#variant_ident)
-            }
-        }
-    }
-}

serde_derive/src/de/identifier.rs

@@ -1,477 +0,0 @@
-//! Deserialization of struct field identifiers and enum variant identifiers by
-//! way of a Rust enum.
-
-use crate::de::{FieldWithAliases, Parameters};
-use crate::fragment::{Fragment, Stmts};
-use crate::internals::ast::{Style, Variant};
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::{Literal, TokenStream};
-use quote::{quote, ToTokens};
-
-// Generates `Deserialize::deserialize` body for an enum with
-// `serde(field_identifier)` or `serde(variant_identifier)` attribute.
-pub(super) fn deserialize_custom(
-    params: &Parameters,
-    variants: &[Variant],
-    cattrs: &attr::Container,
-) -> Fragment {
-    let is_variant = match cattrs.identifier() {
-        attr::Identifier::Variant => true,
-        attr::Identifier::Field => false,
-        attr::Identifier::No => unreachable!(),
-    };
-
-    let this_type = params.this_type.to_token_stream();
-    let this_value = params.this_value.to_token_stream();
-
-    let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
-        let last_ident = &last.ident;
-        if last.attrs.other() {
-            // Process `serde(other)` attribute. It would always be found on the
-            // last variant (checked in `check_identifier`), so all preceding
-            // are ordinary variants.
-            let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::#private::Ok(#this_value::#last_ident));
-            (ordinary, Some(fallthrough), None)
-        } else if let Style::Newtype = last.style {
-            let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = |value| {
-                quote! {
-                    _serde::#private::Result::map(
-                        _serde::Deserialize::deserialize(
-                            _serde::#private::de::IdentifierDeserializer::from(#value)
-                        ),
-                        #this_value::#last_ident)
-                }
-            };
-            (
-                ordinary,
-                Some(fallthrough(quote!(__value))),
-                Some(fallthrough(quote!(_serde::#private::de::Borrowed(
-                    __value
-                )))),
-            )
-        } else {
-            (variants, None, None)
-        }
-    } else {
-        (variants, None, None)
-    };
-
-    let idents_aliases: Vec<_> = ordinary
-        .iter()
-        .map(|variant| FieldWithAliases {
-            ident: variant.ident.clone(),
-            aliases: variant.attrs.aliases(),
-        })
-        .collect();
-
-    let names = idents_aliases.iter().flat_map(|variant| variant.aliases);
-
-    let names_const = if fallthrough.is_some() {
-        None
-    } else if is_variant {
-        let variants = quote! {
-            #[doc(hidden)]
-            const VARIANTS: &'static [&'static str] = &[ #(#names),* ];
-        };
-        Some(variants)
-    } else {
-        let fields = quote! {
-            #[doc(hidden)]
-            const FIELDS: &'static [&'static str] = &[ #(#names),* ];
-        };
-        Some(fields)
-    };
-
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-    let visitor_impl = Stmts(deserialize_identifier(
-        &this_value,
-        &idents_aliases,
-        is_variant,
-        fallthrough,
-        fallthrough_borrowed,
-        false,
-        cattrs.expecting(),
-    ));
-
-    quote_block! {
-        #names_const
-
-        #[doc(hidden)]
-        struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            #visitor_impl
-        }
-
-        let __visitor = __FieldVisitor {
-            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData,
-        };
-        _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
-    }
-}
-
-pub(super) fn deserialize_generated(
-    deserialized_fields: &[FieldWithAliases],
-    has_flatten: bool,
-    is_variant: bool,
-    ignore_variant: Option<TokenStream>,
-    fallthrough: Option<TokenStream>,
-) -> Fragment {
-    let this_value = quote!(__Field);
-    let field_idents: &Vec<_> = &deserialized_fields
-        .iter()
-        .map(|field| &field.ident)
-        .collect();
-
-    let visitor_impl = Stmts(deserialize_identifier(
-        &this_value,
-        deserialized_fields,
-        is_variant,
-        fallthrough,
-        None,
-        !is_variant && has_flatten,
-        None,
-    ));
-
-    let lifetime = if !is_variant && has_flatten {
-        Some(quote!(<'de>))
-    } else {
-        None
-    };
-
-    quote_block! {
-        #[allow(non_camel_case_types)]
-        #[doc(hidden)]
-        enum __Field #lifetime {
-            #(#field_idents,)*
-            #ignore_variant
-        }
-
-        #[doc(hidden)]
-        struct __FieldVisitor;
-
-        #[automatically_derived]
-        impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
-            type Value = __Field #lifetime;
-
-            #visitor_impl
-        }
-
-        #[automatically_derived]
-        impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
-            #[inline]
-            fn deserialize<__D>(__deserializer: __D) -> _serde::#private::Result<Self, __D::Error>
-            where
-                __D: _serde::Deserializer<'de>,
-            {
-                _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
-            }
-        }
-    }
-}
-
-fn deserialize_identifier(
-    this_value: &TokenStream,
-    deserialized_fields: &[FieldWithAliases],
-    is_variant: bool,
-    fallthrough: Option<TokenStream>,
-    fallthrough_borrowed: Option<TokenStream>,
-    collect_other_fields: bool,
-    expecting: Option<&str>,
-) -> Fragment {
-    let str_mapping = deserialized_fields.iter().map(|field| {
-        let ident = &field.ident;
-        let aliases = field.aliases;
-        let private2 = private;
-        // `aliases` also contains a main name
-        quote! {
-            #(
-                #aliases => _serde::#private2::Ok(#this_value::#ident),
-            )*
-        }
-    });
-    let bytes_mapping = deserialized_fields.iter().map(|field| {
-        let ident = &field.ident;
-        // `aliases` also contains a main name
-        let aliases = field
-            .aliases
-            .iter()
-            .map(|alias| Literal::byte_string(alias.value.as_bytes()));
-        let private2 = private;
-        quote! {
-            #(
-                #aliases => _serde::#private2::Ok(#this_value::#ident),
-            )*
-        }
-    });
-
-    let expecting = expecting.unwrap_or(if is_variant {
-        "variant identifier"
-    } else {
-        "field identifier"
-    });
-
-    let bytes_to_str = if fallthrough.is_some() || collect_other_fields {
-        None
-    } else {
-        Some(quote! {
-            let __value = &_serde::#private::from_utf8_lossy(__value);
-        })
-    };
-
-    let (
-        value_as_str_content,
-        value_as_borrowed_str_content,
-        value_as_bytes_content,
-        value_as_borrowed_bytes_content,
-    ) = if collect_other_fields {
-        (
-            Some(quote! {
-                let __value = _serde::#private::de::Content::String(_serde::#private::ToString::to_string(__value));
-            }),
-            Some(quote! {
-                let __value = _serde::#private::de::Content::Str(__value);
-            }),
-            Some(quote! {
-                let __value = _serde::#private::de::Content::ByteBuf(__value.to_vec());
-            }),
-            Some(quote! {
-                let __value = _serde::#private::de::Content::Bytes(__value);
-            }),
-        )
-    } else {
-        (None, None, None, None)
-    };
-
-    let fallthrough_arm_tokens;
-    let fallthrough_arm = if let Some(fallthrough) = &fallthrough {
-        fallthrough
-    } else if is_variant {
-        fallthrough_arm_tokens = quote! {
-            _serde::#private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
-        };
-        &fallthrough_arm_tokens
-    } else {
-        fallthrough_arm_tokens = quote! {
-            _serde::#private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
-        };
-        &fallthrough_arm_tokens
-    };
-
-    let visit_other = if collect_other_fields {
-        quote! {
-            fn visit_bool<__E>(self, __value: bool) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::Bool(__value)))
-            }
-
-            fn visit_i8<__E>(self, __value: i8) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::I8(__value)))
-            }
-
-            fn visit_i16<__E>(self, __value: i16) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::I16(__value)))
-            }
-
-            fn visit_i32<__E>(self, __value: i32) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::I32(__value)))
-            }
-
-            fn visit_i64<__E>(self, __value: i64) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::I64(__value)))
-            }
-
-            fn visit_u8<__E>(self, __value: u8) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::U8(__value)))
-            }
-
-            fn visit_u16<__E>(self, __value: u16) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::U16(__value)))
-            }
-
-            fn visit_u32<__E>(self, __value: u32) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::U32(__value)))
-            }
-
-            fn visit_u64<__E>(self, __value: u64) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::U64(__value)))
-            }
-
-            fn visit_f32<__E>(self, __value: f32) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::F32(__value)))
-            }
-
-            fn visit_f64<__E>(self, __value: f64) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::F64(__value)))
-            }
-
-            fn visit_char<__E>(self, __value: char) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::Char(__value)))
-            }
-
-            fn visit_unit<__E>(self) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::Unit))
-            }
-        }
-    } else {
-        let u64_mapping = deserialized_fields.iter().enumerate().map(|(i, field)| {
-            let i = i as u64;
-            let ident = &field.ident;
-            quote!(#i => _serde::#private::Ok(#this_value::#ident))
-        });
-
-        let u64_fallthrough_arm_tokens;
-        let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough {
-            fallthrough
-        } else {
-            let index_expecting = if is_variant { "variant" } else { "field" };
-            let fallthrough_msg = format!(
-                "{} index 0 <= i < {}",
-                index_expecting,
-                deserialized_fields.len(),
-            );
-            u64_fallthrough_arm_tokens = quote! {
-                _serde::#private::Err(_serde::de::Error::invalid_value(
-                    _serde::de::Unexpected::Unsigned(__value),
-                    &#fallthrough_msg,
-                ))
-            };
-            &u64_fallthrough_arm_tokens
-        };
-
-        quote! {
-            fn visit_u64<__E>(self, __value: u64) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(#u64_mapping,)*
-                    _ => #u64_fallthrough_arm,
-                }
-            }
-        }
-    };
-
-    let visit_borrowed = if fallthrough_borrowed.is_some() || collect_other_fields {
-        let str_mapping = str_mapping.clone();
-        let bytes_mapping = bytes_mapping.clone();
-        let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(fallthrough_arm);
-        Some(quote! {
-            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(#str_mapping)*
-                    _ => {
-                        #value_as_borrowed_str_content
-                        #fallthrough_borrowed_arm
-                    }
-                }
-            }
-
-            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                match __value {
-                    #(#bytes_mapping)*
-                    _ => {
-                        #bytes_to_str
-                        #value_as_borrowed_bytes_content
-                        #fallthrough_borrowed_arm
-                    }
-                }
-            }
-        })
-    } else {
-        None
-    };
-
-    quote_block! {
-        fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-            _serde::#private::Formatter::write_str(__formatter, #expecting)
-        }
-
-        #visit_other
-
-        fn visit_str<__E>(self, __value: &str) -> _serde::#private::Result<Self::Value, __E>
-        where
-            __E: _serde::de::Error,
-        {
-            match __value {
-                #(#str_mapping)*
-                _ => {
-                    #value_as_str_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
-        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::#private::Result<Self::Value, __E>
-        where
-            __E: _serde::de::Error,
-        {
-            match __value {
-                #(#bytes_mapping)*
-                _ => {
-                    #bytes_to_str
-                    #value_as_bytes_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
-        #visit_borrowed
-    }
-}

serde_derive/src/de/struct_.rs

@@ -1,697 +0,0 @@
-use crate::de::identifier;
-use crate::de::{
-    deserialize_seq, expr_is_missing, field_i, has_flatten, wrap_deserialize_field_with,
-    FieldWithAliases, Parameters, StructForm,
-};
-#[cfg(feature = "deserialize_in_place")]
-use crate::de::{deserialize_seq_in_place, place_lifetime};
-use crate::fragment::{Expr, Fragment, Match, Stmts};
-use crate::internals::ast::Field;
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
-
-/// Generates `Deserialize::deserialize` body for a `struct Struct {...}`
-pub(super) fn deserialize(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    form: StructForm,
-) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    // If there are getters (implying private fields), construct the local type
-    // and use an `Into` conversion to get the remote type. If there are no
-    // getters then construct the target type directly.
-    let construct = if params.has_getter {
-        let local = &params.local;
-        quote!(#local)
-    } else {
-        quote!(#this_value)
-    };
-
-    let type_path = match form {
-        StructForm::Struct => construct,
-        StructForm::ExternallyTagged(variant_ident)
-        | StructForm::InternallyTagged(variant_ident)
-        | StructForm::Untagged(variant_ident) => quote!(#construct::#variant_ident),
-    };
-    let expecting = match form {
-        StructForm::Struct => format!("struct {}", params.type_name()),
-        StructForm::ExternallyTagged(variant_ident)
-        | StructForm::InternallyTagged(variant_ident)
-        | StructForm::Untagged(variant_ident) => {
-            format!("struct variant {}::{}", params.type_name(), variant_ident)
-        }
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let deserialized_fields: Vec<_> = fields
-        .iter()
-        .enumerate()
-        // Skip fields that shouldn't be deserialized or that were flattened,
-        // so they don't appear in the storage in their literal form
-        .filter(|&(_, field)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(i, field)| FieldWithAliases {
-            ident: field_i(i),
-            aliases: field.attrs.aliases(),
-        })
-        .collect();
-
-    let has_flatten = has_flatten(fields);
-    let field_visitor = deserialize_field_identifier(&deserialized_fields, cattrs, has_flatten);
-
-    // untagged struct variants do not get a visit_seq method. The same applies to
-    // structs that only have a map representation.
-    let visit_seq = match form {
-        StructForm::Untagged(_) => None,
-        _ if has_flatten => None,
-        _ => {
-            let mut_seq = if deserialized_fields.is_empty() {
-                quote!(_)
-            } else {
-                quote!(mut __seq)
-            };
-
-            let visit_seq = Stmts(deserialize_seq(
-                &type_path, params, fields, true, cattrs, expecting,
-            ));
-
-            Some(quote! {
-                #[inline]
-                fn visit_seq<__A>(self, #mut_seq: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-                where
-                    __A: _serde::de::SeqAccess<#delife>,
-                {
-                    #visit_seq
-                }
-            })
-        }
-    };
-    let visit_map = Stmts(deserialize_map(
-        &type_path,
-        params,
-        fields,
-        cattrs,
-        has_flatten,
-    ));
-
-    let visitor_seed = match form {
-        StructForm::ExternallyTagged(..) if has_flatten => Some(quote! {
-            #[automatically_derived]
-            impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
-                type Value = #this_type #ty_generics;
-
-                fn deserialize<__D>(self, __deserializer: __D) -> _serde::#private::Result<Self::Value, __D::Error>
-                where
-                    __D: _serde::Deserializer<#delife>,
-                {
-                    _serde::Deserializer::deserialize_map(__deserializer, self)
-                }
-            }
-        }),
-        _ => None,
-    };
-
-    let fields_stmt = if has_flatten {
-        None
-    } else {
-        let field_names = deserialized_fields.iter().flat_map(|field| field.aliases);
-
-        Some(quote! {
-            #[doc(hidden)]
-            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
-        })
-    };
-
-    let visitor_expr = quote! {
-        __Visitor {
-            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData,
-        }
-    };
-    let dispatch = match form {
-        StructForm::Struct if has_flatten => quote! {
-            _serde::Deserializer::deserialize_map(__deserializer, #visitor_expr)
-        },
-        StructForm::Struct => {
-            let type_name = cattrs.name().deserialize_name();
-            quote! {
-                _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
-            }
-        }
-        StructForm::ExternallyTagged(_) if has_flatten => quote! {
-            _serde::de::VariantAccess::newtype_variant_seed(__variant, #visitor_expr)
-        },
-        StructForm::ExternallyTagged(_) => quote! {
-            _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
-        },
-        StructForm::InternallyTagged(_) => quote! {
-            _serde::Deserializer::deserialize_any(__deserializer, #visitor_expr)
-        },
-        StructForm::Untagged(_) => quote! {
-            _serde::Deserializer::deserialize_any(__deserializer, #visitor_expr)
-        },
-    };
-
-    quote_block! {
-        #field_visitor
-
-        #[doc(hidden)]
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_seq
-
-            #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                #visit_map
-            }
-        }
-
-        #visitor_seed
-
-        #fields_stmt
-
-        #dispatch
-    }
-}
-
-fn deserialize_map(
-    struct_path: &TokenStream,
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    has_flatten: bool,
-) -> Fragment {
-    // Create the field names for the fields.
-    let fields_names: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| (field, field_i(i)))
-        .collect();
-
-    // Declare each field that will be deserialized.
-    let let_values = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let field_ty = field.ty;
-            quote! {
-                let mut #name: _serde::#private::Option<#field_ty> = _serde::#private::None;
-            }
-        });
-
-    // Collect contents for flatten fields into a buffer
-    let let_collect = if has_flatten {
-        Some(quote! {
-            let mut __collect = _serde::#private::Vec::<_serde::#private::Option<(
-                _serde::#private::de::Content,
-                _serde::#private::de::Content
-            )>>::new();
-        })
-    } else {
-        None
-    };
-
-    // Match arms to extract a value for a field.
-    let value_arms = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let deser_name = field.attrs.name().deserialize_name();
-
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    let field_ty = field.ty;
-                    let span = field.original.span();
-                    let func =
-                        quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
-                    quote! {
-                        #func(&mut __map)?
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::#private::Ok(__wrapper) => __wrapper.value,
-                            _serde::#private::Err(__err) => {
-                                return _serde::#private::Err(__err);
-                            }
-                        }
-                    })
-                }
-            };
-            quote! {
-                __Field::#name => {
-                    if _serde::#private::Option::is_some(&#name) {
-                        return _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
-                    }
-                    #name = _serde::#private::Some(#visit);
-                }
-            }
-        });
-
-    // Visit ignored values to consume them
-    let ignored_arm = if has_flatten {
-        Some(quote! {
-            __Field::__other(__name) => {
-                __collect.push(_serde::#private::Some((
-                    __name,
-                    _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::ContentVisitor::new())?)));
-            }
-        })
-    } else if cattrs.deny_unknown_fields() {
-        None
-    } else {
-        Some(quote! {
-            _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
-        })
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
-        quote! {
-            // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::#private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
-            _serde::#private::Option::map(
-                _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
-                |__impossible| match __impossible {});
-        }
-    } else {
-        quote! {
-            while let _serde::#private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
-                match __key {
-                    #(#value_arms)*
-                    #ignored_arm
-                }
-            }
-        }
-    };
-
-    let extract_values = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(field, name)| {
-            let missing_expr = Match(expr_is_missing(field, cattrs));
-
-            quote! {
-                let #name = match #name {
-                    _serde::#private::Some(#name) => #name,
-                    _serde::#private::None => #missing_expr
-                };
-            }
-        });
-
-    let extract_collected = fields_names
-        .iter()
-        .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let field_ty = field.ty;
-            let func = match field.attrs.deserialize_with() {
-                None => {
-                    let span = field.original.span();
-                    quote_spanned!(span=> _serde::de::Deserialize::deserialize)
-                }
-                Some(path) => quote!(#path),
-            };
-            quote! {
-                let #name: #field_ty = #func(
-                    _serde::#private::de::FlatMapDeserializer(
-                        &mut __collect,
-                        _serde::#private::PhantomData))?;
-            }
-        });
-
-    let collected_deny_unknown_fields = if has_flatten && cattrs.deny_unknown_fields() {
-        Some(quote! {
-            if let _serde::#private::Some(_serde::#private::Some((__key, _))) =
-                __collect.into_iter().filter(_serde::#private::Option::is_some).next()
-            {
-                if let _serde::#private::Some(__key) = _serde::#private::de::content_as_str(&__key) {
-                    return _serde::#private::Err(
-                        _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
-                } else {
-                    return _serde::#private::Err(
-                        _serde::de::Error::custom(format_args!("unexpected map key")));
-                }
-            }
-        })
-    } else {
-        None
-    };
-
-    let result = fields_names.iter().map(|(field, name)| {
-        let member = &field.member;
-        if field.attrs.skip_deserializing() {
-            let value = Expr(expr_is_missing(field, cattrs));
-            quote!(#member: #value)
-        } else {
-            quote!(#member: #name)
-        }
-    });
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::#private::Default::default();
-        )),
-        // If #path returns wrong type, error will be reported here (^^^^^).
-        // We attach span of the path to the function so it will be reported
-        // on the #[serde(default = "...")]
-        //                          ^^^^^
-        attr::Default::Path(path) => Some(quote_spanned!(path.span()=>
-            let __default: Self::Value = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    let mut result = quote!(#struct_path { #(#result),* });
-    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
-        result = quote! {
-            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
-        };
-    }
-
-    quote_block! {
-        #(#let_values)*
-
-        #let_collect
-
-        #match_keys
-
-        #let_default
-
-        #(#extract_values)*
-
-        #(#extract_collected)*
-
-        #collected_deny_unknown_fields
-
-        _serde::#private::Ok(#result)
-    }
-}
-
-/// Generates `Deserialize::deserialize_in_place` body for a `struct Struct {...}`
-#[cfg(feature = "deserialize_in_place")]
-pub(super) fn deserialize_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Option<Fragment> {
-    // for now we do not support in_place deserialization for structs that
-    // are represented as map.
-    if has_flatten(fields) {
-        return None;
-    }
-
-    let this_type = &params.this_type;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    let expecting = format!("struct {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let deserialized_fields: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .filter(|&(_, field)| !field.attrs.skip_deserializing())
-        .map(|(i, field)| FieldWithAliases {
-            ident: field_i(i),
-            aliases: field.attrs.aliases(),
-        })
-        .collect();
-
-    let field_visitor = deserialize_field_identifier(&deserialized_fields, cattrs, false);
-
-    let mut_seq = if deserialized_fields.is_empty() {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
-    let visit_map = Stmts(deserialize_map_in_place(params, fields, cattrs));
-    let field_names = deserialized_fields.iter().flat_map(|field| field.aliases);
-    let type_name = cattrs.name().deserialize_name();
-
-    let in_place_impl_generics = de_impl_generics.in_place();
-    let in_place_ty_generics = de_ty_generics.in_place();
-    let place_life = place_lifetime();
-
-    Some(quote_block! {
-        #field_visitor
-
-        #[doc(hidden)]
-        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this_type #ty_generics,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
-            type Value = ();
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #[inline]
-            fn visit_seq<__A>(self, #mut_seq: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-
-            #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::MapAccess<#delife>,
-            {
-                #visit_map
-            }
-        }
-
-        #[doc(hidden)]
-        const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
-
-        _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, __Visitor {
-            place: __place,
-            lifetime: _serde::#private::PhantomData,
-        })
-    })
-}
-
-#[cfg(feature = "deserialize_in_place")]
-fn deserialize_map_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    assert!(
-        !has_flatten(fields),
-        "inplace deserialization of maps does not support flatten fields"
-    );
-
-    // Create the field names for the fields.
-    let fields_names: Vec<_> = fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| (field, field_i(i)))
-        .collect();
-
-    // For deserialize_in_place, declare booleans for each field that will be
-    // deserialized.
-    let let_flags = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(_, name)| {
-            quote! {
-                let mut #name: bool = false;
-            }
-        });
-
-    // Match arms to extract a value for a field.
-    let value_arms_from = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let deser_name = field.attrs.name().deserialize_name();
-            let member = &field.member;
-
-            let visit = match field.attrs.deserialize_with() {
-                None => {
-                    quote! {
-                        _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::InPlaceSeed(&mut self.place.#member))?
-                    }
-                }
-                Some(path) => {
-                    let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
-                    quote!({
-                        #wrapper
-                        self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::#private::Ok(__wrapper) => __wrapper.value,
-                            _serde::#private::Err(__err) => {
-                                return _serde::#private::Err(__err);
-                            }
-                        };
-                    })
-                }
-            };
-            quote! {
-                __Field::#name => {
-                    if #name {
-                        return _serde::#private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
-                    }
-                    #visit;
-                    #name = true;
-                }
-            }
-        });
-
-    // Visit ignored values to consume them
-    let ignored_arm = if cattrs.deny_unknown_fields() {
-        None
-    } else {
-        Some(quote! {
-            _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
-        })
-    };
-
-    let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
-
-    let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
-        quote! {
-            // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::#private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
-            _serde::#private::Option::map(
-                _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
-                |__impossible| match __impossible {});
-        }
-    } else {
-        quote! {
-            while let _serde::#private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
-                match __key {
-                    #(#value_arms_from)*
-                    #ignored_arm
-                }
-            }
-        }
-    };
-
-    let check_flags = fields_names
-        .iter()
-        .filter(|&&(field, _)| !field.attrs.skip_deserializing())
-        .map(|(field, name)| {
-            let missing_expr = expr_is_missing(field, cattrs);
-            // If missing_expr unconditionally returns an error, don't try
-            // to assign its value to self.place.
-            if field.attrs.default().is_none()
-                && cattrs.default().is_none()
-                && field.attrs.deserialize_with().is_some()
-            {
-                let missing_expr = Stmts(missing_expr);
-                quote! {
-                    if !#name {
-                        #missing_expr;
-                    }
-                }
-            } else {
-                let member = &field.member;
-                let missing_expr = Expr(missing_expr);
-                quote! {
-                    if !#name {
-                        self.place.#member = #missing_expr;
-                    };
-                }
-            }
-        });
-
-    let this_type = &params.this_type;
-    let (_, ty_generics, _) = params.generics.split_for_impl();
-
-    let let_default = match cattrs.default() {
-        attr::Default::Default => Some(quote!(
-            let __default: #this_type #ty_generics = _serde::#private::Default::default();
-        )),
-        // If #path returns wrong type, error will be reported here (^^^^^).
-        // We attach span of the path to the function so it will be reported
-        // on the #[serde(default = "...")]
-        //                          ^^^^^
-        attr::Default::Path(path) => Some(quote_spanned!(path.span()=>
-            let __default: #this_type #ty_generics = #path();
-        )),
-        attr::Default::None => {
-            // We don't need the default value, to prevent an unused variable warning
-            // we'll leave the line empty.
-            None
-        }
-    };
-
-    quote_block! {
-        #(#let_flags)*
-
-        #match_keys
-
-        #let_default
-
-        #(#check_flags)*
-
-        _serde::#private::Ok(())
-    }
-}
-
-/// Generates enum and its `Deserialize` implementation that represents each
-/// non-skipped field of the struct
-fn deserialize_field_identifier(
-    deserialized_fields: &[FieldWithAliases],
-    cattrs: &attr::Container,
-    has_flatten: bool,
-) -> Stmts {
-    let (ignore_variant, fallthrough) = if 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(identifier::deserialize_generated(
-        deserialized_fields,
-        has_flatten,
-        false,
-        ignore_variant,
-        fallthrough,
-    ))
-}

serde_derive/src/de/tuple.rs

@@ -1,283 +0,0 @@
-use crate::de::{deserialize_seq, has_flatten, Parameters, TupleForm};
-#[cfg(feature = "deserialize_in_place")]
-use crate::de::{deserialize_seq_in_place, place_lifetime};
-use crate::fragment::{Fragment, Stmts};
-use crate::internals::ast::Field;
-use crate::internals::attr;
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::{quote, quote_spanned};
-use syn::spanned::Spanned;
-
-/// Generates `Deserialize::deserialize` body for a `struct Tuple(...);` including `struct Newtype(T);`
-pub(super) fn deserialize(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-    form: TupleForm,
-) -> Fragment {
-    assert!(
-        !has_flatten(fields),
-        "tuples and tuple variants cannot have flatten fields"
-    );
-
-    let field_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    // If there are getters (implying private fields), construct the local type
-    // and use an `Into` conversion to get the remote type. If there are no
-    // getters then construct the target type directly.
-    let construct = if params.has_getter {
-        let local = &params.local;
-        quote!(#local)
-    } else {
-        quote!(#this_value)
-    };
-
-    let type_path = match form {
-        TupleForm::Tuple => construct,
-        TupleForm::ExternallyTagged(variant_ident) | TupleForm::Untagged(variant_ident) => {
-            quote!(#construct::#variant_ident)
-        }
-    };
-    let expecting = match form {
-        TupleForm::Tuple => format!("tuple struct {}", params.type_name()),
-        TupleForm::ExternallyTagged(variant_ident) | TupleForm::Untagged(variant_ident) => {
-            format!("tuple variant {}::{}", params.type_name(), variant_ident)
-        }
-    };
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let nfields = fields.len();
-
-    let visit_newtype_struct = match form {
-        TupleForm::Tuple if nfields == 1 => {
-            Some(deserialize_newtype_struct(&type_path, params, &fields[0]))
-        }
-        _ => None,
-    };
-
-    let visit_seq = Stmts(deserialize_seq(
-        &type_path, params, fields, false, cattrs, expecting,
-    ));
-
-    let visitor_expr = quote! {
-        __Visitor {
-            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData,
-        }
-    };
-    let dispatch = match form {
-        TupleForm::Tuple if nfields == 1 => {
-            let type_name = cattrs.name().deserialize_name();
-            quote! {
-                _serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr)
-            }
-        }
-        TupleForm::Tuple => {
-            let type_name = cattrs.name().deserialize_name();
-            quote! {
-                _serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #field_count, #visitor_expr)
-            }
-        }
-        TupleForm::ExternallyTagged(_) => quote! {
-            _serde::de::VariantAccess::tuple_variant(__variant, #field_count, #visitor_expr)
-        },
-        TupleForm::Untagged(_) => quote! {
-            _serde::Deserializer::deserialize_tuple(__deserializer, #field_count, #visitor_expr)
-        },
-    };
-
-    let visitor_var = if field_count == 0 {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    quote_block! {
-        #[doc(hidden)]
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_newtype_struct
-
-            #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-        }
-
-        #dispatch
-    }
-}
-
-fn deserialize_newtype_struct(
-    type_path: &TokenStream,
-    params: &Parameters,
-    field: &Field,
-) -> TokenStream {
-    let delife = params.borrowed.de_lifetime();
-    let field_ty = field.ty;
-    let deserializer_var = quote!(__e);
-
-    let value = match field.attrs.deserialize_with() {
-        None => {
-            let span = field.original.span();
-            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
-            quote! {
-                #func(#deserializer_var)?
-            }
-        }
-        Some(path) => {
-            // If #path returns wrong type, error will be reported here (^^^^^).
-            // We attach span of the path to the function so it will be reported
-            // on the #[serde(with = "...")]
-            //                       ^^^^^
-            quote_spanned! {path.span()=>
-                #path(#deserializer_var)?
-            }
-        }
-    };
-
-    let mut result = quote!(#type_path(__field0));
-    if params.has_getter {
-        let this_type = &params.this_type;
-        let (_, ty_generics, _) = params.generics.split_for_impl();
-        result = quote! {
-            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
-        };
-    }
-
-    quote! {
-        #[inline]
-        fn visit_newtype_struct<__E>(self, #deserializer_var: __E) -> _serde::#private::Result<Self::Value, __E::Error>
-        where
-            __E: _serde::Deserializer<#delife>,
-        {
-            let __field0: #field_ty = #value;
-            _serde::#private::Ok(#result)
-        }
-    }
-}
-
-/// Generates `Deserialize::deserialize_in_place` body for a `struct Tuple(...);` including `struct Newtype(T);`
-#[cfg(feature = "deserialize_in_place")]
-pub(super) fn deserialize_in_place(
-    params: &Parameters,
-    fields: &[Field],
-    cattrs: &attr::Container,
-) -> Fragment {
-    assert!(
-        !has_flatten(fields),
-        "tuples and tuple variants cannot have flatten fields"
-    );
-
-    let field_count = fields
-        .iter()
-        .filter(|field| !field.attrs.skip_deserializing())
-        .count();
-
-    let this_type = &params.this_type;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    let expecting = format!("tuple struct {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    let nfields = fields.len();
-
-    let visit_newtype_struct = if nfields == 1 {
-        // We do not generate deserialize_in_place if every field has a
-        // deserialize_with.
-        assert!(fields[0].attrs.deserialize_with().is_none());
-
-        Some(quote! {
-            #[inline]
-            fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::#private::Result<Self::Value, __E::Error>
-            where
-                __E: _serde::Deserializer<#delife>,
-            {
-                _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
-            }
-        })
-    } else {
-        None
-    };
-
-    let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, expecting));
-
-    let visitor_expr = quote! {
-        __Visitor {
-            place: __place,
-            lifetime: _serde::#private::PhantomData,
-        }
-    };
-
-    let type_name = cattrs.name().deserialize_name();
-    let dispatch = if nfields == 1 {
-        quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr))
-    } else {
-        quote!(_serde::Deserializer::deserialize_tuple_struct(__deserializer, #type_name, #field_count, #visitor_expr))
-    };
-
-    let visitor_var = if field_count == 0 {
-        quote!(_)
-    } else {
-        quote!(mut __seq)
-    };
-
-    let in_place_impl_generics = de_impl_generics.in_place();
-    let in_place_ty_generics = de_ty_generics.in_place();
-    let place_life = place_lifetime();
-
-    quote_block! {
-        #[doc(hidden)]
-        struct __Visitor #in_place_impl_generics #where_clause {
-            place: &#place_life mut #this_type #ty_generics,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
-            type Value = ();
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #visit_newtype_struct
-
-            #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::#private::Result<Self::Value, __A::Error>
-            where
-                __A: _serde::de::SeqAccess<#delife>,
-            {
-                #visit_seq
-            }
-        }
-
-        #dispatch
-    }
-}

serde_derive/src/de/unit.rs

@@ -1,52 +0,0 @@
-use crate::de::Parameters;
-use crate::fragment::Fragment;
-use crate::internals::attr;
-use crate::private;
-use quote::quote;
-
-/// Generates `Deserialize::deserialize` body for a `struct Unit;`
-pub(super) fn deserialize(params: &Parameters, cattrs: &attr::Container) -> Fragment {
-    let this_type = &params.this_type;
-    let this_value = &params.this_value;
-    let type_name = cattrs.name().deserialize_name();
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        params.generics_with_de_lifetime();
-    let delife = params.borrowed.de_lifetime();
-
-    let expecting = format!("unit struct {}", params.type_name());
-    let expecting = cattrs.expecting().unwrap_or(&expecting);
-
-    quote_block! {
-        #[doc(hidden)]
-        struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::#private::PhantomData<&#delife ()>,
-        }
-
-        #[automatically_derived]
-        impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
-            type Value = #this_type #ty_generics;
-
-            fn expecting(&self, __formatter: &mut _serde::#private::Formatter) -> _serde::#private::fmt::Result {
-                _serde::#private::Formatter::write_str(__formatter, #expecting)
-            }
-
-            #[inline]
-            fn visit_unit<__E>(self) -> _serde::#private::Result<Self::Value, __E>
-            where
-                __E: _serde::de::Error,
-            {
-                _serde::#private::Ok(#this_value)
-            }
-        }
-
-        _serde::Deserializer::deserialize_unit_struct(
-            __deserializer,
-            #type_name,
-            __Visitor {
-                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::#private::PhantomData,
-            },
-        )
-    }
-}

serde_derive/src/deprecated.rs

@@ -1,56 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-
-pub fn allow_deprecated(input: &syn::DeriveInput) -> Option<TokenStream> {
-    if should_allow_deprecated(input) {
-        Some(quote! { #[allow(deprecated)] })
-    } else {
-        None
-    }
-}
-
-/// Determine if an `#[allow(deprecated)]` should be added to the derived impl.
-///
-/// This should happen if the derive input or an enum variant it contains has
-/// one of:
-///   - `#[deprecated]`
-///   - `#[allow(deprecated)]`
-fn should_allow_deprecated(input: &syn::DeriveInput) -> bool {
-    if contains_deprecated(&input.attrs) {
-        return true;
-    }
-    if let syn::Data::Enum(data_enum) = &input.data {
-        for variant in &data_enum.variants {
-            if contains_deprecated(&variant.attrs) {
-                return true;
-            }
-        }
-    }
-    false
-}
-
-/// Check whether the given attributes contains one of:
-///   - `#[deprecated]`
-///   - `#[allow(deprecated)]`
-fn contains_deprecated(attrs: &[syn::Attribute]) -> bool {
-    for attr in attrs {
-        if attr.path().is_ident("deprecated") {
-            return true;
-        }
-        if let syn::Meta::List(meta_list) = &attr.meta {
-            if meta_list.path.is_ident("allow") {
-                let mut allow_deprecated = false;
-                let _ = meta_list.parse_nested_meta(|meta| {
-                    if meta.path.is_ident("deprecated") {
-                        allow_deprecated = true;
-                    }
-                    Ok(())
-                });
-                if allow_deprecated {
-                    return true;
-                }
-            }
-        }
-    }
-    false
-}

serde_derive/src/dummy.rs

@@ -1,31 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-
-pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream {
-    let use_serde = match serde_path {
-        Some(path) => quote! {
-            use #path as _serde;
-        },
-        None => quote! {
-            #[allow(unused_extern_crates, clippy::useless_attribute)]
-            extern crate serde as _serde;
-        },
-    };
-
-    quote! {
-        #[doc(hidden)]
-        #[allow(
-            non_upper_case_globals,
-            unused_attributes,
-            unused_qualifications,
-            clippy::absolute_paths,
-        )]
-        const _: () = {
-            #use_serde
-
-            _serde::__require_serde_not_serde_core!();
-
-            #code
-        };
-    }
-}

serde_derive/src/fragment.rs

@@ -1,74 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-use syn::{token, Token};
-
-pub enum Fragment {
-    /// Tokens that can be used as an expression.
-    Expr(TokenStream),
-    /// Tokens that can be used inside a block. The surrounding curly braces are
-    /// not part of these tokens.
-    Block(TokenStream),
-}
-
-macro_rules! quote_expr {
-    ($($tt:tt)*) => {
-        $crate::fragment::Fragment::Expr(quote!($($tt)*))
-    }
-}
-
-macro_rules! quote_block {
-    ($($tt:tt)*) => {
-        $crate::fragment::Fragment::Block(quote!($($tt)*))
-    }
-}
-
-/// Interpolate a fragment in place of an expression. This involves surrounding
-/// Block fragments in curly braces.
-pub struct Expr(pub Fragment);
-impl ToTokens for Expr {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => expr.to_tokens(out),
-            Fragment::Block(block) => {
-                token::Brace::default().surround(out, |out| block.to_tokens(out));
-            }
-        }
-    }
-}
-
-/// Interpolate a fragment as the statements of a block.
-pub struct Stmts(pub Fragment);
-impl ToTokens for Stmts {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => expr.to_tokens(out),
-            Fragment::Block(block) => block.to_tokens(out),
-        }
-    }
-}
-
-/// Interpolate a fragment as the value part of a `match` expression. This
-/// involves putting a comma after expressions and curly braces around blocks.
-pub struct Match(pub Fragment);
-impl ToTokens for Match {
-    fn to_tokens(&self, out: &mut TokenStream) {
-        match &self.0 {
-            Fragment::Expr(expr) => {
-                expr.to_tokens(out);
-                <Token![,]>::default().to_tokens(out);
-            }
-            Fragment::Block(block) => {
-                token::Brace::default().surround(out, |out| block.to_tokens(out));
-            }
-        }
-    }
-}
-
-impl AsRef<TokenStream> for Fragment {
-    fn as_ref(&self) -> &TokenStream {
-        match self {
-            Fragment::Expr(expr) => expr,
-            Fragment::Block(block) => block,
-        }
-    }
-}

serde_derive/src/internals/ast.rs

@@ -1,218 +0,0 @@
-//! A Serde ast, parsed from the Syn ast and ready to generate Rust code.
-
-use crate::internals::{attr, check, Ctxt, Derive};
-use proc_macro2::Ident;
-use syn::punctuated::Punctuated;
-use syn::Token;
-
-/// A source data structure annotated with `#[derive(Serialize)]` and/or `#[derive(Deserialize)]`,
-/// parsed into an internal representation.
-pub struct Container<'a> {
-    /// The struct or enum name (without generics).
-    pub ident: syn::Ident,
-    /// Attributes on the structure, parsed for Serde.
-    pub attrs: attr::Container,
-    /// The contents of the struct or enum.
-    pub data: Data<'a>,
-    /// Any generics on the struct or enum.
-    pub generics: &'a syn::Generics,
-    /// Original input.
-    pub original: &'a syn::DeriveInput,
-}
-
-/// The fields of a struct or enum.
-///
-/// Analogous to `syn::Data`.
-pub enum Data<'a> {
-    Enum(Vec<Variant<'a>>),
-    Struct(Style, Vec<Field<'a>>),
-}
-
-/// A variant of an enum.
-pub struct Variant<'a> {
-    pub ident: syn::Ident,
-    pub attrs: attr::Variant,
-    pub style: Style,
-    pub fields: Vec<Field<'a>>,
-    pub original: &'a syn::Variant,
-}
-
-/// A field of a struct.
-pub struct Field<'a> {
-    pub member: syn::Member,
-    pub attrs: attr::Field,
-    pub ty: &'a syn::Type,
-    pub original: &'a syn::Field,
-}
-
-#[derive(Copy, Clone)]
-pub enum Style {
-    /// Named fields.
-    Struct,
-    /// Many unnamed fields.
-    Tuple,
-    /// One unnamed field.
-    Newtype,
-    /// No fields.
-    Unit,
-}
-
-impl<'a> Container<'a> {
-    /// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`.
-    pub fn from_ast(
-        cx: &Ctxt,
-        item: &'a syn::DeriveInput,
-        derive: Derive,
-        private: &Ident,
-    ) -> Option<Container<'a>> {
-        let attrs = attr::Container::from_ast(cx, item);
-
-        let mut data = match &item.data {
-            syn::Data::Enum(data) => {
-                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default(), private))
-            }
-            syn::Data::Struct(data) => {
-                let (style, fields) =
-                    struct_from_ast(cx, &data.fields, None, attrs.default(), private);
-                Data::Struct(style, fields)
-            }
-            syn::Data::Union(_) => {
-                cx.error_spanned_by(item, "Serde does not support derive for unions");
-                return None;
-            }
-        };
-
-        match &mut data {
-            Data::Enum(variants) => {
-                for variant in variants {
-                    variant.attrs.rename_by_rules(attrs.rename_all_rules());
-                    for field in &mut variant.fields {
-                        field.attrs.rename_by_rules(
-                            variant
-                                .attrs
-                                .rename_all_rules()
-                                .or(attrs.rename_all_fields_rules()),
-                        );
-                    }
-                }
-            }
-            Data::Struct(_, fields) => {
-                for field in fields {
-                    field.attrs.rename_by_rules(attrs.rename_all_rules());
-                }
-            }
-        }
-
-        let mut item = Container {
-            ident: item.ident.clone(),
-            attrs,
-            data,
-            generics: &item.generics,
-            original: item,
-        };
-        check::check(cx, &mut item, derive);
-        Some(item)
-    }
-}
-
-impl<'a> Data<'a> {
-    pub fn all_fields(&'a self) -> Box<dyn Iterator<Item = &'a Field<'a>> + 'a> {
-        match self {
-            Data::Enum(variants) => {
-                Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
-            }
-            Data::Struct(_, fields) => Box::new(fields.iter()),
-        }
-    }
-
-    pub fn has_getter(&self) -> bool {
-        self.all_fields().any(|f| f.attrs.getter().is_some())
-    }
-}
-
-fn enum_from_ast<'a>(
-    cx: &Ctxt,
-    variants: &'a Punctuated<syn::Variant, Token![,]>,
-    container_default: &attr::Default,
-    private: &Ident,
-) -> Vec<Variant<'a>> {
-    let variants: Vec<Variant> = variants
-        .iter()
-        .map(|variant| {
-            let attrs = attr::Variant::from_ast(cx, variant);
-            let (style, fields) = struct_from_ast(
-                cx,
-                &variant.fields,
-                Some(&attrs),
-                container_default,
-                private,
-            );
-            Variant {
-                ident: variant.ident.clone(),
-                attrs,
-                style,
-                fields,
-                original: variant,
-            }
-        })
-        .collect();
-
-    let index_of_last_tagged_variant = variants
-        .iter()
-        .rposition(|variant| !variant.attrs.untagged());
-    if let Some(index_of_last_tagged_variant) = index_of_last_tagged_variant {
-        for variant in &variants[..index_of_last_tagged_variant] {
-            if variant.attrs.untagged() {
-                cx.error_spanned_by(&variant.ident, "all variants with the #[serde(untagged)] attribute must be placed at the end of the enum");
-            }
-        }
-    }
-
-    variants
-}
-
-fn struct_from_ast<'a>(
-    cx: &Ctxt,
-    fields: &'a syn::Fields,
-    attrs: Option<&attr::Variant>,
-    container_default: &attr::Default,
-    private: &Ident,
-) -> (Style, Vec<Field<'a>>) {
-    match fields {
-        syn::Fields::Named(fields) => (
-            Style::Struct,
-            fields_from_ast(cx, &fields.named, attrs, container_default, private),
-        ),
-        syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
-            Style::Newtype,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default, private),
-        ),
-        syn::Fields::Unnamed(fields) => (
-            Style::Tuple,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default, private),
-        ),
-        syn::Fields::Unit => (Style::Unit, Vec::new()),
-    }
-}
-
-fn fields_from_ast<'a>(
-    cx: &Ctxt,
-    fields: &'a Punctuated<syn::Field, Token![,]>,
-    attrs: Option<&attr::Variant>,
-    container_default: &attr::Default,
-    private: &Ident,
-) -> Vec<Field<'a>> {
-    fields
-        .iter()
-        .enumerate()
-        .map(|(i, field)| Field {
-            member: match &field.ident {
-                Some(ident) => syn::Member::Named(ident.clone()),
-                None => syn::Member::Unnamed(i.into()),
-            },
-            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default, private),
-            ty: &field.ty,
-            original: field,
-        })
-        .collect()
-}

serde_derive/src/internals/case.rs

@@ -1,200 +0,0 @@
-//! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the
-//! case of the source (e.g. `my-field`, `MY_FIELD`).
-
-use self::RenameRule::*;
-use std::fmt::{self, Debug, Display};
-
-/// The different possible ways to change case of fields in a struct, or variants in an enum.
-#[derive(Copy, Clone, PartialEq)]
-pub enum RenameRule {
-    /// Don't apply a default rename rule.
-    None,
-    /// Rename direct children to "lowercase" style.
-    LowerCase,
-    /// Rename direct children to "UPPERCASE" style.
-    UpperCase,
-    /// Rename direct children to "PascalCase" style, as typically used for
-    /// enum variants.
-    PascalCase,
-    /// Rename direct children to "camelCase" style.
-    CamelCase,
-    /// Rename direct children to "snake_case" style, as commonly used for
-    /// fields.
-    SnakeCase,
-    /// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly
-    /// used for constants.
-    ScreamingSnakeCase,
-    /// Rename direct children to "kebab-case" style.
-    KebabCase,
-    /// Rename direct children to "SCREAMING-KEBAB-CASE" style.
-    ScreamingKebabCase,
-}
-
-static RENAME_RULES: &[(&str, RenameRule)] = &[
-    ("lowercase", LowerCase),
-    ("UPPERCASE", UpperCase),
-    ("PascalCase", PascalCase),
-    ("camelCase", CamelCase),
-    ("snake_case", SnakeCase),
-    ("SCREAMING_SNAKE_CASE", ScreamingSnakeCase),
-    ("kebab-case", KebabCase),
-    ("SCREAMING-KEBAB-CASE", ScreamingKebabCase),
-];
-
-impl RenameRule {
-    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
-        for (name, rule) in RENAME_RULES {
-            if rename_all_str == *name {
-                return Ok(*rule);
-            }
-        }
-        Err(ParseError {
-            unknown: rename_all_str,
-        })
-    }
-
-    /// Apply a renaming rule to an enum variant, returning the version expected in the source.
-    pub fn apply_to_variant(self, variant: &str) -> String {
-        match self {
-            None | PascalCase => variant.to_owned(),
-            LowerCase => variant.to_ascii_lowercase(),
-            UpperCase => variant.to_ascii_uppercase(),
-            CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..],
-            SnakeCase => {
-                let mut snake = String::new();
-                for (i, ch) in variant.char_indices() {
-                    if i > 0 && ch.is_uppercase() {
-                        snake.push('_');
-                    }
-                    snake.push(ch.to_ascii_lowercase());
-                }
-                snake
-            }
-            ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
-            KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase
-                .apply_to_variant(variant)
-                .replace('_', "-"),
-        }
-    }
-
-    /// Apply a renaming rule to a struct field, returning the version expected in the source.
-    pub fn apply_to_field(self, field: &str) -> String {
-        match self {
-            None | LowerCase | SnakeCase => field.to_owned(),
-            UpperCase => field.to_ascii_uppercase(),
-            PascalCase => {
-                let mut pascal = String::new();
-                let mut capitalize = true;
-                for ch in field.chars() {
-                    if ch == '_' {
-                        capitalize = true;
-                    } else if capitalize {
-                        pascal.push(ch.to_ascii_uppercase());
-                        capitalize = false;
-                    } else {
-                        pascal.push(ch);
-                    }
-                }
-                pascal
-            }
-            CamelCase => {
-                let pascal = PascalCase.apply_to_field(field);
-                pascal[..1].to_ascii_lowercase() + &pascal[1..]
-            }
-            ScreamingSnakeCase => field.to_ascii_uppercase(),
-            KebabCase => field.replace('_', "-"),
-            ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"),
-        }
-    }
-
-    /// Returns the `RenameRule` if it is not `None`, `rule_b` otherwise.
-    pub fn or(self, rule_b: Self) -> Self {
-        match self {
-            None => rule_b,
-            _ => self,
-        }
-    }
-}
-
-pub struct ParseError<'a> {
-    unknown: &'a str,
-}
-
-impl<'a> Display for ParseError<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("unknown rename rule `rename_all = ")?;
-        Debug::fmt(self.unknown, f)?;
-        f.write_str("`, expected one of ")?;
-        for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
-            if i > 0 {
-                f.write_str(", ")?;
-            }
-            Debug::fmt(name, f)?;
-        }
-        Ok(())
-    }
-}
-
-#[test]
-fn rename_variants() {
-    for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[
-        (
-            "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
-        ),
-        (
-            "VeryTasty",
-            "verytasty",
-            "VERYTASTY",
-            "veryTasty",
-            "very_tasty",
-            "VERY_TASTY",
-            "very-tasty",
-            "VERY-TASTY",
-        ),
-        ("A", "a", "A", "a", "a", "A", "a", "A"),
-        ("Z42", "z42", "Z42", "z42", "z42", "Z42", "z42", "Z42"),
-    ] {
-        assert_eq!(None.apply_to_variant(original), original);
-        assert_eq!(LowerCase.apply_to_variant(original), lower);
-        assert_eq!(UpperCase.apply_to_variant(original), upper);
-        assert_eq!(PascalCase.apply_to_variant(original), original);
-        assert_eq!(CamelCase.apply_to_variant(original), camel);
-        assert_eq!(SnakeCase.apply_to_variant(original), snake);
-        assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
-        assert_eq!(KebabCase.apply_to_variant(original), kebab);
-        assert_eq!(
-            ScreamingKebabCase.apply_to_variant(original),
-            screaming_kebab
-        );
-    }
-}
-
-#[test]
-fn rename_fields() {
-    for &(original, upper, pascal, camel, screaming, kebab, screaming_kebab) in &[
-        (
-            "outcome", "OUTCOME", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
-        ),
-        (
-            "very_tasty",
-            "VERY_TASTY",
-            "VeryTasty",
-            "veryTasty",
-            "VERY_TASTY",
-            "very-tasty",
-            "VERY-TASTY",
-        ),
-        ("a", "A", "A", "a", "A", "a", "A"),
-        ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
-    ] {
-        assert_eq!(None.apply_to_field(original), original);
-        assert_eq!(UpperCase.apply_to_field(original), upper);
-        assert_eq!(PascalCase.apply_to_field(original), pascal);
-        assert_eq!(CamelCase.apply_to_field(original), camel);
-        assert_eq!(SnakeCase.apply_to_field(original), original);
-        assert_eq!(ScreamingSnakeCase.apply_to_field(original), screaming);
-        assert_eq!(KebabCase.apply_to_field(original), kebab);
-        assert_eq!(ScreamingKebabCase.apply_to_field(original), screaming_kebab);
-    }
-}

serde_derive/src/internals/check.rs

@@ -1,477 +0,0 @@
-use crate::internals::ast::{Container, Data, Field, Style};
-use crate::internals::attr::{Default, Identifier, TagType};
-use crate::internals::{ungroup, Ctxt, Derive};
-use syn::{Member, Type};
-
-// Cross-cutting checks that require looking at more than a single attrs object.
-// Simpler checks should happen when parsing and building the attrs.
-pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
-    check_default_on_tuple(cx, cont);
-    check_remote_generic(cx, cont);
-    check_getter(cx, cont);
-    check_flatten(cx, cont);
-    check_identifier(cx, cont);
-    check_variant_skip_attrs(cx, cont);
-    check_internal_tag_field_name_conflict(cx, cont);
-    check_adjacent_tag_conflict(cx, cont);
-    check_transparent(cx, cont, derive);
-    check_from_and_try_from(cx, cont);
-}
-
-// If some field of a tuple struct is marked #[serde(default)] then all fields
-// after it must also be marked with that attribute, or the struct must have a
-// container-level serde(default) attribute. A field's default value is only
-// used for tuple fields if the sequence is exhausted at that point; that means
-// all subsequent fields will fail to deserialize if they don't have their own
-// default.
-fn check_default_on_tuple(cx: &Ctxt, cont: &Container) {
-    if let Default::None = cont.attrs.default() {
-        if let Data::Struct(Style::Tuple, fields) = &cont.data {
-            let mut first_default_index = None;
-            for (i, field) in fields.iter().enumerate() {
-                // Skipped fields automatically get the #[serde(default)]
-                // attribute. We are interested only on non-skipped fields here.
-                if field.attrs.skip_deserializing() {
-                    continue;
-                }
-                if let Default::None = field.attrs.default() {
-                    if let Some(first) = first_default_index {
-                        cx.error_spanned_by(
-                            field.ty,
-                            format!("field must have #[serde(default)] because previous field {} has #[serde(default)]", first),
-                        );
-                    }
-                    continue;
-                }
-                if first_default_index.is_none() {
-                    first_default_index = Some(i);
-                }
-            }
-        }
-    }
-}
-
-// Remote derive definition type must have either all of the generics of the
-// remote type:
-//
-//     #[serde(remote = "Generic")]
-//     struct Generic<T> {…}
-//
-// or none of them, i.e. defining impls for one concrete instantiation of the
-// remote type only:
-//
-//     #[serde(remote = "Generic<T>")]
-//     struct ConcreteDef {…}
-//
-fn check_remote_generic(cx: &Ctxt, cont: &Container) {
-    if let Some(remote) = cont.attrs.remote() {
-        let local_has_generic = !cont.generics.params.is_empty();
-        let remote_has_generic = !remote.segments.last().unwrap().arguments.is_none();
-        if local_has_generic && remote_has_generic {
-            cx.error_spanned_by(remote, "remove generic parameters from this path");
-        }
-    }
-}
-
-// Getters are only allowed inside structs (not enums) with the `remote`
-// attribute.
-fn check_getter(cx: &Ctxt, cont: &Container) {
-    match cont.data {
-        Data::Enum(_) => {
-            if cont.data.has_getter() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(getter = \"...\")] is not allowed in an enum",
-                );
-            }
-        }
-        Data::Struct(_, _) => {
-            if cont.data.has_getter() && cont.attrs.remote().is_none() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(getter = \"...\")] can only be used in structs that have #[serde(remote = \"...\")]",
-                );
-            }
-        }
-    }
-}
-
-// Flattening has some restrictions we can test.
-fn check_flatten(cx: &Ctxt, cont: &Container) {
-    match &cont.data {
-        Data::Enum(variants) => {
-            for variant in variants {
-                for field in &variant.fields {
-                    check_flatten_field(cx, variant.style, field);
-                }
-            }
-        }
-        Data::Struct(style, fields) => {
-            for field in fields {
-                check_flatten_field(cx, *style, field);
-            }
-        }
-    }
-}
-
-fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
-    if !field.attrs.flatten() {
-        return;
-    }
-    match style {
-        Style::Tuple => {
-            cx.error_spanned_by(
-                field.original,
-                "#[serde(flatten)] cannot be used on tuple structs",
-            );
-        }
-        Style::Newtype => {
-            cx.error_spanned_by(
-                field.original,
-                "#[serde(flatten)] cannot be used on newtype structs",
-            );
-        }
-        _ => {}
-    }
-}
-
-// The `other` attribute must be used at most once and it must be the last
-// variant of an enum.
-//
-// Inside a `variant_identifier` all variants must be unit variants. Inside a
-// `field_identifier` all but possibly one variant must be unit variants. The
-// last variant may be a newtype variant which is an implicit "other" case.
-fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => return,
-    };
-
-    for (i, variant) in variants.iter().enumerate() {
-        match (
-            variant.style,
-            cont.attrs.identifier(),
-            variant.attrs.other(),
-            cont.attrs.tag(),
-        ) {
-            // The `other` attribute may not be used in a variant_identifier.
-            (_, Identifier::Variant, true, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] may not be used on a variant identifier",
-                );
-            }
-
-            // Variant with `other` attribute cannot appear in untagged enum
-            (_, Identifier::No, true, &TagType::None) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] cannot appear on untagged enum",
-                );
-            }
-
-            // Variant with `other` attribute must be the last one.
-            (Style::Unit, Identifier::Field, true, _) | (Style::Unit, Identifier::No, true, _) => {
-                if i < variants.len() - 1 {
-                    cx.error_spanned_by(
-                        variant.original,
-                        "#[serde(other)] must be on the last variant",
-                    );
-                }
-            }
-
-            // Variant with `other` attribute must be a unit variant.
-            (_, Identifier::Field, true, _) | (_, Identifier::No, true, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(other)] must be on a unit variant",
-                );
-            }
-
-            // Any sort of variant is allowed if this is not an identifier.
-            (_, Identifier::No, false, _) => {}
-
-            // Unit variant without `other` attribute is always fine.
-            (Style::Unit, _, false, _) => {}
-
-            // The last field is allowed to be a newtype catch-all.
-            (Style::Newtype, Identifier::Field, false, _) => {
-                if i < variants.len() - 1 {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!("`{}` must be the last variant", variant.ident),
-                    );
-                }
-            }
-
-            (_, Identifier::Field, false, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(field_identifier)] may only contain unit variants",
-                );
-            }
-
-            (_, Identifier::Variant, false, _) => {
-                cx.error_spanned_by(
-                    variant.original,
-                    "#[serde(variant_identifier)] may only contain unit variants",
-                );
-            }
-        }
-    }
-}
-
-// Skip-(de)serializing attributes are not allowed on variants marked
-// (de)serialize_with.
-fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => return,
-    };
-
-    for variant in variants {
-        if variant.attrs.serialize_with().is_some() {
-            if variant.attrs.skip_serializing() {
-                cx.error_spanned_by(
-                    variant.original,
-                    format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]",
-                        variant.ident
-                    ),
-                );
-            }
-
-            for field in &variant.fields {
-                let member = member_message(&field.member);
-
-                if field.attrs.skip_serializing() {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-
-                if field.attrs.skip_serializing_if().is_some() {
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(serialize_with)] and a field {} marked with #[serde(skip_serializing_if)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-            }
-        }
-
-        if variant.attrs.deserialize_with().is_some() {
-            if variant.attrs.skip_deserializing() {
-                cx.error_spanned_by(
-                    variant.original,
-                    format!(
-                        "variant `{}` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]",
-                        variant.ident
-                    ),
-                );
-            }
-
-            for field in &variant.fields {
-                if field.attrs.skip_deserializing() {
-                    let member = member_message(&field.member);
-
-                    cx.error_spanned_by(
-                        variant.original,
-                        format!(
-                            "variant `{}` cannot have both #[serde(deserialize_with)] and a field {} marked with #[serde(skip_deserializing)]",
-                            variant.ident, member
-                        ),
-                    );
-                }
-            }
-        }
-    }
-}
-
-// The tag of an internally-tagged struct variant must not be the same as either
-// one of its fields, as this would result in duplicate keys in the serialized
-// output and/or ambiguity in the to-be-deserialized input.
-fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => return,
-    };
-
-    let tag = match cont.attrs.tag() {
-        TagType::Internal { tag } => tag.as_str(),
-        TagType::External | TagType::Adjacent { .. } | TagType::None => return,
-    };
-
-    let diagnose_conflict = || {
-        cx.error_spanned_by(
-            cont.original,
-            format!("variant field name `{}` conflicts with internal tag", tag),
-        );
-    };
-
-    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());
-                    let check_de =
-                        !(field.attrs.skip_deserializing() || variant.attrs.skip_deserializing());
-                    let name = field.attrs.name();
-                    let ser_name = name.serialize_name();
-
-                    if check_ser && ser_name.value == tag {
-                        diagnose_conflict();
-                        return;
-                    }
-
-                    for de_name in field.attrs.aliases() {
-                        if check_de && de_name.value == tag {
-                            diagnose_conflict();
-                            return;
-                        }
-                    }
-                }
-            }
-            Style::Unit | Style::Newtype | Style::Tuple => {}
-        }
-    }
-}
-
-// In the case of adjacently-tagged enums, the type and the contents tag must
-// differ, for the same reason.
-fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
-    let (type_tag, content_tag) = match cont.attrs.tag() {
-        TagType::Adjacent { tag, content } => (tag, content),
-        TagType::Internal { .. } | TagType::External | TagType::None => return,
-    };
-
-    if type_tag == content_tag {
-        cx.error_spanned_by(
-            cont.original,
-            format!(
-                "enum tags `{}` for type and content conflict with each other",
-                type_tag
-            ),
-        );
-    }
-}
-
-// Enums and unit structs cannot be transparent.
-fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
-    if !cont.attrs.transparent() {
-        return;
-    }
-
-    if cont.attrs.type_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(from = \"...\")]",
-        );
-    }
-
-    if cont.attrs.type_try_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(try_from = \"...\")]",
-        );
-    }
-
-    if cont.attrs.type_into().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(transparent)] is not allowed with #[serde(into = \"...\")]",
-        );
-    }
-
-    let fields = match &mut cont.data {
-        Data::Enum(_) => {
-            cx.error_spanned_by(
-                cont.original,
-                "#[serde(transparent)] is not allowed on an enum",
-            );
-            return;
-        }
-        Data::Struct(Style::Unit, _) => {
-            cx.error_spanned_by(
-                cont.original,
-                "#[serde(transparent)] is not allowed on a unit struct",
-            );
-            return;
-        }
-        Data::Struct(_, fields) => fields,
-    };
-
-    let mut transparent_field = None;
-
-    for field in fields {
-        if allow_transparent(field, derive) {
-            if transparent_field.is_some() {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires struct to have at most one transparent field",
-                );
-                return;
-            }
-            transparent_field = Some(field);
-        }
-    }
-
-    match transparent_field {
-        Some(transparent_field) => transparent_field.attrs.mark_transparent(),
-        None => match derive {
-            Derive::Serialize => {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires at least one field that is not skipped",
-                );
-            }
-            Derive::Deserialize => {
-                cx.error_spanned_by(
-                    cont.original,
-                    "#[serde(transparent)] requires at least one field that is neither skipped nor has a default",
-                );
-            }
-        },
-    }
-}
-
-fn member_message(member: &Member) -> String {
-    match member {
-        Member::Named(ident) => format!("`{}`", ident),
-        Member::Unnamed(i) => format!("#{}", i.index),
-    }
-}
-
-fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ty) = ungroup(field.ty) {
-        if let Some(seg) = ty.path.segments.last() {
-            if seg.ident == "PhantomData" {
-                return false;
-            }
-        }
-    }
-
-    match derive {
-        Derive::Serialize => !field.attrs.skip_serializing(),
-        Derive::Deserialize => !field.attrs.skip_deserializing() && field.attrs.default().is_none(),
-    }
-}
-
-fn check_from_and_try_from(cx: &Ctxt, cont: &mut Container) {
-    if cont.attrs.type_from().is_some() && cont.attrs.type_try_from().is_some() {
-        cx.error_spanned_by(
-            cont.original,
-            "#[serde(from = \"...\")] and #[serde(try_from = \"...\")] conflict with each other",
-        );
-    }
-}

serde_derive/src/internals/ctxt.rs

@@ -1,67 +0,0 @@
-use quote::ToTokens;
-use std::cell::RefCell;
-use std::fmt::Display;
-use std::thread;
-
-/// A type to collect errors together and format them.
-///
-/// Dropping this object will cause a panic. It must be consumed using `check`.
-///
-/// References can be shared since this type uses run-time exclusive mut checking.
-#[derive(Default)]
-pub struct Ctxt {
-    // The contents will be set to `None` during checking. This is so that checking can be
-    // enforced.
-    errors: RefCell<Option<Vec<syn::Error>>>,
-}
-
-impl Ctxt {
-    /// Create a new context object.
-    ///
-    /// This object contains no errors, but will still trigger a panic if it is not `check`ed.
-    pub fn new() -> Self {
-        Ctxt {
-            errors: RefCell::new(Some(Vec::new())),
-        }
-    }
-
-    /// Add an error to the context object with a tokenenizable object.
-    ///
-    /// The object is used for spanning in error messages.
-    pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
-        self.errors
-            .borrow_mut()
-            .as_mut()
-            .unwrap()
-            // Curb monomorphization from generating too many identical methods.
-            .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
-    }
-
-    /// Add one of Syn's parse errors.
-    pub fn syn_error(&self, err: syn::Error) {
-        self.errors.borrow_mut().as_mut().unwrap().push(err);
-    }
-
-    /// Consume this object, producing a formatted error string if there are errors.
-    pub fn check(self) -> syn::Result<()> {
-        let mut errors = self.errors.borrow_mut().take().unwrap().into_iter();
-
-        let Some(mut combined) = errors.next() else {
-            return Ok(());
-        };
-
-        for rest in errors {
-            combined.combine(rest);
-        }
-
-        Err(combined)
-    }
-}
-
-impl Drop for Ctxt {
-    fn drop(&mut self) {
-        if !thread::panicking() && self.errors.borrow().is_some() {
-            panic!("forgot to check for errors");
-        }
-    }
-}

serde_derive/src/internals/mod.rs

@@ -1,28 +0,0 @@
-pub mod ast;
-pub mod attr;
-pub mod name;
-
-mod case;
-mod check;
-mod ctxt;
-mod receiver;
-mod respan;
-mod symbol;
-
-use syn::Type;
-
-pub use self::ctxt::Ctxt;
-pub use self::receiver::replace_receiver;
-
-#[derive(Copy, Clone)]
-pub enum Derive {
-    Serialize,
-    Deserialize,
-}
-
-pub fn ungroup(mut ty: &Type) -> &Type {
-    while let Type::Group(group) = ty {
-        ty = &group.elem;
-    }
-    ty
-}

serde_derive/src/internals/name.rs

@@ -1,113 +0,0 @@
-use crate::internals::attr::{Attr, VecAttr};
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::ToTokens;
-use std::cmp::Ordering;
-use std::collections::BTreeSet;
-use std::fmt::{self, Display};
-use syn::LitStr;
-
-pub struct MultiName {
-    pub(crate) serialize: Name,
-    pub(crate) serialize_renamed: bool,
-    pub(crate) deserialize: Name,
-    pub(crate) deserialize_renamed: bool,
-    pub(crate) deserialize_aliases: BTreeSet<Name>,
-}
-
-impl MultiName {
-    pub(crate) fn from_attrs(
-        source_name: Name,
-        ser_name: Attr<Name>,
-        de_name: Attr<Name>,
-        de_aliases: Option<VecAttr<Name>>,
-    ) -> Self {
-        let mut alias_set = BTreeSet::new();
-        if let Some(de_aliases) = de_aliases {
-            for alias_name in de_aliases.get() {
-                alias_set.insert(alias_name);
-            }
-        }
-
-        let ser_name = ser_name.get();
-        let ser_renamed = ser_name.is_some();
-        let de_name = de_name.get();
-        let de_renamed = de_name.is_some();
-        MultiName {
-            serialize: ser_name.unwrap_or_else(|| source_name.clone()),
-            serialize_renamed: ser_renamed,
-            deserialize: de_name.unwrap_or(source_name),
-            deserialize_renamed: de_renamed,
-            deserialize_aliases: alias_set,
-        }
-    }
-
-    /// Return the container name for the container when serializing.
-    pub fn serialize_name(&self) -> &Name {
-        &self.serialize
-    }
-
-    /// Return the container name for the container when deserializing.
-    pub fn deserialize_name(&self) -> &Name {
-        &self.deserialize
-    }
-
-    pub(crate) fn deserialize_aliases(&self) -> &BTreeSet<Name> {
-        &self.deserialize_aliases
-    }
-}
-
-#[derive(Clone)]
-pub struct Name {
-    pub value: String,
-    pub span: Span,
-}
-
-impl ToTokens for Name {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        LitStr::new(&self.value, self.span).to_tokens(tokens);
-    }
-}
-
-impl Ord for Name {
-    fn cmp(&self, other: &Self) -> Ordering {
-        Ord::cmp(&self.value, &other.value)
-    }
-}
-
-impl PartialOrd for Name {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(Ord::cmp(self, other))
-    }
-}
-
-impl Eq for Name {}
-
-impl PartialEq for Name {
-    fn eq(&self, other: &Self) -> bool {
-        self.value == other.value
-    }
-}
-
-impl From<&Ident> for Name {
-    fn from(ident: &Ident) -> Self {
-        Name {
-            value: ident.to_string(),
-            span: ident.span(),
-        }
-    }
-}
-
-impl From<&LitStr> for Name {
-    fn from(lit: &LitStr) -> Self {
-        Name {
-            value: lit.value(),
-            span: lit.span(),
-        }
-    }
-}
-
-impl Display for Name {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&self.value, formatter)
-    }
-}