SYMBOL INDEX (2524 symbols across 197 files)

FILE: serde/build.rs
  constant PRIVATE (line 7) | const PRIVATE: &str = "\
  function main (line 19) | fn main() {
  function rustc_minor_version (line 60) | fn rustc_minor_version() -> Option<u32> {

FILE: serde/src/private/de.rs
  function missing_field (line 24) | pub fn missing_field<'de, V, E>(field: &'static str) -> Result<V, E>
  function borrow_cow_str (line 64) | pub fn borrow_cow_str<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R, D...
  function borrow_cow_bytes (line 138) | pub fn borrow_cow_bytes<'de: 'a, 'a, D, R>(deserializer: D) -> Result<R,...
  function content_as_str (line 222) | pub fn content_as_str<'a, 'de>(content: &'a Content<'de>) -> Option<&'a ...
  function content_clone (line 232) | fn content_clone<'de>(content: &Content<'de>) -> Content<'de> {
  function content_unexpected (line 264) | fn content_unexpected<'a, 'de>(content: &'a Content<'de>) -> Unexpected<...
  type ContentVisitor (line 290) | pub struct ContentVisitor<'de> {
  function new (line 295) | pub fn new() -> Self {
  type Value (line 302) | type Value = Content<'de>;
  function deserialize (line 304) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  type Value (line 314) | type Value = Content<'de>;
  function expecting (line 316) | fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  function visit_bool (line 320) | fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
  function visit_i8 (line 327) | fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
  function visit_i16 (line 334) | fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
  function visit_i32 (line 341) | fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
  function visit_i64 (line 348) | fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
  function visit_u8 (line 355) | fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
  function visit_u16 (line 362) | fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
  function visit_u32 (line 369) | fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
  function visit_u64 (line 376) | fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
  function visit_f32 (line 383) | fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
  function visit_f64 (line 390) | fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
  function visit_char (line 397) | fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
  function visit_str (line 404) | fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
  function visit_borrowed_str (line 411) | fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
  function visit_string (line 418) | fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
  function visit_bytes (line 425) | fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
  function visit_borrowed_bytes (line 432) | fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value...
  function visit_byte_buf (line 439) | fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
  function visit_unit (line 446) | fn visit_unit<F>(self) -> Result<Self::Value, F>
  function visit_none (line 453) | fn visit_none<F>(self) -> Result<Self::Value, F>
  function visit_some (line 460) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  function visit_newtype_struct (line 468) | fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value,...
  function visit_seq (line 476) | fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
  function visit_map (line 488) | fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
  function visit_enum (line 504) | fn visit_enum<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
  type TagOrContent (line 517) | pub enum TagOrContent<'de> {
  type TagOrContentVisitor (line 524) | struct TagOrContentVisitor<'de> {
  function new (line 530) | fn new(name: &'static str) -> Self {
  type Value (line 540) | type Value = TagOrContent<'de>;
  function deserialize (line 542) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  type Value (line 554) | type Value = TagOrContent<'de>;
  function expecting (line 556) | fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  function visit_bool (line 560) | fn visit_bool<F>(self, value: bool) -> Result<Self::Value, F>
  function visit_i8 (line 569) | fn visit_i8<F>(self, value: i8) -> Result<Self::Value, F>
  function visit_i16 (line 578) | fn visit_i16<F>(self, value: i16) -> Result<Self::Value, F>
  function visit_i32 (line 587) | fn visit_i32<F>(self, value: i32) -> Result<Self::Value, F>
  function visit_i64 (line 596) | fn visit_i64<F>(self, value: i64) -> Result<Self::Value, F>
  function visit_u8 (line 605) | fn visit_u8<F>(self, value: u8) -> Result<Self::Value, F>
  function visit_u16 (line 614) | fn visit_u16<F>(self, value: u16) -> Result<Self::Value, F>
  function visit_u32 (line 623) | fn visit_u32<F>(self, value: u32) -> Result<Self::Value, F>
  function visit_u64 (line 632) | fn visit_u64<F>(self, value: u64) -> Result<Self::Value, F>
  function visit_f32 (line 641) | fn visit_f32<F>(self, value: f32) -> Result<Self::Value, F>
  function visit_f64 (line 650) | fn visit_f64<F>(self, value: f64) -> Result<Self::Value, F>
  function visit_char (line 659) | fn visit_char<F>(self, value: char) -> Result<Self::Value, F>
  function visit_str (line 668) | fn visit_str<F>(self, value: &str) -> Result<Self::Value, F>
  function visit_borrowed_str (line 681) | fn visit_borrowed_str<F>(self, value: &'de str) -> Result<Self::Value, F>
  function visit_string (line 694) | fn visit_string<F>(self, value: String) -> Result<Self::Value, F>
  function visit_bytes (line 707) | fn visit_bytes<F>(self, value: &[u8]) -> Result<Self::Value, F>
  function visit_borrowed_bytes (line 720) | fn visit_borrowed_bytes<F>(self, value: &'de [u8]) -> Result<Self::Value...
  function visit_byte_buf (line 733) | fn visit_byte_buf<F>(self, value: Vec<u8>) -> Result<Self::Value, F>
  function visit_unit (line 746) | fn visit_unit<F>(self) -> Result<Self::Value, F>
  function visit_none (line 755) | fn visit_none<F>(self) -> Result<Self::Value, F>
  function visit_some (line 764) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  function visit_newtype_struct (line 773) | fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value,...
  function visit_seq (line 782) | fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
  function visit_map (line 791) | fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
  function visit_enum (line 800) | fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
  type TaggedContentVisitor (line 816) | pub struct TaggedContentVisitor<T> {
  function new (line 825) | pub fn new(name: &'static str, expecting: &'static str) -> Self {
  type Value (line 839) | type Value = (T, Content<'de>);
  function expecting (line 841) | fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 845) | fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
  function visit_map (line 859) | fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
  type TagOrContentField (line 892) | pub enum TagOrContentField {
  type TagOrContentFieldVisitor (line 898) | pub struct TagOrContentFieldVisitor {
    type Value (line 907) | type Value = TagOrContentField;
    method deserialize (line 909) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    type Value (line 919) | type Value = TagOrContentField;
    method expecting (line 921) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_u64 (line 925) | fn visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E>
    method visit_str (line 939) | fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
    method visit_bytes (line 952) | fn visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E>
  type TagContentOtherField (line 970) | pub enum TagContentOtherField {
  type TagContentOtherFieldVisitor (line 977) | pub struct TagContentOtherFieldVisitor {
    type Value (line 986) | type Value = TagContentOtherField;
    method deserialize (line 988) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    type Value (line 998) | type Value = TagContentOtherField;
    method expecting (line 1000) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_u64 (line 1008) | fn visit_u64<E>(self, field_index: u64) -> Result<Self::Value, E>
    method visit_str (line 1019) | fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
    method visit_bytes (line 1026) | fn visit_bytes<E>(self, field: &[u8]) -> Result<Self::Value, E>
  type ContentDeserializer (line 1041) | pub struct ContentDeserializer<'de, E> {
  function invalid_type (line 1051) | fn invalid_type(self, exp: &dyn Expected) -> E {
  function deserialize_integer (line 1055) | fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
  function deserialize_float (line 1072) | fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
  function visit_content_seq (line 1092) | fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) ...
  function visit_content_map (line 1103) | fn visit_content_map<'de, V, E>(
  type Error (line 1124) | type Error = E;
  function deserialize_any (line 1126) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bool (line 1156) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i8 (line 1166) | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i16 (line 1173) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i32 (line 1180) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i64 (line 1187) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u8 (line 1194) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u16 (line 1201) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u32 (line 1208) | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u64 (line 1215) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f32 (line 1222) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f64 (line 1229) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_char (line 1236) | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_str (line 1248) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_string (line 1255) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bytes (line 1268) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_byte_buf (line 1275) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::E...
  function deserialize_option (line 1289) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit (line 1301) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 1322) | fn deserialize_unit_struct<V>(
  function deserialize_newtype_struct (line 1351) | fn deserialize_newtype_struct<V>(
  function deserialize_seq (line 1365) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 1375) | fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Valu...
  function deserialize_tuple_struct (line 1382) | fn deserialize_tuple_struct<V>(
  function deserialize_map (line 1394) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_struct (line 1404) | fn deserialize_struct<V>(
  function deserialize_enum (line 1420) | fn deserialize_enum<V>(
  function deserialize_identifier (line 1462) | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self:...
  function deserialize_ignored_any (line 1477) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self...
  function __deserialize_content_v1 (line 1485) | fn __deserialize_content_v1<V>(self, visitor: V) -> Result<V::Value, Sel...
  function new (line 1496) | pub fn new(content: Content<'de>) -> Self {
  type SeqDeserializer (line 1504) | struct SeqDeserializer<'de, E> {
  function new (line 1511) | fn new(content: Vec<Content<'de>>) -> Self {
  function end (line 1524) | fn end(self) -> Result<(), E> {
  type Error (line 1544) | type Error = E;
  function deserialize_any (line 1546) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  type Error (line 1567) | type Error = E;
  function next_element_seed (line 1569) | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, ...
  function size_hint (line 1582) | fn size_hint(&self) -> Option<usize> {
  type ExpectedInSeq (line 1587) | struct ExpectedInSeq(usize);
  method fmt (line 1591) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type MapDeserializer (line 1600) | struct MapDeserializer<'de, E> {
  function new (line 1608) | fn new(content: Vec<(Content<'de>, Content<'de>)>) -> Self {
  function end (line 1622) | fn end(self) -> Result<(), E> {
  function next_pair (line 1638) | fn next_pair(&mut self) -> Option<(Content<'de>, Content<'de>)> {
  type Error (line 1654) | type Error = E;
  function deserialize_any (line 1656) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_seq (line 1665) | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_tuple (line 1674) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type Error (line 1694) | type Error = E;
  function next_key_seed (line 1696) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 1709) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  function next_entry_seed (line 1720) | fn next_entry_seed<TK, TV>(
  function size_hint (line 1739) | fn size_hint(&self) -> Option<usize> {
  type Error (line 1749) | type Error = E;
  function next_element_seed (line 1751) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 1764) | fn size_hint(&self) -> Option<usize> {
  type PairDeserializer (line 1769) | struct PairDeserializer<'de, E>(Content<'de>, Content<'de>, PhantomData<...
  type Error (line 1776) | type Error = E;
  function deserialize_any (line 1784) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_seq (line 1791) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 1807) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type PairVisitor (line 1821) | struct PairVisitor<'de, E>(Option<Content<'de>>, Option<Content<'de>>, P...
  type Error (line 1828) | type Error = E;
  function next_element_seed (line 1830) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 1843) | fn size_hint(&self) -> Option<usize> {
  type ExpectedInMap (line 1854) | struct ExpectedInMap(usize);
  method fmt (line 1858) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type EnumDeserializer (line 1867) | pub struct EnumDeserializer<'de, E>
  function new (line 1880) | pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDe...
  type Error (line 1894) | type Error = E;
  type Variant (line 1895) | type Variant = VariantDeserializer<'de, Self::Error>;
  function variant_seed (line 1897) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), E>
  type VariantDeserializer (line 1910) | pub struct VariantDeserializer<'de, E>
  type Error (line 1923) | type Error = E;
  function unit_variant (line 1925) | fn unit_variant(self) -> Result<(), E> {
  function newtype_variant_seed (line 1932) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
  function tuple_variant (line 1945) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, S...
  function struct_variant (line 1964) | fn struct_variant<V>(
  type ContentRefDeserializer (line 1992) | pub struct ContentRefDeserializer<'a, 'de: 'a, E> {
  function invalid_type (line 2002) | fn invalid_type(self, exp: &dyn Expected) -> E {
  function deserialize_integer (line 2006) | fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
  function deserialize_float (line 2023) | fn deserialize_float<V>(self, visitor: V) -> Result<V::Value, E>
  function visit_content_seq_ref (line 2043) | fn visit_content_seq_ref<'a, 'de, V, E>(
  function visit_content_map_ref (line 2057) | fn visit_content_map_ref<'a, 'de, V, E>(
  type Error (line 2078) | type Error = E;
  function deserialize_any (line 2080) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, E>
  function deserialize_bool (line 2112) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i8 (line 2122) | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i16 (line 2129) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i32 (line 2136) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_i64 (line 2143) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u8 (line 2150) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u16 (line 2157) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u32 (line 2164) | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_u64 (line 2171) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f32 (line 2178) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_f64 (line 2185) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_char (line 2192) | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_str (line 2204) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_string (line 2217) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_bytes (line 2224) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_byte_buf (line 2238) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::E...
  function deserialize_option (line 2245) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
  function deserialize_unit (line 2266) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 2276) | fn deserialize_unit_struct<V>(
  function deserialize_newtype_struct (line 2287) | fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Resul...
  function deserialize_seq (line 2310) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 2320) | fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Valu...
  function deserialize_tuple_struct (line 2327) | fn deserialize_tuple_struct<V>(
  function deserialize_map (line 2339) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_struct (line 2349) | fn deserialize_struct<V>(
  function deserialize_enum (line 2365) | fn deserialize_enum<V>(
  function deserialize_identifier (line 2411) | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self:...
  function deserialize_ignored_any (line 2426) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self...
  function __deserialize_content_v1 (line 2433) | fn __deserialize_content_v1<V>(self, visitor: V) -> Result<V::Value, Sel...
  function new (line 2444) | pub fn new(content: &'a Content<'de>) -> Self {
  method clone (line 2457) | fn clone(&self) -> Self {
  type SeqRefDeserializer (line 2462) | struct SeqRefDeserializer<'a, 'de, E> {
  function new (line 2469) | fn new(content: &'a [Content<'de>]) -> Self {
  function end (line 2482) | fn end(self) -> Result<(), E> {
  type Error (line 2502) | type Error = E;
  function deserialize_any (line 2504) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  type Error (line 2525) | type Error = E;
  function next_element_seed (line 2527) | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, ...
  function size_hint (line 2541) | fn size_hint(&self) -> Option<usize> {
  type MapRefDeserializer (line 2546) | struct MapRefDeserializer<'a, 'de, E> {
  function new (line 2554) | fn new(content: &'a [(Content<'de>, Content<'de>)]) -> Self {
  function end (line 2568) | fn end(self) -> Result<(), E> {
  function next_pair (line 2584) | fn next_pair(&mut self) -> Option<(&'a Content<'de>, &'a Content<'de>)> {
  type Error (line 2600) | type Error = E;
  function deserialize_any (line 2602) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_seq (line 2611) | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_tuple (line 2620) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type Error (line 2640) | type Error = E;
  function next_key_seed (line 2642) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 2655) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  function next_entry_seed (line 2666) | fn next_entry_seed<TK, TV>(
  function size_hint (line 2685) | fn size_hint(&self) -> Option<usize> {
  type Error (line 2695) | type Error = E;
  function next_element_seed (line 2697) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 2710) | fn size_hint(&self) -> Option<usize> {
  type PairRefDeserializer (line 2715) | struct PairRefDeserializer<'a, 'de, E>(&'a Content<'de>, &'a Content<'de...
  type Error (line 2722) | type Error = E;
  function deserialize_any (line 2730) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_seq (line 2737) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 2753) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type PairRefVisitor (line 2767) | struct PairRefVisitor<'a, 'de, E>(
  type Error (line 2778) | type Error = E;
  function next_element_seed (line 2780) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 2793) | fn size_hint(&self) -> Option<usize> {
  type EnumRefDeserializer (line 2804) | struct EnumRefDeserializer<'a, 'de: 'a, E>
  type Error (line 2818) | type Error = E;
  type Variant (line 2819) | type Variant = VariantRefDeserializer<'a, 'de, Self::Error>;
  function variant_seed (line 2821) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), S...
  type VariantRefDeserializer (line 2834) | struct VariantRefDeserializer<'a, 'de: 'a, E>
  type Error (line 2847) | type Error = E;
  function unit_variant (line 2849) | fn unit_variant(self) -> Result<(), E> {
  function newtype_variant_seed (line 2860) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, E>
  function tuple_variant (line 2878) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, S...
  function struct_variant (line 2901) | fn struct_variant<V>(
  type Deserializer (line 2934) | type Deserializer = Self;
  function into_deserializer (line 2936) | fn into_deserializer(self) -> Self {
  type Deserializer (line 2946) | type Deserializer = Self;
  function into_deserializer (line 2948) | fn into_deserializer(self) -> Self {
  type InternallyTaggedUnitVisitor (line 2956) | pub struct InternallyTaggedUnitVisitor<'a> {
  function new (line 2963) | pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
  type Value (line 2973) | type Value = ();
  function expecting (line 2975) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 2983) | fn visit_seq<S>(self, _: S) -> Result<(), S::Error>
  function visit_map (line 2990) | fn visit_map<M>(self, mut access: M) -> Result<(), M::Error>
  type UntaggedUnitVisitor (line 3002) | pub struct UntaggedUnitVisitor<'a> {
  function new (line 3009) | pub fn new(type_name: &'a str, variant_name: &'a str) -> Self {
  type Value (line 3019) | type Value = ();
  function expecting (line 3021) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_unit (line 3029) | fn visit_unit<E>(self) -> Result<(), E>
  function visit_none (line 3036) | fn visit_none<E>(self) -> Result<(), E>
  type IdentifierDeserializer (line 3057) | pub trait IdentifierDeserializer<'de, E: Error> {
    method from (line 3060) | fn from(self) -> Self::Deserializer;
  type Borrowed (line 3063) | pub struct Borrowed<'de, T: 'de + ?Sized>(pub &'de T);
  type Deserializer (line 3070) | type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
  function from (line 3072) | fn from(self) -> Self::Deserializer {
  type StrDeserializer (line 3077) | pub struct StrDeserializer<'a, E> {
  type Error (line 3087) | type Error = E;
  function deserialize_any (line 3089) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type BorrowedStrDeserializer (line 3103) | pub struct BorrowedStrDeserializer<'de, E> {
  type Error (line 3113) | type Error = E;
  function deserialize_any (line 3115) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 3134) | type Deserializer = StrDeserializer<'a, E>;
  function from (line 3136) | fn from(self) -> Self::Deserializer {
  type Deserializer (line 3149) | type Deserializer = BorrowedStrDeserializer<'de, E>;
  function from (line 3151) | fn from(self) -> Self::Deserializer {
  type Deserializer (line 3164) | type Deserializer = BytesDeserializer<'a, E>;
  function from (line 3166) | fn from(self) -> Self::Deserializer {
  type Deserializer (line 3176) | type Deserializer = BorrowedBytesDeserializer<'de, E>;
  function from (line 3178) | fn from(self) -> Self::Deserializer {
  type FlatMapDeserializer (line 3184) | pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
  function deserialize_other (line 3194) | fn deserialize_other<V>() -> Result<V, E> {
  type Error (line 3219) | type Error = E;
  function deserialize_any (line 3221) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 3228) | fn deserialize_enum<V>(
  function deserialize_map (line 3249) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_struct (line 3260) | fn deserialize_struct<V>(
  function deserialize_newtype_struct (line 3277) | fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Resul...
  function deserialize_option (line 3284) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit (line 3294) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_unit_struct (line 3301) | fn deserialize_unit_struct<V>(
  function deserialize_ignored_any (line 3312) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self...
  type FlatMapAccess (line 3344) | struct FlatMapAccess<'a, 'de: 'a, E> {
  type Error (line 3356) | type Error = E;
  function next_key_seed (line 3358) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 3376) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  type FlatStructAccess (line 3388) | struct FlatStructAccess<'a, 'de: 'a, E> {
  type Error (line 3401) | type Error = E;
  function next_key_seed (line 3403) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 3416) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  function flat_map_take_entry (line 3430) | fn flat_map_take_entry<'de>(
  type AdjacentlyTaggedEnumVariantSeed (line 3449) | pub struct AdjacentlyTaggedEnumVariantSeed<F> {
  type AdjacentlyTaggedEnumVariantVisitor (line 3455) | pub struct AdjacentlyTaggedEnumVariantVisitor<F> {
  type Value (line 3465) | type Value = F;
  function expecting (line 3467) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_enum (line 3471) | fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
  type Value (line 3486) | type Value = F;
  function deserialize (line 3488) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

FILE: serde/src/private/ser.rs
  function constrain (line 12) | pub fn constrain<T: ?Sized>(t: &T) -> &T {
  function serialize_tagged_newtype (line 17) | pub fn serialize_tagged_newtype<S, T>(
  type TaggedSerializer (line 38) | struct TaggedSerializer<S> {
  type Unsupported (line 46) | enum Unsupported {
  method fmt (line 63) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function bad_type (line 85) | fn bad_type(self, what: Unsupported) -> S::Error {
  type Ok (line 98) | type Ok = S::Ok;
  type Error (line 99) | type Error = S::Error;
  type SerializeSeq (line 101) | type SerializeSeq = Impossible<S::Ok, S::Error>;
  type SerializeTuple (line 102) | type SerializeTuple = Impossible<S::Ok, S::Error>;
  type SerializeTupleStruct (line 103) | type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
  type SerializeMap (line 104) | type SerializeMap = S::SerializeMap;
  type SerializeStruct (line 105) | type SerializeStruct = S::SerializeStruct;
  type SerializeTupleVariant (line 108) | type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
  type SerializeTupleVariant (line 110) | type SerializeTupleVariant = SerializeTupleVariantAsMapValue<S::Serializ...
  type SerializeStructVariant (line 113) | type SerializeStructVariant = Impossible<S::Ok, S::Error>;
  type SerializeStructVariant (line 115) | type SerializeStructVariant = SerializeStructVariantAsMapValue<S::Serial...
  method serialize_bool (line 117) | fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
  method serialize_i8 (line 121) | fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
  method serialize_i16 (line 125) | fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
  method serialize_i32 (line 129) | fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
  method serialize_i64 (line 133) | fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
  method serialize_u8 (line 137) | fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
  method serialize_u16 (line 141) | fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
  method serialize_u32 (line 145) | fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
  method serialize_u64 (line 149) | fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
  method serialize_f32 (line 153) | fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
  method serialize_f64 (line 157) | fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
  method serialize_char (line 161) | fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
  method serialize_str (line 165) | fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
  method serialize_bytes (line 169) | fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
  method serialize_none (line 173) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  method serialize_some (line 177) | fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
  method serialize_unit (line 184) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  method serialize_unit_struct (line 190) | fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self...
  method serialize_unit_variant (line 196) | fn serialize_unit_variant(
  method serialize_newtype_struct (line 208) | fn serialize_newtype_struct<T>(
  method serialize_newtype_variant (line 219) | fn serialize_newtype_variant<T>(
  method serialize_seq (line 235) | fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, S...
  method serialize_tuple (line 239) | fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self:...
  method serialize_tuple_struct (line 243) | fn serialize_tuple_struct(
  method serialize_tuple_variant (line 252) | fn serialize_tuple_variant(
  method serialize_tuple_variant (line 265) | fn serialize_tuple_variant(
  method serialize_map (line 282) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap,...
  method serialize_struct (line 288) | fn serialize_struct(
  method serialize_struct_variant (line 299) | fn serialize_struct_variant(
  method serialize_struct_variant (line 312) | fn serialize_struct_variant(
  method collect_str (line 330) | fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
  type SerializeTupleVariantAsMapValue (line 344) | pub struct SerializeTupleVariantAsMapValue<M> {
  function new (line 351) | pub fn new(map: M, name: &'static str, len: usize) -> Self {
  type Ok (line 365) | type Ok = M::Ok;
  type Error (line 366) | type Error = M::Error;
  function serialize_field (line 368) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), M::Error>
  function end (line 377) | fn end(mut self) -> Result<M::Ok, M::Error> {
  type SerializeStructVariantAsMapValue (line 385) | pub struct SerializeStructVariantAsMapValue<M> {
  function new (line 392) | pub fn new(map: M, name: &'static str, len: usize) -> Self {
  type Ok (line 406) | type Ok = M::Ok;
  type Error (line 407) | type Error = M::Error;
  function serialize_field (line 409) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 418) | fn end(mut self) -> Result<M::Ok, M::Error> {
  type Content (line 426) | pub enum Content {
  method serialize (line 471) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type ContentSerializer (line 552) | pub struct ContentSerializer<E> {
  function new (line 557) | pub fn new() -> Self {
  type Ok (line 567) | type Ok = Content;
  type Error (line 568) | type Error = E;
  type SerializeSeq (line 570) | type SerializeSeq = SerializeSeq<E>;
  type SerializeTuple (line 571) | type SerializeTuple = SerializeTuple<E>;
  type SerializeTupleStruct (line 572) | type SerializeTupleStruct = SerializeTupleStruct<E>;
  type SerializeTupleVariant (line 573) | type SerializeTupleVariant = SerializeTupleVariant<E>;
  type SerializeMap (line 574) | type SerializeMap = SerializeMap<E>;
  type SerializeStruct (line 575) | type SerializeStruct = SerializeStruct<E>;
  type SerializeStructVariant (line 576) | type SerializeStructVariant = SerializeStructVariant<E>;
  method serialize_bool (line 578) | fn serialize_bool(self, v: bool) -> Result<Content, E> {
  method serialize_i8 (line 582) | fn serialize_i8(self, v: i8) -> Result<Content, E> {
  method serialize_i16 (line 586) | fn serialize_i16(self, v: i16) -> Result<Content, E> {
  method serialize_i32 (line 590) | fn serialize_i32(self, v: i32) -> Result<Content, E> {
  method serialize_i64 (line 594) | fn serialize_i64(self, v: i64) -> Result<Content, E> {
  method serialize_u8 (line 598) | fn serialize_u8(self, v: u8) -> Result<Content, E> {
  method serialize_u16 (line 602) | fn serialize_u16(self, v: u16) -> Result<Content, E> {
  method serialize_u32 (line 606) | fn serialize_u32(self, v: u32) -> Result<Content, E> {
  method serialize_u64 (line 610) | fn serialize_u64(self, v: u64) -> Result<Content, E> {
  method serialize_f32 (line 614) | fn serialize_f32(self, v: f32) -> Result<Content, E> {
  method serialize_f64 (line 618) | fn serialize_f64(self, v: f64) -> Result<Content, E> {
  method serialize_char (line 622) | fn serialize_char(self, v: char) -> Result<Content, E> {
  method serialize_str (line 626) | fn serialize_str(self, value: &str) -> Result<Content, E> {
  method serialize_bytes (line 630) | fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> {
  method serialize_none (line 634) | fn serialize_none(self) -> Result<Content, E> {
  method serialize_some (line 638) | fn serialize_some<T>(self, value: &T) -> Result<Content, E>
  method serialize_unit (line 645) | fn serialize_unit(self) -> Result<Content, E> {
  method serialize_unit_struct (line 649) | fn serialize_unit_struct(self, name: &'static str) -> Result<Content, E> {
  method serialize_unit_variant (line 653) | fn serialize_unit_variant(
  method serialize_newtype_struct (line 662) | fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> R...
  method serialize_newtype_variant (line 672) | fn serialize_newtype_variant<T>(
  method serialize_seq (line 690) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq,...
  method serialize_tuple (line 697) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
  method serialize_tuple_struct (line 704) | fn serialize_tuple_struct(
  method serialize_tuple_variant (line 716) | fn serialize_tuple_variant(
  method serialize_map (line 732) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap,...
  method serialize_struct (line 740) | fn serialize_struct(
  method serialize_struct_variant (line 752) | fn serialize_struct_variant(
  type SerializeSeq (line 769) | pub struct SerializeSeq<E> {
  type Ok (line 779) | type Ok = Content;
  type Error (line 780) | type Error = E;
  function serialize_element (line 782) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
  function end (line 791) | fn end(self) -> Result<Content, E> {
  type SerializeTuple (line 796) | pub struct SerializeTuple<E> {
  type Ok (line 806) | type Ok = Content;
  type Error (line 807) | type Error = E;
  function serialize_element (line 809) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
  function end (line 818) | fn end(self) -> Result<Content, E> {
  type SerializeTupleStruct (line 823) | pub struct SerializeTupleStruct<E> {
  type Ok (line 834) | type Ok = Content;
  type Error (line 835) | type Error = E;
  function serialize_field (line 837) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
  function end (line 846) | fn end(self) -> Result<Content, E> {
  type SerializeTupleVariant (line 851) | pub struct SerializeTupleVariant<E> {
  type Ok (line 864) | type Ok = Content;
  type Error (line 865) | type Error = E;
  function serialize_field (line 867) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
  function end (line 876) | fn end(self) -> Result<Content, E> {
  type SerializeMap (line 886) | pub struct SerializeMap<E> {
  type Ok (line 897) | type Ok = Content;
  type Error (line 898) | type Error = E;
  function serialize_key (line 900) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), E>
  function serialize_value (line 909) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), E>
  function end (line 922) | fn end(self) -> Result<Content, E> {
  function serialize_entry (line 926) | fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), E>
  type SerializeStruct (line 938) | pub struct SerializeStruct<E> {
  type Ok (line 949) | type Ok = Content;
  type Error (line 950) | type Error = E;
  function serialize_field (line 952) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 961) | fn end(self) -> Result<Content, E> {
  type SerializeStructVariant (line 966) | pub struct SerializeStructVariant<E> {
  type Ok (line 979) | type Ok = Content;
  type Error (line 980) | type Error = E;
  function serialize_field (line 982) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 991) | fn end(self) -> Result<Content, E> {
  type FlatMapSerializer (line 1003) | pub struct FlatMapSerializer<'a, M: 'a>(pub &'a mut M);
  function bad_type (line 1010) | fn bad_type(what: Unsupported) -> M::Error {
  type Ok (line 1024) | type Ok = ();
  type Error (line 1025) | type Error = M::Error;
  type SerializeSeq (line 1027) | type SerializeSeq = Impossible<Self::Ok, M::Error>;
  type SerializeTuple (line 1028) | type SerializeTuple = Impossible<Self::Ok, M::Error>;
  type SerializeTupleStruct (line 1029) | type SerializeTupleStruct = Impossible<Self::Ok, M::Error>;
  type SerializeMap (line 1030) | type SerializeMap = FlatMapSerializeMap<'a, M>;
  type SerializeStruct (line 1031) | type SerializeStruct = FlatMapSerializeStruct<'a, M>;
  type SerializeTupleVariant (line 1032) | type SerializeTupleVariant = FlatMapSerializeTupleVariantAsMapValue<'a, M>;
  type SerializeStructVariant (line 1033) | type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a...
  method serialize_bool (line 1035) | fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
  method serialize_i8 (line 1039) | fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
  method serialize_i16 (line 1043) | fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
  method serialize_i32 (line 1047) | fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
  method serialize_i64 (line 1051) | fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
  method serialize_u8 (line 1055) | fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
  method serialize_u16 (line 1059) | fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
  method serialize_u32 (line 1063) | fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
  method serialize_u64 (line 1067) | fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
  method serialize_f32 (line 1071) | fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
  method serialize_f64 (line 1075) | fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
  method serialize_char (line 1079) | fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
  method serialize_str (line 1083) | fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
  method serialize_bytes (line 1087) | fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
  method serialize_none (line 1091) | fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
  method serialize_some (line 1095) | fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
  method serialize_unit (line 1102) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
  method serialize_unit_struct (line 1106) | fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self...
  method serialize_unit_variant (line 1110) | fn serialize_unit_variant(
  method serialize_newtype_struct (line 1119) | fn serialize_newtype_struct<T>(
  method serialize_newtype_variant (line 1130) | fn serialize_newtype_variant<T>(
  method serialize_seq (line 1143) | fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, S...
  method serialize_tuple (line 1147) | fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self:...
  method serialize_tuple_struct (line 1151) | fn serialize_tuple_struct(
  method serialize_tuple_variant (line 1159) | fn serialize_tuple_variant(
  method serialize_map (line 1170) | fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, S...
  method serialize_struct (line 1174) | fn serialize_struct(
  method serialize_struct_variant (line 1182) | fn serialize_struct_variant(
  type FlatMapSerializeMap (line 1198) | pub struct FlatMapSerializeMap<'a, M: 'a>(&'a mut M);
  type Ok (line 1206) | type Ok = ();
  type Error (line 1207) | type Error = M::Error;
  function serialize_key (line 1209) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
  function serialize_value (line 1216) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function serialize_entry (line 1223) | fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Se...
  function end (line 1231) | fn end(self) -> Result<(), Self::Error> {
  type FlatMapSerializeStruct (line 1237) | pub struct FlatMapSerializeStruct<'a, M: 'a>(&'a mut M);
  type Ok (line 1245) | type Ok = ();
  type Error (line 1246) | type Error = M::Error;
  function serialize_field (line 1248) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 1255) | fn end(self) -> Result<(), Self::Error> {
  type FlatMapSerializeTupleVariantAsMapValue (line 1263) | pub struct FlatMapSerializeTupleVariantAsMapValue<'a, M: 'a> {
  function new (line 1273) | fn new(map: &'a mut M) -> Self {
  type Ok (line 1287) | type Ok = ();
  type Error (line 1288) | type Error = M::Error;
  function serialize_field (line 1290) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
  function end (line 1299) | fn end(self) -> Result<(), Self::Error> {
  type FlatMapSerializeStructVariantAsMapValue (line 1308) | pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
  function new (line 1319) | fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVari...
  type Ok (line 1334) | type Ok = ();
  type Error (line 1335) | type Error = M::Error;
  function serialize_field (line 1337) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  function end (line 1346) | fn end(self) -> Result<(), Self::Error> {
  type AdjacentlyTaggedEnumVariant (line 1354) | pub struct AdjacentlyTaggedEnumVariant {
  method serialize (line 1362) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type CannotSerializeVariant (line 1372) | pub struct CannotSerializeVariant<T>(pub T);
  method fmt (line 1379) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

FILE: serde_core/build.rs
  constant PRIVATE (line 7) | const PRIVATE: &str = "\
  function main (line 18) | fn main() {
  function rustc_minor_version (line 104) | fn rustc_minor_version() -> Option<u32> {

FILE: serde_core/src/de/ignored_any.rs
  type IgnoredAny (line 111) | pub struct IgnoredAny;
    type Value (line 114) | type Value = IgnoredAny;
    method expecting (line 116) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_bool (line 121) | fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
    method visit_i64 (line 127) | fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
    method visit_i128 (line 133) | fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
    method visit_u64 (line 139) | fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
    method visit_u128 (line 145) | fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
    method visit_f64 (line 151) | fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
    method visit_str (line 157) | fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
    method visit_none (line 166) | fn visit_none<E>(self) -> Result<Self::Value, E> {
    method visit_some (line 171) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    method visit_newtype_struct (line 179) | fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Valu...
    method visit_unit (line 187) | fn visit_unit<E>(self) -> Result<Self::Value, E> {
    method visit_seq (line 192) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    method visit_map (line 203) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
    method visit_bytes (line 214) | fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
    method visit_enum (line 222) | fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
    method deserialize (line 232) | fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>

FILE: serde_core/src/de/impls.rs
  type UnitVisitor (line 14) | struct UnitVisitor;
    type Value (line 17) | type Value = ();
    method expecting (line 19) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_unit (line 23) | fn visit_unit<E>(self) -> Result<Self::Value, E>
  function deserialize (line 32) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 43) | fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
  type BoolVisitor (line 53) | struct BoolVisitor;
    type Value (line 56) | type Value = bool;
    method expecting (line 58) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_bool (line 62) | fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
  function deserialize (line 71) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type CharVisitor (line 537) | struct CharVisitor;
    type Value (line 540) | type Value = char;
    method expecting (line 542) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_char (line 547) | fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
    method visit_str (line 555) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
  function deserialize (line 569) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type StringVisitor (line 580) | struct StringVisitor;
    type Value (line 586) | type Value = String;
    method expecting (line 588) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_str (line 592) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    method visit_string (line 599) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    method visit_bytes (line 606) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    method visit_byte_buf (line 616) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
  type StringInPlaceVisitor (line 582) | struct StringInPlaceVisitor<'a>(&'a mut String);
  type Value (line 632) | type Value = ();
  function expecting (line 634) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_str (line 638) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
  function visit_string (line 647) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
  function visit_bytes (line 655) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
  function visit_byte_buf (line 669) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
  method deserialize (line 689) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method deserialize_in_place (line 696) | fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<...
  type StrVisitor (line 706) | struct StrVisitor;
    type Value (line 709) | type Value = &'a str;
    method expecting (line 711) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_borrowed_str (line 715) | fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
    method visit_borrowed_bytes (line 722) | fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
  function deserialize (line 731) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type BytesVisitor (line 741) | struct BytesVisitor;
    type Value (line 744) | type Value = &'a [u8];
    method expecting (line 746) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_borrowed_bytes (line 750) | fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
    method visit_borrowed_str (line 757) | fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
  function deserialize (line 766) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type CStringVisitor (line 777) | struct CStringVisitor;
    type Value (line 781) | type Value = CString;
    method expecting (line 783) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_seq (line 787) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    method visit_bytes (line 801) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    method visit_byte_buf (line 808) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    method visit_str (line 815) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    method visit_string (line 822) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
  method deserialize (line 833) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type OptionVisitor (line 870) | struct OptionVisitor<T> {
  type Value (line 878) | type Value = Option<T>;
  function expecting (line 880) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_unit (line 885) | fn visit_unit<E>(self) -> Result<Self::Value, E>
  function visit_none (line 893) | fn visit_none<E>(self) -> Result<Self::Value, E>
  function visit_some (line 901) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  function __private_visit_untagged_option (line 908) | fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<S...
  function deserialize (line 920) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type PhantomDataVisitor (line 938) | struct PhantomDataVisitor<T: ?Sized> {
  type Value (line 946) | type Value = PhantomData<T>;
  function expecting (line 948) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_unit (line 953) | fn visit_unit<E>(self) -> Result<Self::Value, E>
  function deserialize (line 965) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function nop_reserve (line 1074) | fn nop_reserve<T>(_seq: T, _n: usize) {}
  function deserialize (line 1139) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize_in_place (line 1178) | fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<...
  type ArrayVisitor (line 1228) | struct ArrayVisitor<A> {
  type ArrayInPlaceVisitor (line 1231) | struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
  function new (line 1234) | fn new() -> Self {
  type Value (line 1242) | type Value = [T; 0];
  function expecting (line 1244) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 1249) | fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
  function deserialize (line 1259) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 1707) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 1753) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type PathVisitor (line 1785) | struct PathVisitor;
    type Value (line 1789) | type Value = &'a Path;
    method expecting (line 1791) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_borrowed_str (line 1795) | fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
    method visit_borrowed_bytes (line 1802) | fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
  function deserialize (line 1815) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type PathBufVisitor (line 1824) | struct PathBufVisitor;
    type Value (line 1828) | type Value = PathBuf;
    method expecting (line 1830) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_str (line 1834) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    method visit_string (line 1841) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    method visit_bytes (line 1848) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    method visit_byte_buf (line 1857) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
  method deserialize (line 1870) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type OsStringVisitor (line 1898) | struct OsStringVisitor;
    type Value (line 1902) | type Value = OsString;
    method expecting (line 1904) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_enum (line 1909) | fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
    method visit_enum (line 1924) | fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
  method deserialize (line 1944) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 1986) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2009) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2031) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2095) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method deserialize (line 2130) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method deserialize (line 2272) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2427) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2447) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  constant FIELDS (line 2469) | pub const FIELDS: &[&str] = &["start", "end"];
  type Field (line 2475) | enum Field {
    method deserialize (line 2481) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2639) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2778) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type RangeVisitor (line 2524) | pub struct RangeVisitor<Idx> {
  type Value (line 2533) | type Value = (Idx, Idx);
  function expecting (line 2535) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 2539) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  function visit_map (line 2558) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
  function deserialize (line 2606) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  constant FIELDS (line 2628) | pub const FIELDS: &[&str] = &["start"];
  type Field (line 2634) | enum Field {
    method deserialize (line 2481) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2639) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2778) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type RangeFromVisitor (line 2680) | pub struct RangeFromVisitor<Idx> {
  type Value (line 2689) | type Value = Idx;
  function expecting (line 2691) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 2695) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  function visit_map (line 2708) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
  function deserialize (line 2745) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  constant FIELDS (line 2767) | pub const FIELDS: &[&str] = &["end"];
  type Field (line 2773) | enum Field {
    method deserialize (line 2481) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2639) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize (line 2778) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type RangeToVisitor (line 2819) | pub struct RangeToVisitor<Idx> {
  type Value (line 2828) | type Value = Idx;
  function expecting (line 2830) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_seq (line 2834) | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
  function visit_map (line 2847) | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
  function deserialize (line 2877) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 2987) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function deserialize (line 3094) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type FromStrVisitor (line 3140) | struct FromStrVisitor<T> {
  function new (line 3147) | fn new(expecting: &'static str) -> Self {
  type Value (line 3161) | type Value = T;
  function expecting (line 3163) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  function visit_str (line 3167) | fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>

FILE: serde_core/src/de/mod.rs
  type Unexpected (line 338) | pub enum Unexpected<'a> {
  function fmt (line 402) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Expected (line 484) | pub trait Expected {
    method fmt (line 487) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
    method fmt (line 494) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 500) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 506) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Deserialize (line 554) | pub trait Deserialize<'de>: Sized {
    method deserialize (line 561) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method deserialize_in_place (line 585) | fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Resul...
  type DeserializeOwned (line 632) | pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
  type DeserializeSeed (line 803) | pub trait DeserializeSeed<'de>: Sized {
    method deserialize (line 809) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  type Value (line 818) | type Value = T;
  function deserialize (line 821) | fn deserialize<D>(self, deserializer: D) -> Result<T, D::Error>
  type Deserializer (line 945) | pub trait Deserializer<'de>: Sized {
    method deserialize_any (line 959) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_bool (line 964) | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i8 (line 969) | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i16 (line 974) | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i32 (line 979) | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i64 (line 984) | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_i128 (line 991) | fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u8 (line 1000) | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u16 (line 1005) | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u32 (line 1010) | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u64 (line 1015) | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_u128 (line 1022) | fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_f32 (line 1031) | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_f64 (line 1036) | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_char (line 1041) | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_str (line 1052) | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_string (line 1063) | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::E...
    method deserialize_bytes (line 1074) | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Er...
    method deserialize_byte_buf (line 1085) | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self:...
    method deserialize_option (line 1094) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::E...
    method deserialize_unit (line 1099) | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_unit_struct (line 1105) | fn deserialize_unit_struct<V>(
    method deserialize_newtype_struct (line 1115) | fn deserialize_newtype_struct<V>(
    method deserialize_seq (line 1124) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_tuple (line 1130) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Val...
    method deserialize_tuple_struct (line 1136) | fn deserialize_tuple_struct<V>(
    method deserialize_map (line 1146) | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    method deserialize_struct (line 1152) | fn deserialize_struct<V>(
    method deserialize_enum (line 1163) | fn deserialize_enum<V>(
    method deserialize_identifier (line 1174) | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Sel...
    method deserialize_ignored_any (line 1182) | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Se...
    method is_human_readable (line 1253) | fn is_human_readable(&self) -> bool {
    method __deserialize_content_v1 (line 1260) | fn __deserialize_content_v1<V>(self, visitor: V) -> Result<V::Value, S...
  type Visitor (line 1317) | pub trait Visitor<'de>: Sized {
    method expecting (line 1343) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
    method visit_bool (line 1348) | fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
    method visit_i8 (line 1360) | fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
    method visit_i16 (line 1372) | fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
    method visit_i32 (line 1384) | fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
    method visit_i64 (line 1394) | fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
    method visit_i128 (line 1404) | fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
    method visit_u8 (line 1422) | fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
    method visit_u16 (line 1434) | fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
    method visit_u32 (line 1446) | fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
    method visit_u64 (line 1456) | fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
    method visit_u128 (line 1466) | fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
    method visit_f32 (line 1484) | fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
    method visit_f64 (line 1494) | fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
    method visit_char (line 1508) | fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
    method visit_str (line 1526) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    method visit_borrowed_str (line 1543) | fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
    method visit_string (line 1568) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    method visit_bytes (line 1586) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    method visit_borrowed_bytes (line 1602) | fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
    method visit_byte_buf (line 1627) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    method visit_none (line 1637) | fn visit_none<E>(self) -> Result<Self::Value, E>
    method visit_some (line 1647) | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    method visit_unit (line 1658) | fn visit_unit<E>(self) -> Result<Self::Value, E>
    method visit_newtype_struct (line 1671) | fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Valu...
    method visit_seq (line 1682) | fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
    method visit_map (line 1693) | fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
    method visit_enum (line 1704) | fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
    method __private_visit_untagged_option (line 1714) | fn __private_visit_untagged_option<D>(self, _: D) -> Result<Self::Valu...
  type SeqAccess (line 1749) | pub trait SeqAccess<'de> {
    method next_element_seed (line 1759) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>...
    method next_element (line 1769) | fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
    method size_hint (line 1778) | fn size_hint(&self) -> Option<usize> {
  type Error (line 1787) | type Error = A::Error;
  function next_element_seed (line 1790) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function next_element (line 1798) | fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
  function size_hint (line 1806) | fn size_hint(&self) -> Option<usize> {
  type MapAccess (line 1837) | pub trait MapAccess<'de> {
    method next_key_seed (line 1847) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Se...
    method next_value_seed (line 1860) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Er...
    method next_entry_seed (line 1873) | fn next_entry_seed<K, V>(
    method next_key (line 1897) | fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
    method next_value (line 1914) | fn next_value<V>(&mut self) -> Result<V, Self::Error>
    method next_entry (line 1927) | fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
    method size_hint (line 1937) | fn size_hint(&self) -> Option<usize> {
  type Error (line 1946) | type Error = A::Error;
  function next_key_seed (line 1949) | fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self...
  function next_value_seed (line 1957) | fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
  function next_entry_seed (line 1965) | fn next_entry_seed<K, V>(
  function next_entry (line 1978) | fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
  function next_key (line 1987) | fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
  function next_value (line 1995) | fn next_value<V>(&mut self) -> Result<V, Self::Error>
  function size_hint (line 2003) | fn size_hint(&self) -> Option<usize> {
  type EnumAccess (line 2035) | pub trait EnumAccess<'de>: Sized {
    method variant_seed (line 2047) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant),...
    method variant (line 2056) | fn variant<V>(self) -> Result<(V, Self::Variant), Self::Error>
  type VariantAccess (line 2088) | pub trait VariantAccess<'de>: Sized {
    method unit_variant (line 2128) | fn unit_variant(self) -> Result<(), Self::Error>;
    method newtype_variant_seed (line 2170) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Er...
    method newtype_variant (line 2180) | fn newtype_variant<T>(self) -> Result<T, Self::Error>
    method tuple_variant (line 2226) | fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, ...
    method struct_variant (line 2273) | fn struct_variant<V>(
  type IntoDeserializer (line 2316) | pub trait IntoDeserializer<'de, E: Error = value::Error> {
    method into_deserializer (line 2321) | fn into_deserializer(self) -> Self::Deserializer;
  type OneOf (line 2333) | struct OneOf {
  method fmt (line 2338) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type WithDecimalPoint (line 2357) | struct WithDecimalPoint(f64);
  method fmt (line 2360) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

FILE: serde_core/src/de/value.rs
  type Error (line 52) | pub struct Error {
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type ErrorImpl (line 57) | type ErrorImpl = Box<str>;
  type ErrorImpl (line 59) | type ErrorImpl = ();
  method fmt (line 96) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 101) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 107) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Deserializer (line 129) | type Deserializer = UnitDeserializer<E>;
  function into_deserializer (line 131) | fn into_deserializer(self) -> UnitDeserializer<E> {
  type UnitDeserializer (line 137) | pub struct UnitDeserializer<E> {
  function new (line 145) | pub fn new() -> Self {
  type Error (line 156) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 164) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_option (line 171) | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 183) | type Deserializer = Self;
  function into_deserializer (line 185) | fn into_deserializer(self) -> Self {
  method fmt (line 191) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type NeverDeserializer (line 201) | pub struct NeverDeserializer<E> {
  type Deserializer (line 212) | type Deserializer = NeverDeserializer<E>;
  function into_deserializer (line 214) | fn into_deserializer(self) -> Self::Deserializer {
  type Error (line 224) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 226) | fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 245) | type Deserializer = Self;
  function into_deserializer (line 247) | fn into_deserializer(self) -> Self {
  type U32Deserializer (line 345) | pub struct U32Deserializer<E> {
  type Deserializer (line 356) | type Deserializer = U32Deserializer<E>;
  function into_deserializer (line 358) | fn into_deserializer(self) -> U32Deserializer<E> {
  function new (line 365) | pub fn new(value: u32) -> Self {
  type Error (line 377) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 385) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 392) | fn deserialize_enum<V>(
  type Deserializer (line 411) | type Deserializer = Self;
  function into_deserializer (line 413) | fn into_deserializer(self) -> Self {
  type Error (line 422) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 423) | type Variant = private::UnitOnly<E>;
  function variant_seed (line 425) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...
  method fmt (line 434) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type StrDeserializer (line 445) | pub struct StrDeserializer<'a, E> {
  type Deserializer (line 456) | type Deserializer = StrDeserializer<'a, E>;
  function into_deserializer (line 458) | fn into_deserializer(self) -> StrDeserializer<'a, E> {
  function new (line 465) | pub fn new(value: &'a str) -> Self {
  type Error (line 477) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 479) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 486) | fn deserialize_enum<V>(
  type Deserializer (line 511) | type Deserializer = Self;
  function into_deserializer (line 513) | fn into_deserializer(self) -> Self {
  type Error (line 522) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 523) | type Variant = private::UnitOnly<E>;
  function variant_seed (line 525) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...
  method fmt (line 534) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type BorrowedStrDeserializer (line 546) | pub struct BorrowedStrDeserializer<'de, E> {
  function new (line 555) | pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
  type Error (line 567) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 569) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 576) | fn deserialize_enum<V>(
  type Deserializer (line 601) | type Deserializer = Self;
  function into_deserializer (line 603) | fn into_deserializer(self) -> Self {
  type Error (line 612) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 613) | type Variant = private::UnitOnly<E>;
  function variant_seed (line 615) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...
  method fmt (line 624) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type StringDeserializer (line 637) | pub struct StringDeserializer<E> {
  method clone (line 644) | fn clone(&self) -> Self {
  type Deserializer (line 658) | type Deserializer = StringDeserializer<E>;
  method into_deserializer (line 660) | fn into_deserializer(self) -> StringDeserializer<E> {
  function new (line 668) | pub fn new(value: String) -> Self {
  type Error (line 681) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 683) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 690) | fn deserialize_enum<V>(
  type Deserializer (line 716) | type Deserializer = Self;
  function into_deserializer (line 718) | fn into_deserializer(self) -> Self {
  type Error (line 728) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 729) | type Variant = private::UnitOnly<E>;
  function variant_seed (line 731) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...
  method fmt (line 741) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type CowStrDeserializer (line 754) | pub struct CowStrDeserializer<'a, E> {
  method clone (line 761) | fn clone(&self) -> Self {
  type Deserializer (line 775) | type Deserializer = CowStrDeserializer<'a, E>;
  function into_deserializer (line 777) | fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
  function new (line 785) | pub fn new(value: Cow<'a, str>) -> Self {
  type Error (line 798) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 800) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 810) | fn deserialize_enum<V>(
  type Deserializer (line 836) | type Deserializer = Self;
  function into_deserializer (line 838) | fn into_deserializer(self) -> Self {
  type Error (line 848) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 849) | type Variant = private::UnitOnly<E>;
  function variant_seed (line 851) | fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), S...
  method fmt (line 861) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type BytesDeserializer (line 872) | pub struct BytesDeserializer<'a, E> {
  function new (line 879) | pub fn new(value: &'a [u8]) -> Self {
  type Deserializer (line 893) | type Deserializer = BytesDeserializer<'a, E>;
  function into_deserializer (line 895) | fn into_deserializer(self) -> BytesDeserializer<'a, E> {
  type Error (line 904) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 906) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 924) | type Deserializer = Self;
  function into_deserializer (line 926) | fn into_deserializer(self) -> Self {
  method fmt (line 932) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type BorrowedBytesDeserializer (line 942) | pub struct BorrowedBytesDeserializer<'de, E> {
  function new (line 949) | pub fn new(value: &'de [u8]) -> Self {
  type Error (line 963) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 965) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 983) | type Deserializer = Self;
  function into_deserializer (line 985) | fn into_deserializer(self) -> Self {
  method fmt (line 991) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type SeqDeserializer (line 1003) | pub struct SeqDeserializer<I, E> {
  function new (line 1014) | pub fn new(iter: I) -> Self {
  function end (line 1030) | pub fn end(self) -> Result<(), E> {
  type Error (line 1051) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1053) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  type Deserializer (line 1075) | type Deserializer = Self;
  function into_deserializer (line 1077) | fn into_deserializer(self) -> Self {
  type Error (line 1088) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function next_element_seed (line 1090) | fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, ...
  function size_hint (line 1103) | fn size_hint(&self) -> Option<usize> {
  type ExpectedInSeq (line 1108) | struct ExpectedInSeq(usize);
  method fmt (line 1111) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  method fmt (line 1124) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Deserializer (line 1142) | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
  function into_deserializer (line 1144) | fn into_deserializer(self) -> Self::Deserializer {
  type Deserializer (line 1156) | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
  function into_deserializer (line 1158) | fn into_deserializer(self) -> Self::Deserializer {
  type Deserializer (line 1171) | type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
  function into_deserializer (line 1173) | fn into_deserializer(self) -> Self::Deserializer {
  type SeqAccessDeserializer (line 1182) | pub struct SeqAccessDeserializer<A> {
  function new (line 1188) | pub fn new(seq: A) -> Self {
  type Error (line 1197) | type Error = A::Error;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1199) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 1217) | type Deserializer = Self;
  function into_deserializer (line 1219) | fn into_deserializer(self) -> Self {
  type MapDeserializer (line 1227) | pub struct MapDeserializer<'de, I, E>
  function new (line 1245) | pub fn new(iter: I) -> Self {
  function end (line 1264) | pub fn end(self) -> Result<(), E> {
  function next_pair (line 1284) | fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> {
  type Error (line 1303) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1305) | fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_seq (line 1314) | fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Er...
  function deserialize_tuple (line 1323) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type Deserializer (line 1346) | type Deserializer = Self;
  function into_deserializer (line 1348) | fn into_deserializer(self) -> Self {
  type Error (line 1361) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function next_key_seed (line 1363) | fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self...
  function next_value_seed (line 1376) | fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
  function next_entry_seed (line 1387) | fn next_entry_seed<TK, TV>(
  function size_hint (line 1406) | fn size_hint(&self) -> Option<usize> {
  type Error (line 1419) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function next_element_seed (line 1421) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 1434) | fn size_hint(&self) -> Option<usize> {
  method clone (line 1446) | fn clone(&self) -> Self {
  method fmt (line 1463) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type PairDeserializer (line 1475) | struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
  type Error (line 1483) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1491) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_seq (line 1498) | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_tuple (line 1514) | fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value...
  type PairVisitor (line 1528) | struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
  type Error (line 1536) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function next_element_seed (line 1538) | fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, ...
  function size_hint (line 1551) | fn size_hint(&self) -> Option<usize> {
  type ExpectedInMap (line 1562) | struct ExpectedInMap(usize);
  method fmt (line 1565) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Deserializer (line 1584) | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIte...
  function into_deserializer (line 1586) | fn into_deserializer(self) -> Self::Deserializer {
  type Deserializer (line 1600) | type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIte...
  function into_deserializer (line 1602) | fn into_deserializer(self) -> Self::Deserializer {
  type MapAccessDeserializer (line 1611) | pub struct MapAccessDeserializer<A> {
  function new (line 1617) | pub fn new(map: A) -> Self {
  type Error (line 1626) | type Error = A::Error;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1628) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  function deserialize_enum (line 1635) | fn deserialize_enum<V>(
  type Deserializer (line 1658) | type Deserializer = Self;
  function into_deserializer (line 1660) | fn into_deserializer(self) -> Self {
  type Error (line 1669) | type Error = A::Error;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  type Variant (line 1670) | type Variant = private::MapAsEnum<A>;
  function variant_seed (line 1672) | fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant...
  type EnumAccessDeserializer (line 1687) | pub struct EnumAccessDeserializer<A> {
  function new (line 1693) | pub fn new(access: A) -> Self {
  type Error (line 1702) | type Error = A::Error;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function deserialize_any (line 1704) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
  type Deserializer (line 1722) | type Deserializer = Self;
  function into_deserializer (line 1724) | fn into_deserializer(self) -> Self {
  type UnitOnly (line 1738) | pub struct UnitOnly<E> {
  function unit_only (line 1742) | pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
  type Error (line 1755) | type Error = E;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function unit_variant (line 1757) | fn unit_variant(self) -> Result<(), Self::Error> {
  function newtype_variant_seed (line 1761) | fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
  function tuple_variant (line 1771) | fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, ...
  function struct_variant (line 1781) | fn struct_variant<V>(
  type MapAsEnum (line 1796) | pub struct MapAsEnum<A> {
  function map_as_enum (line 1800) | pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
  type Error (line 1808) | type Error = A::Error;
    method custom (line 64) | fn custom<T>(msg: T) -> Self
    method custom (line 75) | fn custom<T>(msg: T) -> Self
    method custom (line 86) | fn custom<T>(msg: T) -> Self
    method description (line 118) | fn description(&self) -> &str {
  function unit_variant (line 1810) | fn unit_variant(mut self) -> Result<(), Self::Error> {
  function newtype_variant_seed (line 1814) | fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::...
  function tuple_variant (line 1821) | fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value...
  function struct_variant (line 1828) | fn struct_variant<V>(
  type SeedTupleVariant (line 1840) | struct SeedTupleVariant<V> {
  type Value (line 1849) | type Value = V::Value;
  function deserialize (line 1851) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  type SeedStructVariant (line 1859) | struct SeedStructVariant<V> {
  type Value (line 1867) | type Value = V::Value;
  function deserialize (line 1869) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
  type Pair (line 1879) | pub trait Pair {
    method split (line 1882) | fn split(self) -> (Self::First, Self::Second);
    type First (line 1886) | type First = A;
    type Second (line 1887) | type Second = B;
    method split (line 1888) | fn split(self) -> (A, B) {
  type First (line 1893) | pub type First<T> = <T as Pair>::First;
  type Second (line 1894) | pub type Second<T> = <T as Pair>::Second;

FILE: serde_core/src/format.rs
  type Buf (line 4) | pub(super) struct Buf<'a> {
  function new (line 10) | pub fn new(bytes: &'a mut [u8]) -> Self {
  function as_str (line 14) | pub fn as_str(&self) -> &str {
  method write_str (line 21) | fn write_str(&mut self, s: &str) -> fmt::Result {

FILE: serde_core/src/private/content.rs
  type Content (line 10) | pub enum Content<'de> {

FILE: serde_core/src/private/doc.rs
  type Error (line 9) | pub struct Error;
    method custom (line 13) | fn custom<T>(_: T) -> Self
    method description (line 24) | fn description(&self) -> &str {
  method fmt (line 31) | fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {

FILE: serde_core/src/private/seed.rs
  type InPlaceSeed (line 6) | pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
  type Value (line 13) | type Value = ();
  function deserialize (line 14) | fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>

FILE: serde_core/src/private/size_hint.rs
  function from_bounds (line 4) | pub fn from_bounds<I>(iter: &I) -> Option<usize>
  function cautious (line 12) | pub fn cautious<Element>(hint: Option<usize>) -> usize {
  function helper (line 25) | fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {

FILE: serde_core/src/private/string.rs
  function from_utf8_lossy (line 5) | pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<'_, str> {
  function from_utf8_lossy (line 18) | pub fn from_utf8_lossy(bytes: &[u8]) -> &str {

FILE: serde_core/src/ser/fmt.rs
  method custom (line 5) | fn custom<T: Display>(_msg: T) -> Self {
  type Ok (line 39) | type Ok = ();
  type Error (line 40) | type Error = fmt::Error;
  type SerializeSeq (line 41) | type SerializeSeq = Impossible<(), fmt::Error>;
  type SerializeTuple (line 42) | type SerializeTuple = Impossible<(), fmt::Error>;
  type SerializeTupleStruct (line 43) | type SerializeTupleStruct = Impossible<(), fmt::Error>;
  type SerializeTupleVariant (line 44) | type SerializeTupleVariant = Impossible<(), fmt::Error>;
  type SerializeMap (line 45) | type SerializeMap = Impossible<(), fmt::Error>;
  type SerializeStruct (line 46) | type SerializeStruct = Impossible<(), fmt::Error>;
  type SerializeStructVariant (line 47) | type SerializeStructVariant = Impossible<(), fmt::Error>;
  method serialize_unit_variant (line 68) | fn serialize_unit_variant(
  method serialize_newtype_struct (line 77) | fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> ...
  method serialize_bytes (line 84) | fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
  method serialize_none (line 88) | fn serialize_none(self) -> fmt::Result {
  method serialize_some (line 92) | fn serialize_some<T>(self, _value: &T) -> fmt::Result
  method serialize_unit (line 99) | fn serialize_unit(self) -> fmt::Result {
  method serialize_newtype_variant (line 103) | fn serialize_newtype_variant<T>(
  method serialize_seq (line 116) | fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq...
  method serialize_tuple (line 120) | fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fm...
  method serialize_tuple_struct (line 124) | fn serialize_tuple_struct(
  method serialize_tuple_variant (line 132) | fn serialize_tuple_variant(
  method serialize_map (line 142) | fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap...
  method serialize_struct (line 146) | fn serialize_struct(
  method serialize_struct_variant (line 154) | fn serialize_struct_variant(
  method collect_str (line 164) | fn collect_str<T>(self, value: &T) -> fmt::Result

FILE: serde_core/src/ser/impls.rs
  method serialize (line 42) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 54) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 63) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 77) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 89) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 104) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 122) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 135) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 180) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 251) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 269) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 286) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 304) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 321) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 341) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 352) | fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 540) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 560) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 604) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 616) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 633) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 650) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 670) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 686) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 703) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 737) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  constant DEC_DIGITS_LUT (line 760) | const DEC_DIGITS_LUT: &[u8] = b"\
  function format_u8 (line 769) | fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
  function test_format_u8 (line 790) | fn test_format_u8() {
  method serialize (line 807) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 831) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 847) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 871) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 887) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 909) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 923) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 935) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 944) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 957) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 972) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 986) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 999) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: serde_core/src/ser/impossible.rs
  type Impossible (line 60) | pub struct Impossible<Ok, Error> {
  type Void (line 66) | enum Void {}
  type Ok (line 72) | type Ok = Ok;
  type Error (line 73) | type Error = Error;
  method serialize_element (line 75) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
  method end (line 83) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 92) | type Ok = Ok;
  type Error (line 93) | type Error = Error;
  method serialize_element (line 95) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
  method end (line 103) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 112) | type Ok = Ok;
  type Error (line 113) | type Error = Error;
  method serialize_field (line 115) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
  method end (line 123) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 132) | type Ok = Ok;
  type Error (line 133) | type Error = Error;
  method serialize_field (line 135) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
  method end (line 143) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 152) | type Ok = Ok;
  type Error (line 153) | type Error = Error;
  method serialize_key (line 155) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
  method serialize_value (line 163) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
  method end (line 171) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 180) | type Ok = Ok;
  type Error (line 181) | type Error = Error;
  method serialize_field (line 183) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  method end (line 192) | fn end(self) -> Result<Ok, Error> {
  type Ok (line 201) | type Ok = Ok;
  type Error (line 202) | type Error = Error;
  method serialize_field (line 204) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result...
  method end (line 213) | fn end(self) -> Result<Ok, Error> {

FILE: serde_core/src/ser/mod.rs
  type Serialize (line 234) | pub trait Serialize {
    method serialize (line 265) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Serializer (line 355) | pub trait Serializer: Sized {
    method serialize_bool (line 427) | fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
    method serialize_i8 (line 449) | fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
    method serialize_i16 (line 471) | fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
    method serialize_i32 (line 493) | fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
    method serialize_i64 (line 511) | fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
    method serialize_i128 (line 531) | fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
    method serialize_u8 (line 556) | fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
    method serialize_u16 (line 578) | fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
    method serialize_u32 (line 600) | fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
    method serialize_u64 (line 618) | fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
    method serialize_u128 (line 638) | fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
    method serialize_f32 (line 663) | fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
    method serialize_f64 (line 681) | fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
    method serialize_char (line 702) | fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;
    method serialize_str (line 720) | fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
    method serialize_bytes (line 755) | fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
    method serialize_none (line 788) | fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
    method serialize_some (line 821) | fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    method serialize_unit (line 841) | fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
    method serialize_unit_struct (line 861) | fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok,...
    method serialize_unit_variant (line 889) | fn serialize_unit_variant(
    method serialize_newtype_struct (line 916) | fn serialize_newtype_struct<T>(
    method serialize_newtype_variant (line 950) | fn serialize_newtype_variant<T>(
    method serialize_seq (line 1006) | fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSe...
    method serialize_tuple (line 1062) | fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, S...
    method serialize_tuple_struct (line 1089) | fn serialize_tuple_struct(
    method serialize_tuple_variant (line 1134) | fn serialize_tuple_variant(
    method serialize_map (line 1188) | fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMa...
    method serialize_struct (line 1220) | fn serialize_struct(
    method serialize_struct_variant (line 1264) | fn serialize_struct_variant(
    method collect_seq (line 1296) | fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    method collect_map (line 1333) | fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    method collect_str (line 1373) | fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    method collect_str (line 1406) | fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    method is_human_readable (line 1459) | fn is_human_readable(&self) -> bool {
  type SerializeSeq (line 1518) | pub trait SerializeSeq {
    method serialize_element (line 1526) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    method end (line 1531) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeTuple (line 1624) | pub trait SerializeTuple {
    method serialize_element (line 1632) | fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    method end (line 1637) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeTupleStruct (line 1675) | pub trait SerializeTupleStruct {
    method serialize_field (line 1683) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    method end (line 1688) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeTupleVariant (line 1739) | pub trait SerializeTupleVariant {
    method serialize_field (line 1747) | fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    method end (line 1752) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeMap (line 1811) | pub trait SerializeMap {
    method serialize_key (line 1824) | fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
    method serialize_value (line 1834) | fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
    method serialize_entry (line 1855) | fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), ...
    method end (line 1865) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeStruct (line 1907) | pub trait SerializeStruct {
    method serialize_field (line 1915) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Resu...
    method skip_field (line 1923) | fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
    method end (line 1929) | fn end(self) -> Result<Self::Ok, Self::Error>;
  type SerializeStructVariant (line 1977) | pub trait SerializeStructVariant {
    method serialize_field (line 1985) | fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Resu...
    method skip_field (line 1993) | fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
    method end (line 1999) | fn end(self) -> Result<Self::Ok, Self::Error>;
  function iterator_len_hint (line 2002) | fn iterator_len_hint<I>(iter: &I) -> Option<usize>

FILE: serde_core/src/std_error.rs
  type Error (line 43) | pub trait Error: Debug + Display {
    method source (line 45) | fn source(&self) -> Option<&(dyn Error + 'static)> {

FILE: serde_derive/build.rs
  function main (line 1) | fn main() {

FILE: serde_derive/src/bound.rs
  function without_defaults (line 11) | pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
  function with_where_predicates (line 29) | pub fn with_where_predicates(
  function with_where_predicates_from_fields (line 42) | pub fn with_where_predicates_from_fields(
  function with_where_predicates_from_variants (line 61) | pub fn with_where_predicates_from_variants(
  function with_bound (line 98) | pub fn with_bound(
  function with_self_bound (line 327) | pub fn with_self_bound(
  function with_lifetime_bound (line 354) | pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> ...
  function type_of_item (line 387) | fn type_of_item(cont: &Container) -> syn::Type {

FILE: serde_derive/src/de.rs
  function expand_derive_deserialize (line 25) | pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::R...
  function precondition (line 84) | fn precondition(cx: &Ctxt, cont: &Container) {
  function precondition_sized (line 89) | fn precondition_sized(cx: &Ctxt, cont: &Container) {
  function precondition_no_de_lifetime (line 102) | fn precondition_no_de_lifetime(cx: &Ctxt, cont: &Container) {
  type Parameters (line 116) | struct Parameters {
    method new (line 145) | fn new(cont: &Container) -> Self {
    method type_name (line 167) | fn type_name(&self) -> String {
    method generics_with_de_lifetime (line 174) | fn generics_with_de_lifetime(
  function build_generics (line 192) | fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn...
  function needs_deserialize_bound (line 236) | fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::V...
  function requires_default (line 249) | fn requires_default(field: &attr::Field, _variant: Option<&attr::Variant...
  type BorrowedLifetimes (line 257) | enum BorrowedLifetimes {
    method de_lifetime (line 263) | fn de_lifetime(&self) -> syn::Lifetime {
    method de_lifetime_param (line 270) | fn de_lifetime_param(&self) -> Option<syn::LifetimeParam> {
  function borrowed_lifetimes (line 292) | fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
  function deserialize_body (line 306) | fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
  function deserialize_in_place_body (line 333) | fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> O...
  function deserialize_in_place_body (line 378) | fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) ->...
  function deserialize_transparent (line 383) | fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fra...
  function deserialize_from (line 426) | fn deserialize_from(type_from: &syn::Type) -> Fragment {
  function deserialize_try_from (line 435) | fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
  type TupleForm (line 443) | enum TupleForm<'a> {
  function deserialize_seq (line 451) | fn deserialize_seq(
  function deserialize_seq_in_place (line 555) | fn deserialize_seq_in_place(
  type StructForm (line 643) | enum StructForm<'a> {
  type FieldWithAliases (line 653) | struct FieldWithAliases<'a> {
  function field_i (line 658) | pub(crate) fn field_i(i: usize) -> Ident {
  function wrap_deserialize_with (line 664) | fn wrap_deserialize_with(
  function wrap_deserialize_field_with (line 710) | fn wrap_deserialize_field_with(
  function unwrap_to_variant_closure (line 719) | fn unwrap_to_variant_closure(
  function expr_is_missing (line 766) | fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
  function expr_is_missing_seq (line 808) | fn expr_is_missing_seq(
  function effective_style (line 841) | fn effective_style(variant: &Variant) -> Style {
  function has_flatten (line 850) | fn has_flatten(fields: &[Field]) -> bool {
  type DeImplGenerics (line 856) | struct DeImplGenerics<'a>(&'a Parameters);
  type InPlaceImplGenerics (line 858) | struct InPlaceImplGenerics<'a>(&'a Parameters);
  method to_tokens (line 861) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 876) | fn to_tokens(&self, tokens: &mut TokenStream) {
  function in_place (line 911) | fn in_place(self) -> InPlaceImplGenerics<'a> {
  type DeTypeGenerics (line 916) | struct DeTypeGenerics<'a>(&'a Parameters);
  type InPlaceTypeGenerics (line 918) | struct InPlaceTypeGenerics<'a>(&'a Parameters);
  function de_type_generics_to_tokens (line 920) | fn de_type_generics_to_tokens(
  method to_tokens (line 943) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method to_tokens (line 950) | fn to_tokens(&self, tokens: &mut TokenStream) {
  function in_place (line 963) | fn in_place(self) -> InPlaceTypeGenerics<'a> {
  function place_lifetime (line 969) | fn place_lifetime() -> syn::LifetimeParam {

FILE: serde_derive/src/de/enum_.rs
  function deserialize (line 15) | pub(super) fn deserialize(
  function deserialize_homogeneous_enum (line 39) | fn deserialize_homogeneous_enum(
  function prepare_enum_variant_enum (line 56) | pub fn prepare_enum_variant_enum(variants: &[Variant]) -> (TokenStream, ...

FILE: serde_derive/src/de/enum_adjacently.rs
  function deserialize (line 19) | pub(super) fn deserialize(

FILE: serde_derive/src/de/enum_externally.rs
  function deserialize (line 23) | pub(super) fn deserialize(
  function deserialize_externally_tagged_variant (line 118) | fn deserialize_externally_tagged_variant(
  function wrap_deserialize_variant_with (line 163) | fn wrap_deserialize_variant_with(
  function deserialize_externally_tagged_newtype_variant (line 177) | fn deserialize_externally_tagged_newtype_variant(

FILE: serde_derive/src/de/enum_internally.rs
  function deserialize (line 21) | pub(super) fn deserialize(
  function deserialize_internally_tagged_variant (line 67) | fn deserialize_internally_tagged_variant(

FILE: serde_derive/src/de/enum_untagged.rs
  function deserialize (line 22) | pub(super) fn deserialize(
  function deserialize_variant (line 62) | pub(super) fn deserialize_variant(
  function deserialize_newtype_variant (line 113) | pub(super) fn deserialize_newtype_variant(

FILE: serde_derive/src/de/identifier.rs
  function deserialize_custom (line 14) | pub(super) fn deserialize_custom(
  function deserialize_generated (line 125) | pub(super) fn deserialize_generated(
  function deserialize_identifier (line 185) | fn deserialize_identifier(

FILE: serde_derive/src/de/struct_.rs
  function deserialize (line 17) | pub(super) fn deserialize(
  function deserialize_map (line 199) | fn deserialize_map(
  function deserialize_in_place (line 423) | pub(super) fn deserialize_in_place(
  function deserialize_map_in_place (line 513) | fn deserialize_map_in_place(
  function deserialize_field_identifier (line 673) | fn deserialize_field_identifier(

FILE: serde_derive/src/de/tuple.rs
  function deserialize (line 13) | pub(super) fn deserialize(
  function deserialize_newtype_struct (line 135) | fn deserialize_newtype_struct(
  function deserialize_in_place (line 186) | pub(super) fn deserialize_in_place(

FILE: serde_derive/src/de/unit.rs
  function deserialize (line 8) | pub(super) fn deserialize(params: &Parameters, cattrs: &attr::Container)...

FILE: serde_derive/src/deprecated.rs
  function allow_deprecated (line 4) | pub fn allow_deprecated(input: &syn::DeriveInput) -> Option<TokenStream> {
  function should_allow_deprecated (line 18) | fn should_allow_deprecated(input: &syn::DeriveInput) -> bool {
  function contains_deprecated (line 35) | fn contains_deprecated(attrs: &[syn::Attribute]) -> bool {

FILE: serde_derive/src/dummy.rs
  function wrap_in_const (line 4) | pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) ...

FILE: serde_derive/src/fragment.rs
  type Fragment (line 5) | pub enum Fragment {
    method as_ref (line 68) | fn as_ref(&self) -> &TokenStream {
  type Expr (line 27) | pub struct Expr(pub Fragment);
  method to_tokens (line 29) | fn to_tokens(&self, out: &mut TokenStream) {
  type Stmts (line 40) | pub struct Stmts(pub Fragment);
  method to_tokens (line 42) | fn to_tokens(&self, out: &mut TokenStream) {
  type Match (line 52) | pub struct Match(pub Fragment);
  method to_tokens (line 54) | fn to_tokens(&self, out: &mut TokenStream) {

FILE: serde_derive/src/internals/ast.rs
  type Container (line 10) | pub struct Container<'a> {
  type Data (line 26) | pub enum Data<'a> {
  type Variant (line 32) | pub struct Variant<'a> {
  type Field (line 41) | pub struct Field<'a> {
  type Style (line 49) | pub enum Style {
  function from_ast (line 62) | pub fn from_ast(
  function all_fields (line 119) | pub fn all_fields(&'a self) -> Box<dyn Iterator<Item = &'a Field<'a>> + ...
  function has_getter (line 128) | pub fn has_getter(&self) -> bool {
  function enum_from_ast (line 133) | fn enum_from_ast<'a>(
  function struct_from_ast (line 174) | fn struct_from_ast<'a>(
  function fields_from_ast (line 198) | fn fields_from_ast<'a>(

FILE: serde_derive/src/internals/attr.rs
  type Attr (line 24) | pub(crate) struct Attr<'c, T> {
  function none (line 32) | fn none(cx: &'c Ctxt, name: Symbol) -> Self {
  function set (line 41) | fn set<A: ToTokens>(&mut self, obj: A, value: T) {
  function set_opt (line 53) | fn set_opt<A: ToTokens>(&mut self, obj: A, value: Option<T>) {
  function set_if_none (line 59) | fn set_if_none(&mut self, value: T) {
  function get (line 65) | pub(crate) fn get(self) -> Option<T> {
  function get_with_tokens (line 69) | fn get_with_tokens(self) -> Option<(TokenStream, T)> {
  type BoolAttr (line 77) | struct BoolAttr<'c>(Attr<'c, ()>);
  function none (line 80) | fn none(cx: &'c Ctxt, name: Symbol) -> Self {
  function set_true (line 84) | fn set_true<A: ToTokens>(&mut self, obj: A) {
  function get (line 88) | fn get(&self) -> bool {
  type VecAttr (line 93) | pub(crate) struct VecAttr<'c, T> {
  function none (line 101) | fn none(cx: &'c Ctxt, name: Symbol) -> Self {
  function insert (line 110) | fn insert<A: ToTokens>(&mut self, obj: A, value: T) {
  function at_most_one (line 117) | fn at_most_one(mut self) -> Option<T> {
  function get (line 128) | pub(crate) fn get(self) -> Vec<T> {
  function unraw (line 133) | fn unraw(ident: &Ident) -> Ident {
  type RenameAllRules (line 138) | pub struct RenameAllRules {
    method or (line 146) | pub fn or(self, other_rules: Self) -> Self {
  type Container (line 155) | pub struct Container {
    method from_ast (line 237) | pub fn from_ast(cx: &Ctxt, item: &syn::DeriveInput) -> Self {
    method name (line 547) | pub fn name(&self) -> &MultiName {
    method rename_all_rules (line 551) | pub fn rename_all_rules(&self) -> RenameAllRules {
    method rename_all_fields_rules (line 555) | pub fn rename_all_fields_rules(&self) -> RenameAllRules {
    method transparent (line 559) | pub fn transparent(&self) -> bool {
    method deny_unknown_fields (line 563) | pub fn deny_unknown_fields(&self) -> bool {
    method default (line 567) | pub fn default(&self) -> &Default {
    method ser_bound (line 571) | pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
    method de_bound (line 575) | pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
    method tag (line 579) | pub fn tag(&self) -> &TagType {
    method type_from (line 583) | pub fn type_from(&self) -> Option<&syn::Type> {
    method type_try_from (line 587) | pub fn type_try_from(&self) -> Option<&syn::Type> {
    method type_into (line 591) | pub fn type_into(&self) -> Option<&syn::Type> {
    method remote (line 595) | pub fn remote(&self) -> Option<&syn::Path> {
    method is_packed (line 599) | pub fn is_packed(&self) -> bool {
    method identifier (line 603) | pub fn identifier(&self) -> Identifier {
    method custom_serde_path (line 607) | pub fn custom_serde_path(&self) -> Option<&syn::Path> {
    method expecting (line 613) | pub fn expecting(&self) -> Option<&str> {
    method non_exhaustive (line 617) | pub fn non_exhaustive(&self) -> bool {
  type TagType (line 178) | pub enum TagType {
  type Identifier (line 211) | pub enum Identifier {
    method is_some (line 227) | pub fn is_some(self) -> bool {
  function decide_tag (line 622) | fn decide_tag(
  function decide_identifier (line 683) | fn decide_identifier(
  type Variant (line 728) | pub struct Variant {
    method from_ast (line 748) | pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
    method name (line 917) | pub fn name(&self) -> &MultiName {
    method aliases (line 921) | pub fn aliases(&self) -> &BTreeSet<Name> {
    method rename_by_rules (line 925) | pub fn rename_by_rules(&mut self, rules: RenameAllRules) {
    method rename_all_rules (line 940) | pub fn rename_all_rules(&self) -> RenameAllRules {
    method ser_bound (line 944) | pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
    method de_bound (line 948) | pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
    method skip_deserializing (line 952) | pub fn skip_deserializing(&self) -> bool {
    method skip_serializing (line 956) | pub fn skip_serializing(&self) -> bool {
    method other (line 960) | pub fn other(&self) -> bool {
    method serialize_with (line 964) | pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
    method deserialize_with (line 968) | pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
    method untagged (line 972) | pub fn untagged(&self) -> bool {
  type BorrowAttribute (line 742) | struct BorrowAttribute {
  type Field (line 978) | pub struct Field {
    method from_ast (line 1015) | pub fn from_ast(
    method name (line 1264) | pub fn name(&self) -> &MultiName {
    method aliases (line 1268) | pub fn aliases(&self) -> &BTreeSet<Name> {
    method rename_by_rules (line 1272) | pub fn rename_by_rules(&mut self, rules: RenameAllRules) {
    method skip_serializing (line 1286) | pub fn skip_serializing(&self) -> bool {
    method skip_deserializing (line 1290) | pub fn skip_deserializing(&self) -> bool {
    method skip_serializing_if (line 1294) | pub fn skip_serializing_if(&self) -> Option<&syn::ExprPath> {
    method default (line 1298) | pub fn default(&self) -> &Default {
    method serialize_with (line 1302) | pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
    method deserialize_with (line 1306) | pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
    method ser_bound (line 1310) | pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
    method de_bound (line 1314) | pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
    method borrowed_lifetimes (line 1318) | pub fn borrowed_lifetimes(&self) -> &BTreeSet<syn::Lifetime> {
    method getter (line 1322) | pub fn getter(&self) -> Option<&syn::ExprPath> {
    method flatten (line 1326) | pub fn flatten(&self) -> bool {
    method transparent (line 1330) | pub fn transparent(&self) -> bool {
    method mark_transparent (line 1334) | pub fn mark_transparent(&mut self) {
  type Default (line 995) | pub enum Default {
    method is_none (line 1005) | pub fn is_none(&self) -> bool {
  type SerAndDe (line 1339) | type SerAndDe<T> = (Option<T>, Option<T>);
  function get_ser_and_de (line 1341) | fn get_ser_and_de<'c, T, F, R>(
  function get_renames (line 1386) | fn get_renames(
  function get_multiple_renames (line 1395) | fn get_multiple_renames(
  function get_where_predicates (line 1403) | fn get_where_predicates(
  function get_lit_str (line 1411) | fn get_lit_str(
  function get_lit_str2 (line 1419) | fn get_lit_str2(
  function parse_lit_into_path (line 1455) | fn parse_lit_into_path(
  function parse_lit_into_expr_path (line 1476) | fn parse_lit_into_expr_path(
  function parse_lit_into_where (line 1497) | fn parse_lit_into_where(
  function parse_lit_into_ty (line 1518) | fn parse_lit_into_ty(
  function parse_lit_into_lifetimes (line 1541) | fn parse_lit_into_lifetimes(
  function is_implicitly_borrowed (line 1579) | fn is_implicitly_borrowed(ty: &syn::Type) -> bool {
  function is_implicitly_borrowed_reference (line 1583) | fn is_implicitly_borrowed_reference(ty: &syn::Type) -> bool {
  function is_cow (line 1609) | fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
  function is_option (line 1633) | fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
  function is_reference (line 1677) | fn is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
  function is_str (line 1684) | fn is_str(ty: &syn::Type) -> bool {
  function is_slice_u8 (line 1688) | fn is_slice_u8(ty: &syn::Type) -> bool {
  function is_primitive_type (line 1695) | fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
  function is_primitive_path (line 1702) | fn is_primitive_path(path: &syn::Path, primitive: &str) -> bool {
  function borrowable_lifetimes (line 1716) | fn borrowable_lifetimes(
  function collect_lifetimes (line 1732) | fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
  function collect_lifetimes_from_tokens (line 1799) | fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet...

FILE: serde_derive/src/internals/case.rs
  type RenameRule (line 9) | pub enum RenameRule {
    method from_str (line 45) | pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
    method apply_to_variant (line 57) | pub fn apply_to_variant(self, variant: &str) -> String {
    method apply_to_field (line 82) | pub fn apply_to_field(self, field: &str) -> String {
    method or (line 112) | pub fn or(self, rule_b: Self) -> Self {
  type ParseError (line 120) | pub struct ParseError<'a> {
  method fmt (line 125) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function rename_variants (line 140) | fn rename_variants() {
  function rename_fields (line 174) | fn rename_fields() {

FILE: serde_derive/src/internals/check.rs
  function check (line 8) | pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
  function check_default_on_tuple (line 27) | fn check_default_on_tuple(cx: &Ctxt, cont: &Container) {
  function check_remote_generic (line 66) | fn check_remote_generic(cx: &Ctxt, cont: &Container) {
  function check_getter (line 78) | fn check_getter(cx: &Ctxt, cont: &Container) {
  function check_flatten (line 100) | fn check_flatten(cx: &Ctxt, cont: &Container) {
  function check_flatten_field (line 117) | fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
  function check_identifier (line 144) | fn check_identifier(cx: &Ctxt, cont: &Container) {
  function check_variant_skip_attrs (line 226) | fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
  function check_internal_tag_field_name_conflict (line 300) | fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
  function check_adjacent_tag_conflict (line 352) | fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
  function check_transparent (line 370) | fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
  function member_message (line 448) | fn member_message(member: &Member) -> String {
  function allow_transparent (line 455) | fn allow_transparent(field: &Field, derive: Derive) -> bool {
  function check_from_and_try_from (line 470) | fn check_from_and_try_from(cx: &Ctxt, cont: &mut Container) {

FILE: serde_derive/src/internals/ctxt.rs
  type Ctxt (line 12) | pub struct Ctxt {
    method new (line 22) | pub fn new() -> Self {
    method error_spanned_by (line 31) | pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
    method syn_error (line 41) | pub fn syn_error(&self, err: syn::Error) {
    method check (line 46) | pub fn check(self) -> syn::Result<()> {
  method drop (line 62) | fn drop(&mut self) {

FILE: serde_derive/src/internals/mod.rs
  type Derive (line 18) | pub enum Derive {
  function ungroup (line 23) | pub fn ungroup(mut ty: &Type) -> &Type {

FILE: serde_derive/src/internals/name.rs
  type MultiName (line 9) | pub struct MultiName {
    method from_attrs (line 18) | pub(crate) fn from_attrs(
    method serialize_name (line 45) | pub fn serialize_name(&self) -> &Name {
    method deserialize_name (line 50) | pub fn deserialize_name(&self) -> &Name {
    method deserialize_aliases (line 54) | pub(crate) fn deserialize_aliases(&self) -> &BTreeSet<Name> {
  type Name (line 60) | pub struct Name {
    method from (line 92) | fn from(ident: &Ident) -> Self {
    method from (line 101) | fn from(lit: &LitStr) -> Self {
  method to_tokens (line 66) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method cmp (line 72) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 78) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 86) | fn eq(&self, other: &Self) -> bool {
  method fmt (line 110) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

FILE: serde_derive/src/internals/receiver.rs
  function replace_receiver (line 10) | pub fn replace_receiver(input: &mut DeriveInput) {
  type ReplaceReceiver (line 21) | struct ReplaceReceiver<'a>(&'a TypePath);
  function self_ty (line 24) | fn self_ty(&self, span: Span) -> TypePath {
  function self_to_qself (line 30) | fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
  function self_to_expr_path (line 55) | fn self_to_expr_path(&self, path: &mut Path) {
  function visit_type_mut (line 74) | fn visit_type_mut(&mut self, ty: &mut Type) {
  function visit_type_path_mut (line 90) | fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
  function visit_expr_path_mut (line 98) | fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
  function visit_type_mut_impl (line 107) | fn visit_type_mut_impl(&mut self, ty: &mut Type) {
  function visit_type_path_mut_impl (line 154) | fn visit_type_path_mut_impl(&mut self, ty: &mut TypePath) {
  function visit_expr_path_mut_impl (line 161) | fn visit_expr_path_mut_impl(&mut self, expr: &mut ExprPath) {
  function visit_path_mut (line 168) | fn visit_path_mut(&mut self, path: &mut Path) {
  function visit_path_arguments_mut (line 174) | fn visit_path_arguments_mut(&mut self, arguments: &mut PathArguments) {
  function visit_return_type_mut (line 200) | fn visit_return_type_mut(&mut self, return_type: &mut ReturnType) {
  function visit_type_param_bound_mut (line 207) | fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
  function visit_generics_mut (line 218) | fn visit_generics_mut(&mut self, generics: &mut Generics) {
  function visit_data_mut (line 246) | fn visit_data_mut(&mut self, data: &mut Data) {
  function visit_expr_mut (line 264) | fn visit_expr_mut(&mut self, expr: &mut Expr) {
  function visit_macro_mut (line 292) | fn visit_macro_mut(&mut self, _mac: &mut Macro) {}

FILE: serde_derive/src/internals/respan.rs
  function respan (line 3) | pub(crate) fn respan(stream: TokenStream, span: Span) -> TokenStream {
  function respan_token (line 10) | fn respan_token(mut token: TokenTree, span: Span) -> TokenTree {

FILE: serde_derive/src/internals/symbol.rs
  type Symbol (line 5) | pub struct Symbol(&'static str);
  constant ALIAS (line 7) | pub const ALIAS: Symbol = Symbol("alias");
  constant BORROW (line 8) | pub const BORROW: Symbol = Symbol("borrow");
  constant BOUND (line 9) | pub const BOUND: Symbol = Symbol("bound");
  constant CONTENT (line 10) | pub const CONTENT: Symbol = Symbol("content");
  constant CRATE (line 11) | pub const CRATE: Symbol = Symbol("crate");
  constant DEFAULT (line 12) | pub const DEFAULT: Symbol = Symbol("default");
  constant DENY_UNKNOWN_FIELDS (line 13) | pub const DENY_UNKNOWN_FIELDS: Symbol = Symbol("deny_unknown_fields");
  constant DESERIALIZE (line 14) | pub const DESERIALIZE: Symbol = Symbol("deserialize");
  constant DESERIALIZE_WITH (line 15) | pub const DESERIALIZE_WITH: Symbol = Symbol("deserialize_with");
  constant EXPECTING (line 16) | pub const EXPECTING: Symbol = Symbol("expecting");
  constant FIELD_IDENTIFIER (line 17) | pub const FIELD_IDENTIFIER: Symbol = Symbol("field_identifier");
  constant FLATTEN (line 18) | pub const FLATTEN: Symbol = Symbol("flatten");
  constant FROM (line 19) | pub const FROM: Symbol = Symbol("from");
  constant GETTER (line 20) | pub const GETTER: Symbol = Symbol("getter");
  constant INTO (line 21) | pub const INTO: Symbol = Symbol("into");
  constant NON_EXHAUSTIVE (line 22) | pub const NON_EXHAUSTIVE: Symbol = Symbol("non_exhaustive");
  constant OTHER (line 23) | pub const OTHER: Symbol = Symbol("other");
  constant REMOTE (line 24) | pub const REMOTE: Symbol = Symbol("remote");
  constant RENAME (line 25) | pub const RENAME: Symbol = Symbol("rename");
  constant RENAME_ALL (line 26) | pub const RENAME_ALL: Symbol = Symbol("rename_all");
  constant RENAME_ALL_FIELDS (line 27) | pub const RENAME_ALL_FIELDS: Symbol = Symbol("rename_all_fields");
  constant REPR (line 28) | pub const REPR: Symbol = Symbol("repr");
  constant SERDE (line 29) | pub const SERDE: Symbol = Symbol("serde");
  constant SERIALIZE (line 30) | pub const SERIALIZE: Symbol = Symbol("serialize");
  constant SERIALIZE_WITH (line 31) | pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with");
  constant SKIP (line 32) | pub const SKIP: Symbol = Symbol("skip");
  constant SKIP_DESERIALIZING (line 33) | pub const SKIP_DESERIALIZING: Symbol = Symbol("skip_deserializing");
  constant SKIP_SERIALIZING (line 34) | pub const SKIP_SERIALIZING: Symbol = Symbol("skip_serializing");
  constant SKIP_SERIALIZING_IF (line 35) | pub const SKIP_SERIALIZING_IF: Symbol = Symbol("skip_serializing_if");
  constant TAG (line 36) | pub const TAG: Symbol = Symbol("tag");
  constant TRANSPARENT (line 37) | pub const TRANSPARENT: Symbol = Symbol("transparent");
  constant TRY_FROM (line 38) | pub const TRY_FROM: Symbol = Symbol("try_from");
  constant UNTAGGED (line 39) | pub const UNTAGGED: Symbol = Symbol("untagged");
  constant VARIANT_IDENTIFIER (line 40) | pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
  constant WITH (line 41) | pub const WITH: Symbol = Symbol("with");
  method eq (line 44) | fn eq(&self, word: &Symbol) -> bool {
  function eq (line 50) | fn eq(&self, word: &Symbol) -> bool {
  method eq (line 56) | fn eq(&self, word: &Symbol) -> bool {
  function eq (line 62) | fn eq(&self, word: &Symbol) -> bool {
  method fmt (line 68) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

FILE: serde_derive/src/lib.rs
  type private (line 96) | struct private;
    method ident (line 99) | fn ident(&self) -> Ident {
  method to_tokens (line 108) | fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
  function derive_serialize (line 114) | pub fn derive_serialize(input: TokenStream) -> TokenStream {
  function derive_deserialize (line 122) | pub fn derive_deserialize(input: TokenStream) -> TokenStream {

FILE: serde_derive/src/pretend.rs
  function pretend_used (line 23) | pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
  function pretend_fields_used (line 65) | fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
  function pretend_fields_used_struct (line 79) | fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> Tok...
  function pretend_fields_used_struct_packed (line 94) | fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field])...
  function pretend_fields_used_enum (line 113) | fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> T...
  function pretend_variants_used (line 150) | fn pretend_variants_used(cont: &Container) -> TokenStream {

FILE: serde_derive/src/ser.rs
  function expand_derive_serialize (line 13) | pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Res...
  function precondition (line 66) | fn precondition(cx: &Ctxt, cont: &Container) {
  type Parameters (line 78) | struct Parameters {
    method new (line 103) | fn new(cont: &Container) -> Self {
    method type_name (line 128) | fn type_name(&self) -> String {
  function build_generics (line 135) | fn build_generics(cont: &Container) -> syn::Generics {
  function needs_serialize_bound (line 160) | fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Var...
  function serialize_body (line 171) | fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
  function serialize_transparent (line 191) | fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragm...
  function serialize_into (line 214) | fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
  function serialize_unit_struct (line 223) | fn serialize_unit_struct(cattrs: &attr::Container) -> Fragment {
  function serialize_newtype_struct (line 231) | fn serialize_newtype_struct(
  function serialize_tuple_struct (line 257) | fn serialize_tuple_struct(
  function serialize_struct (line 296) | fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr...
  function serialize_struct_tag_field (line 315) | fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &S...
  function serialize_struct_as_struct (line 328) | fn serialize_struct_as_struct(
  function serialize_struct_as_map (line 369) | fn serialize_struct_as_map(
  function serialize_enum (line 395) | fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &at...
  function serialize_variant (line 421) | fn serialize_variant(
  function serialize_externally_tagged_variant (line 502) | fn serialize_externally_tagged_variant(
  function serialize_internally_tagged_variant (line 575) | fn serialize_internally_tagged_variant(
  function serialize_adjacently_tagged_variant (line 641) | fn serialize_adjacently_tagged_variant(
  function serialize_untagged_variant (line 765) | fn serialize_untagged_variant(
  type TupleVariant (line 804) | enum TupleVariant<'a> {
  function serialize_tuple_variant (line 813) | fn serialize_tuple_variant(
  type StructVariant (line 872) | enum StructVariant<'a> {
  function serialize_struct_variant (line 884) | fn serialize_struct_variant(
  function serialize_struct_variant_with_flatten (line 968) | fn serialize_struct_variant_with_flatten(
  function serialize_tuple_struct_visitor (line 1056) | fn serialize_tuple_struct_visitor(
  function serialize_struct_visitor (line 1105) | fn serialize_struct_visitor(
  function wrap_serialize_field_with (line 1173) | fn wrap_serialize_field_with(
  function wrap_serialize_variant_with (line 1182) | fn wrap_serialize_variant_with(
  function wrap_serialize_with (line 1207) | fn wrap_serialize_with(
  function mut_if (line 1271) | fn mut_if(is_mut: bool) -> Option<TokenStream> {
  function get_member (line 1279) | fn get_member(params: &Parameters, field: &Field, member: &Member) -> To...
  function effective_style (line 1308) | fn effective_style(variant: &Variant) -> Style {
  type StructTrait (line 1315) | enum StructTrait {
    method serialize_field (line 1322) | fn serialize_field(&self, span: Span) -> TokenStream {
    method skip_field (line 1336) | fn skip_field(&self, span: Span) -> Option<TokenStream> {
  type TupleTrait (line 1349) | enum TupleTrait {
    method serialize_element (line 1356) | fn serialize_element(&self, span: Span) -> TokenStream {

FILE: serde_derive/src/this.rs
  function this_type (line 4) | pub fn this_type(cont: &Container) -> Path {
  function this_value (line 18) | pub fn this_value(cont: &Container) -> Path {

FILE: serde_derive_internals/build.rs
  function main (line 3) | fn main() {

FILE: test_suite/no_std/src/main.rs
  function main (line 7) | extern "C" fn main(_argc: c_int, _argv: *const *const u8) -> c_int {
  function panic (line 12) | fn panic(_info: &core::panic::PanicInfo) -> ! {
  type Unit (line 23) | pub struct Unit;
  type Newtype (line 26) | pub struct Newtype(u8);
  type Tuple (line 29) | pub struct Tuple(u8, u8);
  type Struct (line 32) | pub struct Struct {
  type Enum (line 37) | pub enum Enum {

FILE: test_suite/tests/bytes/mod.rs
  function deserialize (line 4) | pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
  type ByteBufVisitor (line 11) | struct ByteBufVisitor;
    type Value (line 14) | type Value = Vec<u8>;
    method expecting (line 16) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_seq (line 20) | fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
    method visit_bytes (line 31) | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    method visit_byte_buf (line 38) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    method visit_str (line 45) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    method visit_string (line 52) | fn visit_string<E>(self, v: String) -> Result<Self::Value, E>

FILE: test_suite/tests/compiletest.rs
  function ui (line 6) | fn ui() {

FILE: test_suite/tests/macros/mod.rs
  type SingleTokenIntoIterator (line 60) | pub trait SingleTokenIntoIterator {
    method into_iter (line 61) | fn into_iter(self) -> iter::Once<Token>;
    method into_iter (line 65) | fn into_iter(self) -> iter::Once<Token> {

FILE: test_suite/tests/regression/issue1904.rs
  type Nested (line 6) | pub struct Nested;
  type ExternallyTagged1 (line 9) | pub enum ExternallyTagged1 {
  type ExternallyTagged2 (line 18) | pub enum ExternallyTagged2 {
  type AdjacentlyTagged1 (line 30) | pub enum AdjacentlyTagged1 {
  type AdjacentlyTagged2 (line 40) | pub enum AdjacentlyTagged2 {
  type Untagged1 (line 50) | pub enum Untagged1 {
  type Untagged2 (line 60) | pub enum Untagged2 {

FILE: test_suite/tests/regression/issue2371.rs
  type Nested (line 6) | pub struct Nested;
  type ExternallyTagged (line 9) | pub enum ExternallyTagged {
  type InternallyTagged (line 21) | pub enum InternallyTagged {
  type AdjacentlyTagged (line 33) | pub enum AdjacentlyTagged {
  type UntaggedWorkaround (line 45) | pub enum UntaggedWorkaround {

FILE: test_suite/tests/regression/issue2415.rs
  type S (line 6) | pub struct S;

FILE: test_suite/tests/regression/issue2565.rs
  type Enum (line 5) | enum Enum {
  function simple_variant (line 17) | fn simple_variant() {
  function flatten_variant (line 34) | fn flatten_variant() {

FILE: test_suite/tests/regression/issue2792.rs
  type A (line 7) | pub enum A {
  type E (line 18) | pub struct E {}

FILE: test_suite/tests/regression/issue2844.rs
  function serialize (line 20) | pub fn serialize<S>(_: &i32, _: S) -> Result<S::Ok, S::Error>
  function deserialize (line 27) | pub fn deserialize<'de, D>(_: D) -> Result<i32, D::Error>

FILE: test_suite/tests/regression/issue2846.rs
  function deserialize (line 21) | pub fn deserialize<'de, D>(_: D) -> Result<i32, D::Error>

FILE: test_suite/tests/test_annotations.rs
  type MyDefault (line 25) | trait MyDefault: Sized {
    method my_default (line 26) | fn my_default() -> Self;
    method my_default (line 46) | fn my_default() -> Self {
    method my_default (line 313) | fn my_default() -> Self {
    method my_default (line 384) | fn my_default() -> Self {
  type ShouldSkip (line 29) | trait ShouldSkip: Sized {
    method should_skip (line 30) | fn should_skip(&self) -> bool;
    method should_skip (line 52) | fn should_skip(&self) -> bool {
  type SerializeWith (line 33) | trait SerializeWith: Sized {
    method serialize_with (line 34) | fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    method serialize_with (line 58) | fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
    method serialize_with (line 1021) | fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
  type DeserializeWith (line 39) | trait DeserializeWith: Sized {
    method deserialize_with (line 40) | fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
    method deserialize_with (line 71) | fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
    method deserialize_with (line 369) | fn deserialize_with<'de, D>(_: D) -> Result<Self, D::Error>
  type DefaultStruct (line 84) | struct DefaultStruct<A, B, C, D, E>
  type DefaultTupleStruct (line 101) | struct DefaultTupleStruct<A, B, C>(
  type CollectOther (line 110) | struct CollectOther {
  function test_default_struct (line 118) | fn test_default_struct() {
  function test_default_tuple (line 167) | fn test_default_tuple() {
  type DefaultStructVariant (line 196) | enum DefaultStructVariant<A, B, C, D, E>
  type DefaultTupleVariant (line 215) | enum DefaultTupleVariant<A, B, C>
  function test_default_struct_variant (line 227) | fn test_default_struct_variant() {
  function test_default_tuple_variant (line 278) | fn test_default_tuple_variant() {
  type NoStdDefault (line 310) | struct NoStdDefault(i8);
  type ContainsNoStdDefault (line 319) | struct ContainsNoStdDefault<A: MyDefault> {
  function test_no_std_default (line 327) | fn test_no_std_default() {
  type NotDeserializeStruct (line 360) | struct NotDeserializeStruct(i8);
  method default (line 363) | fn default() -> Self {
  type NotDeserializeEnum (line 379) | enum NotDeserializeEnum {
  type ContainsNotDeserialize (line 390) | struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
  function test_elt_not_deserialize (line 405) | fn test_elt_not_deserialize() {
  type DenyUnknown (line 425) | struct DenyUnknown {
  function test_ignore_unknown (line 430) | fn test_ignore_unknown() {
  type RenameStruct (line 479) | struct RenameStruct {
  type RenameStructSerializeDeserialize (line 487) | struct RenameStructSerializeDeserialize {
  type AliasStruct (line 495) | struct AliasStruct {
  function test_rename_struct (line 504) | fn test_rename_struct() {
  function test_unknown_field_rename_struct (line 594) | fn test_unknown_field_rename_struct() {
  type RenameEnum (line 614) | enum RenameEnum {
  type RenameEnumSerializeDeserialize (line 630) | enum RenameEnumSerializeDeserialize<A> {
  type AliasEnum (line 642) | enum AliasEnum {
  function test_rename_enum (line 654) | fn test_rename_enum() {
  function test_unknown_field_rename_enum (line 778) | fn test_unknown_field_rename_enum() {
  type SkipSerializingStruct (line 807) | struct SkipSerializingStruct<'a, B, C>
  function test_skip_serializing_struct (line 819) | fn test_skip_serializing_struct() {
  type SkipSerializingTupleStruct (line 855) | struct SkipSerializingTupleStruct<'a, B, C>(
  function test_skip_serializing_tuple_struct (line 864) | fn test_skip_serializing_tuple_struct() {
  type SkipStruct (line 893) | struct SkipStruct<B> {
  function test_skip_struct (line 900) | fn test_skip_struct() {
  type SkipSerializingEnum (line 929) | enum SkipSerializingEnum<'a, B, C>
  function test_skip_serializing_enum (line 948) | fn test_skip_serializing_enum() {
  type NotSerializeStruct (line 1013) | struct NotSerializeStruct(i8);
  type NotSerializeEnum (line 1016) | enum NotSerializeEnum {
  type ContainsNotSerialize (line 1030) | struct ContainsNotSerialize<'a, B, C, D>
  function test_elt_not_serialize (line 1045) | fn test_elt_not_serialize() {
  type SerializeWithStruct (line 1070) | struct SerializeWithStruct<'a, B>
  function test_serialize_with_struct (line 1080) | fn test_serialize_with_struct() {
  type SerializeWithEnum (line 1114) | enum SerializeWithEnum<'a, B>
  function test_serialize_with_enum (line 1126) | fn test_serialize_with_enum() {
  type WithVariant (line 1162) | enum WithVariant {
  function serialize_unit_variant_as_i8 (line 1180) | fn serialize_unit_variant_as_i8<S>(serializer: S) -> Result<S::Ok, S::Er...
  function deserialize_i8_as_unit_variant (line 1187) | fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(),...
  function serialize_variant_as_string (line 1198) | fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> R...
  function deserialize_string_as_variant (line 1205) | fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(Str...
  function test_serialize_with_variant (line 1227) | fn test_serialize_with_variant() {
  function test_deserialize_with_variant (line 1277) | fn test_deserialize_with_variant() {
  type DeserializeWithStruct (line 1327) | struct DeserializeWithStruct<B>
  function test_deserialize_with_struct (line 1337) | fn test_deserialize_with_struct() {
  type DeserializeWithEnum (line 1370) | enum DeserializeWithEnum<B>
  function test_deserialize_with_enum (line 1382) | fn test_deserialize_with_enum() {
  function test_missing_renamed_field_struct (line 1417) | fn test_missing_renamed_field_struct() {
  function test_missing_renamed_field_enum (line 1446) | fn test_missing_renamed_field_enum() {
  type InvalidLengthEnum (line 1475) | enum InvalidLengthEnum {
  function test_invalid_length_enum (line 1481) | fn test_invalid_length_enum() {
  type StructFromEnum (line 1510) | struct StructFromEnum(Option<u32>);
    method into (line 1513) | fn into(self) -> EnumToU32 {
    method from (line 1521) | fn from(v: EnumToU32) -> Self {
  type EnumToU32 (line 1528) | enum EnumToU32 {
    method into (line 1537) | fn into(self) -> Option<u32> {
    method from (line 1549) | fn from(v: Option<u32>) -> Self {
  type TryFromU32 (line 1562) | enum TryFromU32 {
    type Error (line 1568) | type Error = String;
    method try_from (line 1570) | fn try_from(value: u32) -> Result<Self, Self::Error> {
  function test_from_into_traits (line 1580) | fn test_from_into_traits() {
  function test_collect_other (line 1592) | fn test_collect_other() {
  function test_partially_untagged_enum (line 1611) | fn test_partially_untagged_enum() {
  function test_partially_untagged_enum_generic (line 1642) | fn test_partially_untagged_enum_generic() {
  function test_partially_untagged_enum_desugared (line 1681) | fn test_partially_untagged_enum_desugared() {
  function test_partially_untagged_internally_tagged_enum (line 1767) | fn test_partially_untagged_internally_tagged_enum() {
  function test_transparent_struct (line 1797) | fn test_transparent_struct() {
  function test_transparent_tuple_struct (line 1821) | fn test_transparent_tuple_struct() {
  function test_expecting_message (line 1835) | fn test_expecting_message() {
  function test_expecting_message_externally_tagged_enum (line 1879) | fn test_expecting_message_externally_tagged_enum() {
  function test_expecting_message_identifier_enum (line 1899) | fn test_expecting_message_identifier_enum() {
  function complex (line 1949) | fn complex() {
  function map_twice (line 2053) | fn map_twice() {
  function unsupported_type (line 2096) | fn unsupported_type() {
  function unknown_field (line 2130) | fn unknown_field() {
  function non_string_keys (line 2168) | fn non_string_keys() {
  function lifetime_propagation (line 2199) | fn lifetime_propagation() {
  function enum_tuple_and_struct (line 2283) | fn enum_tuple_and_struct() {
  function option (line 2332) | fn option() {
  function ignored_any (line 2402) | fn ignored_any() {
  function flatten_any_after_flatten_struct (line 2427) | fn flatten_any_after_flatten_struct() {
  function alias (line 2488) | fn alias() {
  function unit (line 2553) | fn unit() {
  function unit_struct (line 2576) | fn unit_struct() {
  function straightforward (line 2610) | fn straightforward() {
  type Flatten (line 2648) | struct Flatten {
  type Enum (line 2657) | enum Enum {
  function unit (line 2665) | fn unit() {
  function newtype (line 2699) | fn newtype() {
  function tuple (line 2742) | fn tuple() {
  function struct_from_seq (line 2785) | fn struct_from_seq() {
  function struct_from_map (line 2831) | fn struct_from_map() {
  type Flatten (line 2888) | struct Flatten {
  type NewtypeWrapper (line 2896) | struct NewtypeWrapper(pub Enum);
  type Enum (line 2900) | enum Enum {
  type NewtypeVariant (line 2907) | struct NewtypeVariant {
  function unit (line 2912) | fn unit() {
  function newtype (line 3076) | fn newtype() {
  function struct_ (line 3240) | fn struct_() {
  function structs (line 3423) | fn structs() {
  function unit_enum_with_unknown_fields (line 3487) | fn unit_enum_with_unknown_fields() {
  type Flatten (line 3549) | struct Flatten {
  type Enum (line 3556) | enum Enum {
  function struct_ (line 3561) | fn struct_() {

FILE: test_suite/tests/test_borrow.rs
  function test_borrowed_str (line 17) | fn test_borrowed_str() {
  function test_borrowed_str_from_string (line 22) | fn test_borrowed_str_from_string() {
  function test_borrowed_str_from_str (line 30) | fn test_borrowed_str_from_str() {
  function test_string_from_borrowed_str (line 38) | fn test_string_from_borrowed_str() {
  function test_borrowed_bytes (line 43) | fn test_borrowed_bytes() {
  function test_borrowed_bytes_from_bytebuf (line 48) | fn test_borrowed_bytes_from_bytebuf() {
  function test_borrowed_bytes_from_bytes (line 56) | fn test_borrowed_bytes_from_bytes() {
  function test_tuple (line 64) | fn test_tuple() {
  function test_struct (line 77) | fn test_struct() {
  function test_field_identifier (line 104) | fn test_field_identifier() {
  function test_cow (line 128) | fn test_cow() {
  function test_lifetimes (line 166) | fn test_lifetimes() {

FILE: test_suite/tests/test_de.rs
  type UnitStruct (line 45) | struct UnitStruct;
  type GenericUnitStruct (line 48) | struct GenericUnitStruct<const N: u8>;
  type NewtypeStruct (line 51) | struct NewtypeStruct(i32);
  type TupleStruct (line 54) | struct TupleStruct(i32, i32, i32);
  type Struct (line 57) | struct Struct {
  type StructDefault (line 66) | struct StructDefault<T> {
  method default (line 72) | fn default() -> Self {
  type StructSkipAll (line 81) | struct StructSkipAll {
  type StructSkipDefault (line 88) | struct StructSkipDefault {
  type StructSkipDefaultGeneric (line 95) | pub struct StructSkipDefaultGeneric<T> {
  method default (line 101) | fn default() -> Self {
  type StructSkipAllDenyUnknown (line 108) | struct StructSkipAllDenyUnknown {
  type NotDeserializable (line 114) | struct NotDeserializable;
  type Enum (line 117) | enum Enum {
  type EnumOther (line 133) | enum EnumOther {
  type IgnoredAny (line 140) | struct IgnoredAny;
    method deserialize (line 143) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function test (line 155) | fn test<'de, T>(value: T, tokens: &'de [Token])
  type SkipPartialEq (line 167) | struct SkipPartialEq<T>(T);
  function deserialize (line 173) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method eq (line 182) | fn eq(&self, _other: &Self) -> bool {
  function assert_de_tokens_ignore (line 188) | fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
  function test_bool (line 214) | fn test_bool() {
  function test_i8 (line 220) | fn test_i8() {
  function test_i16 (line 245) | fn test_i16() {
  function test_i32 (line 270) | fn test_i32() {
  function test_i64 (line 295) | fn test_i64() {
  function test_i128 (line 320) | fn test_i128() {
  function test_isize (line 345) | fn test_isize() {
  function test_u8 (line 370) | fn test_u8() {
  function test_u16 (line 395) | fn test_u16() {
  function test_u32 (line 420) | fn test_u32() {
  function test_u64 (line 445) | fn test_u64() {
  function test_u128 (line 470) | fn test_u128() {
  function test_usize (line 495) | fn test_usize() {
  function test_nonzero_i8 (line 520) | fn test_nonzero_i8() {
  function test_nonzero_i16 (line 545) | fn test_nonzero_i16() {
  function test_nonzero_i32 (line 570) | fn test_nonzero_i32() {
  function test_nonzero_i64 (line 595) | fn test_nonzero_i64() {
  function test_nonzero_i128 (line 620) | fn test_nonzero_i128() {
  function test_nonzero_isize (line 645) | fn test_nonzero_isize() {
  function test_nonzero_u8 (line 670) | fn test_nonzero_u8() {
  function test_nonzero_u16 (line 695) | fn test_nonzero_u16() {
  function test_nonzero_u32 (line 720) | fn test_nonzero_u32() {
  function test_nonzero_u64 (line 745) | fn test_nonzero_u64() {
  function test_nonzero_u128 (line 770) | fn test_nonzero_u128() {
  function test_nonzero_usize (line 795) | fn test_nonzero_usize() {
  function test_f32 (line 820) | fn test_f32() {
  function test_f64 (line 828) | fn test_f64() {
  function test_nan (line 836) | fn test_nan() {
  function test_char (line 856) | fn test_char() {
  function test_string (line 863) | fn test_string() {
  function test_option (line 870) | fn test_option() {
  function test_result (line 877) | fn test_result() {
  function test_unit (line 897) | fn test_unit() {
  function test_unit_struct (line 902) | fn test_unit_struct() {
  function test_generic_unit_struct (line 908) | fn test_generic_unit_struct() {
  function test_newtype_struct (line 919) | fn test_newtype_struct() {
  function test_tuple_struct (line 932) | fn test_tuple_struct() {
  function test_btreeset (line 982) | fn test_btreeset() {
  function test_hashset (line 1016) | fn test_hashset() {
  function test_vec (line 1054) | fn test_vec() {
  function test_array (line 1089) | fn test_array() {
  function test_tuple (line 1137) | fn test_tuple() {
  function test_btreemap (line 1169) | fn test_btreemap() {
  function test_hashmap (line 1224) | fn test_hashmap() {
  function test_struct (line 1290) | fn test_struct() {
  function test_struct_borrowed_keys (line 1395) | fn test_struct_borrowed_keys() {
  function test_struct_owned_keys (line 1424) | fn test_struct_owned_keys() {
  function test_struct_with_skip (line 1453) | fn test_struct_with_skip() {
  function test_struct_skip_all (line 1505) | fn test_struct_skip_all() {
  function test_struct_skip_default (line 1533) | fn test_struct_skip_default() {
  function test_struct_skip_all_deny_unknown (line 1547) | fn test_struct_skip_all_deny_unknown() {
  function test_struct_default (line 1561) | fn test_struct_default() {
  function test_enum_unit (line 1595) | fn test_enum_unit() {
  function test_enum_simple (line 1606) | fn test_enum_simple() {
  function test_enum_simple_with_skipped (line 1620) | fn test_enum_simple_with_skipped() {
  function test_enum_seq (line 1631) | fn test_enum_seq() {
  function test_enum_map (line 1649) | fn test_enum_map() {
  function test_enum_unit_usize (line 1670) | fn test_enum_unit_usize() {
  function test_enum_unit_bytes (line 1678) | fn test_enum_unit_bytes() {
  function test_enum_other_unit (line 1690) | fn test_enum_other_unit() {
  function test_enum_other (line 1730) | fn test_enum_other() {
  function test_box (line 1774) | fn test_box() {
  function test_boxed_slice (line 1779) | fn test_boxed_slice() {
  function test_duration (line 1793) | fn test_duration() {
  function test_system_time (line 1820) | fn test_system_time() {
  function test_range (line 1847) | fn test_range() {
  function test_range_inclusive (line 1874) | fn test_range_inclusive() {
  function test_range_from (line 1901) | fn test_range_from() {
  function test_range_to (line 1921) | fn test_range_to() {
  function test_bound (line 1941) | fn test_bound() {
  function test_path (line 1969) | fn test_path() {
  function test_path_buf (line 1981) | fn test_path_buf() {
  function test_boxed_path (line 2001) | fn test_boxed_path() {
  function test_cstring (line 2021) | fn test_cstring() {
  function test_rc (line 2026) | fn test_rc() {
  function test_rc_weak_some (line 2031) | fn test_rc_weak_some() {
  function test_rc_weak_none (line 2039) | fn test_rc_weak_none() {
  function test_arc (line 2044) | fn test_arc() {
  function test_arc_weak_some (line 2049) | fn test_arc_weak_some() {
  function test_arc_weak_none (line 2057) | fn test_arc_weak_none() {
  function test_wrapping (line 2062) | fn test_wrapping() {
  function test_saturating (line 2068) | fn test_saturating() {
  function test_rc_dst (line 2105) | fn test_rc_dst() {
  function test_arc_dst (line 2118) | fn test_arc_dst() {
  function test_ignored_any (line 2131) | fn test_ignored_any() {
  function test_net_ipv4addr_readable (line 2148) | fn test_net_ipv4addr_readable() {
  function test_net_ipv6addr_readable (line 2156) | fn test_net_ipv6addr_readable() {
  function test_net_ipaddr_readable (line 2164) | fn test_net_ipaddr_readable() {
  function test_net_socketaddr_readable (line 2172) | fn test_net_socketaddr_readable() {
  function test_net_ipv4addr_compact (line 2197) | fn test_net_ipv4addr_compact() {
  function test_net_ipv6addr_compact (line 2209) | fn test_net_ipv6addr_compact() {
  function test_net_ipaddr_compact (line 2221) | fn test_net_ipaddr_compact() {
  function test_net_socketaddr_compact (line 2237) | fn test_net_socketaddr_compact() {
  function test_never_result (line 2294) | fn test_never_result() {
  function test_osstring (line 2309) | fn test_osstring() {
  function test_osstring (line 2329) | fn test_osstring() {
  function test_cstr (line 2348) | fn test_cstr() {
  function test_atomics (line 2356) | fn test_atomics() {

FILE: test_suite/tests/test_de_error.rs
  type UnitStruct (line 20) | struct UnitStruct;
  type Struct (line 23) | struct Struct {
  type StructDenyUnknown (line 32) | struct StructDenyUnknown {
  type StructSkipAllDenyUnknown (line 40) | struct StructSkipAllDenyUnknown {
  type NotDeserializable (line 46) | struct NotDeserializable;
  type Enum (line 49) | enum Enum {
  type EnumSkipAll (line 65) | enum EnumSkipAll {
  function test_i8 (line 72) | fn test_i8() {
  function test_i16 (line 121) | fn test_i16() {
  function test_i32 (line 158) | fn test_i32() {
  function test_i64 (line 183) | fn test_i64() {
  function test_i128 (line 194) | fn test_i128() {
  function test_u8 (line 204) | fn test_u8() {
  function test_u16 (line 250) | fn test_u16() {
  function test_u32 (line 291) | fn test_u32() {
  function test_u64 (line 324) | fn test_u64() {
  function test_u128 (line 354) | fn test_u128() {
  function test_usize (line 384) | fn test_usize() {
  function test_nonzero_i8 (line 407) | fn test_nonzero_i8() {
  function test_nonzero_i16 (line 490) | fn test_nonzero_i16() {
  function test_nonzero_i32 (line 561) | fn test_nonzero_i32() {
  function test_nonzero_i64 (line 620) | fn test_nonzero_i64() {
  function test_nonzero_i128 (line 665) | fn test_nonzero_i128() {
  function test_nonzero_isize (line 704) | fn test_nonzero_isize() {
  function test_nonzero_u8 (line 743) | fn test_nonzero_u8() {
  function test_nonzero_u16 (line 826) | fn test_nonzero_u16() {
  function test_nonzero_u32 (line 901) | fn test_nonzero_u32() {
  function test_nonzero_u64 (line 968) | fn test_nonzero_u64() {
  function test_nonzero_u128 (line 1025) | fn test_nonzero_u128() {
  function test_nonzero_usize (line 1082) | fn test_nonzero_usize() {
  function test_unknown_field (line 1139) | fn test_unknown_field() {
  function test_skipped_field_is_unknown (line 1155) | fn test_skipped_field_is_unknown() {
  function test_skip_all_deny_unknown (line 1169) | fn test_skip_all_deny_unknown() {
  function test_unknown_variant (line 1183) | fn test_unknown_variant() {
  function test_enum_skipped_variant (line 1193) | fn test_enum_skipped_variant() {
  function test_enum_skip_all (line 1203) | fn test_enum_skip_all() {
  function test_duplicate_field_struct (line 1214) | fn test_duplicate_field_struct() {
  function test_duplicate_field_enum (line 1227) | fn test_duplicate_field_enum() {
  function test_enum_out_of_range (line 1244) | fn test_enum_out_of_range() {
  function test_short_tuple (line 1252) | fn test_short_tuple() {
  function test_short_array (line 1260) | fn test_short_array() {
  function test_cstring_internal_null (line 1268) | fn test_cstring_internal_null() {
  function test_cstring_internal_null_end (line 1276) | fn test_cstring_internal_null_end() {
  function test_unit_from_empty_seq (line 1284) | fn test_unit_from_empty_seq() {
  function test_unit_from_empty_seq_without_len (line 1292) | fn test_unit_from_empty_seq_without_len() {
  function test_unit_from_tuple_struct (line 1300) | fn test_unit_from_tuple_struct() {
  function test_string_from_unit (line 1314) | fn test_string_from_unit() {
  function test_btreeset_from_unit (line 1322) | fn test_btreeset_from_unit() {
  function test_btreeset_from_unit_struct (line 1330) | fn test_btreeset_from_unit_struct() {
  function test_hashset_from_unit (line 1338) | fn test_hashset_from_unit() {
  function test_hashset_from_unit_struct (line 1346) | fn test_hashset_from_unit_struct() {
  function test_vec_from_unit (line 1354) | fn test_vec_from_unit() {
  function test_vec_from_unit_struct (line 1362) | fn test_vec_from_unit_struct() {
  function test_zero_array_from_unit (line 1370) | fn test_zero_array_from_unit() {
  function test_zero_array_from_unit_struct (line 1378) | fn test_zero_array_from_unit_struct() {
  function test_btreemap_from_unit (line 1386) | fn test_btreemap_from_unit() {
  function test_btreemap_from_unit_struct (line 1394) | fn test_btreemap_from_unit_struct() {
  function test_hashmap_from_unit (line 1402) | fn test_hashmap_from_unit() {
  function test_hashmap_from_unit_struct (line 1410) | fn test_hashmap_from_unit_struct() {
  function test_bool_from_string (line 1418) | fn test_bool_from_string() {
  function test_number_from_string (line 1426) | fn test_number_from_string() {
  function test_integer_from_float (line 1434) | fn test_integer_from_float() {
  function test_nan_no_decimal_point (line 1442) | fn test_nan_no_decimal_point() {
  function test_unit_struct_from_seq (line 1450) | fn test_unit_struct_from_seq() {
  function test_wrapping_overflow (line 1458) | fn test_wrapping_overflow() {
  function test_duration_overflow_seq (line 1466) | fn test_duration_overflow_seq() {
  function test_duration_overflow_struct (line 1479) | fn test_duration_overflow_struct() {
  function test_systemtime_overflow_seq (line 1497) | fn test_systemtime_overflow_seq() {
  function test_systemtime_overflow_struct (line 1510) | fn test_systemtime_overflow_struct() {
  function test_systemtime_overflow (line 1528) | fn test_systemtime_overflow() {
  function test_cstr_internal_null (line 1541) | fn test_cstr_internal_null() {
  function test_cstr_internal_null_end (line 1549) | fn test_cstr_internal_null_end() {
  function test_never_type (line 1558) | fn test_never_type() {

FILE: test_suite/tests/test_deprecated.rs
  type DeprecatedEnum (line 8) | enum DeprecatedEnum {
  type DeprecatedStruct (line 15) | struct DeprecatedStruct {
  type DeprecatedVariant (line 20) | enum DeprecatedVariant {
  type DeprecatedField (line 27) | struct DeprecatedField {

FILE: test_suite/tests/test_enum_adjacently_tagged.rs
  type AdjacentlyTagged (line 14) | enum AdjacentlyTagged<T> {
  function map_str_tag_only (line 25) | fn map_str_tag_only() {
  function map_int_tag_only (line 62) | fn map_int_tag_only() {
  function map_bytes_tag_only (line 82) | fn map_bytes_tag_only() {
  function map_str_tag_content (line 119) | fn map_str_tag_content() {
  function map_int_tag_content (line 184) | fn map_int_tag_content() {
  function map_bytes_tag_content (line 225) | fn map_bytes_tag_content() {
  function seq_tag_content (line 266) | fn seq_tag_content() {
  function map_tag_only (line 309) | fn map_tag_only() {
  function map_tag_content (line 329) | fn map_tag_content() {
  function seq (line 372) | fn seq() {
  function newtype_with_newtype (line 414) | fn newtype_with_newtype() {
  function map (line 444) | fn map() {
  function seq (line 493) | fn seq() {
  function map (line 519) | fn map() {
  function seq (line 574) | fn seq() {
  function struct_with_flatten (line 600) | fn struct_with_flatten() {
  function expecting_message (line 646) | fn expecting_message() {
  function partially_untagged (line 672) | fn partially_untagged() {
  function deny_unknown_fields (line 704) | fn deny_unknown_fields() {

FILE: test_suite/tests/test_enum_internally_tagged.rs
  type Unit (line 17) | struct Unit;
  type Newtype (line 20) | struct Newtype(BTreeMap<String, String>);
  type Struct (line 23) | struct Struct {
  type Enum (line 28) | enum Enum {
  type InternallyTagged (line 37) | enum InternallyTagged {
  function unit (line 50) | fn unit() {
  function newtype_unit (line 114) | fn newtype_unit() {
  function newtype_unit_struct (line 163) | fn newtype_unit_struct() {
  function newtype_newtype (line 229) | fn newtype_newtype() {
  function newtype_map (line 242) | fn newtype_map() {
  function newtype_struct (line 331) | fn newtype_struct() {
  function unit (line 418) | fn unit() {
  function newtype (line 471) | fn newtype() {
  function tuple (line 524) | fn tuple() {
  function struct_ (line 604) | fn struct_() {
  function struct_ (line 744) | fn struct_() {
  function unit (line 879) | fn unit() {
  function wrong_tag (line 1041) | fn wrong_tag() {
  function untagged_variant (line 1068) | fn untagged_variant() {
  type InternallyTagged (line 1166) | enum InternallyTagged {
  function string_from_string (line 1177) | fn string_from_string() {
  function string_from_bytes (line 1214) | fn string_from_bytes() {
  function bytes_from_string (line 1251) | fn bytes_from_string() {
  function bytes_from_bytes (line 1284) | fn bytes_from_bytes() {
  function bytes_from_seq (line 1317) | fn bytes_from_seq() {
  function borrow (line 1338) | fn borrow() {
  function with_skipped_conflict (line 1362) | fn with_skipped_conflict() {
  function containing_flatten (line 1395) | fn containing_flatten() {
  function unit_variant_with_unknown_fields (line 1432) | fn unit_variant_with_unknown_fields() {
  function expecting_message (line 1460) | fn expecting_message() {

FILE: test_suite/tests/test_enum_untagged.rs
  function complex (line 16) | fn complex() {
  function newtype_unit_and_empty_map (line 90) | fn newtype_unit_and_empty_map() {
  function newtype_struct (line 109) | fn newtype_struct() {
  type Outer (line 142) | enum Outer {
  type Inner (line 147) | enum Inner {
  function unit (line 158) | fn unit() {
  function newtype (line 170) | fn newtype() {
  function tuple0 (line 185) | fn tuple0() {
  function tuple2 (line 201) | fn tuple2() {
  function struct_from_map (line 220) | fn struct_from_map() {
  function struct_from_seq (line 239) | fn struct_from_seq() {
  function empty_struct_from_map (line 259) | fn empty_struct_from_map() {
  function empty_struct_from_seq (line 278) | fn empty_struct_from_seq() {
  type Enum (line 300) | enum Enum {
  function some (line 306) | fn some() {
  function some_without_marker (line 323) | fn some_without_marker() {
  function none (line 339) | fn none() {
  function unit (line 355) | fn unit() {
  function string_and_bytes (line 369) | fn string_and_bytes() {
  function contains_flatten (line 511) | fn contains_flatten() {
  function contains_flatten_with_integer_key (line 546) | fn contains_flatten_with_integer_key() {
  function expecting_message (line 574) | fn expecting_message() {

FILE: test_suite/tests/test_gen.rs
  type Result (line 38) | struct Result;
  type Ok (line 40) | struct Ok;
  type Err (line 42) | struct Err;
  type Option (line 44) | struct Option;
  type Some (line 46) | struct Some;
  type None (line 48) | struct None;
  function test_gen (line 53) | fn test_gen() {
  function assert (line 823) | fn assert<T: Serialize + DeserializeOwned>() {}
  function assert_ser (line 824) | fn assert_ser<T: Serialize>() {}
  type SerializeWith (line 826) | trait SerializeWith {
    method serialize_with (line 827) | fn serialize_with<S: Serializer>(_: &Self, _: S) -> StdResult<S::Ok, S...
    method serialize_with (line 850) | fn serialize_with<S: Serializer>(_: &Self, _: S) -> StdResult<S::Ok, S...
  type DeserializeWith (line 830) | trait DeserializeWith: Sized {
    method deserialize_with (line 831) | fn deserialize_with<'de, D: Deserializer<'de>>(_: D) -> StdResult<Self...
    method deserialize_with (line 856) | fn deserialize_with<'de, D: Deserializer<'de>>(_: D) -> StdResult<Self...
  type X (line 835) | pub struct X;
  function ser_x (line 837) | pub fn ser_x<S: Serializer>(_: &X, _: S) -> StdResult<S::Ok, S::Error> {
  function de_x (line 841) | pub fn de_x<'de, D: Deserializer<'de>>(_: D) -> StdResult<X, D::Error> {
  function serialize_some_unit_variant (line 861) | pub fn serialize_some_unit_variant<S>(_: S) -> StdResult<S::Ok, S::Error>
  function deserialize_some_unit_variant (line 868) | pub fn deserialize_some_unit_variant<'de, D>(_: D) -> StdResult<(), D::E...
  function serialize_some_other_variant (line 875) | pub fn serialize_some_other_variant<S>(_: &str, _: &u8, _: S) -> StdResu...
  function deserialize_some_other_variant (line 882) | pub fn deserialize_some_other_variant<'de, D>(_: D) -> StdResult<(String...
  function is_zero (line 889) | pub fn is_zero(n: &u8) -> bool {
  function vec_first_element (line 893) | fn vec_first_element<T, S>(vec: &[T], serializer: S) -> StdResult<S::Ok,...
  type InternallyTagged (line 905) | pub enum InternallyTagged {
  function deserialize_generic (line 916) | fn deserialize_generic<'de, T, D>(deserializer: D) -> StdResult<T, D::Er...
  type RemotePacked (line 927) | pub struct RemotePacked {
  type RemotePackedDef (line 935) | pub struct RemotePackedDef {
  method drop (line 941) | fn drop(&mut self) {}
  type RemotePackedNonCopy (line 945) | pub struct RemotePackedNonCopy {
  type RemotePackedNonCopyDef (line 953) | pub struct RemotePackedNonCopyDef {
  method drop (line 959) | fn drop(&mut self) {}

FILE: test_suite/tests/test_identifier.rs
  type V (line 13) | enum V {
  function variant1 (line 20) | fn variant1() {
  function aliases (line 30) | fn aliases() {
  function unknown (line 47) | fn unknown() {
  type F (line 80) | enum F {
  function field1 (line 87) | fn field1() {
  function aliases (line 97) | fn aliases() {
  function unknown (line 114) | fn unknown() {
  function unit_fallthrough (line 142) | fn unit_fallthrough() {
  function newtype_fallthrough (line 160) | fn newtype_fallthrough() {
  function newtype_fallthrough_generic (line 173) | fn newtype_fallthrough_generic() {

FILE: test_suite/tests/test_ignored_any.rs
  type Target (line 12) | enum Target {
  type Enum (line 19) | struct Enum(&'static str);
    type Error (line 22) | type Error = Error;
    method deserialize_any (line 24) | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    type Error (line 39) | type Error = Error;
    type Variant (line 40) | type Variant = Self;
    method variant_seed (line 42) | fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant),...
    type Error (line 52) | type Error = Error;
    method unit_variant (line 54) | fn unit_variant(self) -> Result<(), Self::Error> {
    method newtype_variant_seed (line 58) | fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Er...
    method tuple_variant (line 65) | fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value,...
    method struct_variant (line 73) | fn struct_variant<V>(
  function test_deserialize_enum (line 87) | fn test_deserialize_enum() {

FILE: test_suite/tests/test_macros.rs
  type Void (line 18) | enum Void {}
  type NamedUnit (line 21) | struct NamedUnit;
  type SerNamedTuple (line 24) | struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
  type DeNamedTuple (line 27) | struct DeNamedTuple<A, B, C>(A, B, C);
  type SerNamedMap (line 30) | struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
  type DeNamedMap (line 37) | struct DeNamedMap<A, B, C> {
  type SerEnum (line 44) | enum SerEnum<'a, B: 'a, C: 'a, D>
  type DeEnum (line 59) | enum DeEnum<B, C, D> {
  type Lifetimes (line 71) | enum Lifetimes<'a> {
  type GenericStruct (line 79) | pub struct GenericStruct<T> {
  type GenericNewTypeStruct (line 84) | pub struct GenericNewTypeStruct<T>(T);
  type GenericTupleStruct (line 87) | pub struct GenericTupleStruct<T, U>(T, U);
  type GenericEnum (line 90) | pub enum GenericEnum<T, U> {
  type AssociatedType (line 97) | trait AssociatedType {
    type X (line 102) | type X = i32;
  type DefaultTyParam (line 106) | struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
  function test_named_unit (line 111) | fn test_named_unit() {
  function test_ser_named_tuple (line 116) | fn test_ser_named_tuple() {
  function test_de_named_tuple (line 136) | fn test_de_named_tuple() {
  function test_ser_named_map (line 164) | fn test_ser_named_map() {
  function test_de_named_map (line 192) | fn test_de_named_map() {
  function test_ser_enum_unit (line 212) | fn test_ser_enum_unit() {
  function test_ser_enum_seq (line 223) | fn test_ser_enum_seq() {
  function test_ser_enum_map (line 247) | fn test_ser_enum_map() {
  function test_de_enum_unit (line 280) | fn test_de_enum_unit() {
  function test_de_enum_seq (line 291) | fn test_de_enum_seq() {
  function test_de_enum_map (line 315) | fn test_de_enum_map() {
  function test_lifetimes (line 348) | fn test_lifetimes() {
  function test_generic_struct (line 403) | fn test_generic_struct() {
  function test_generic_newtype_struct (line 419) | fn test_generic_newtype_struct() {
  function test_generic_tuple_struct (line 432) | fn test_generic_tuple_struct() {
  function test_generic_enum_unit (line 448) | fn test_generic_enum_unit() {
  function test_generic_enum_newtype (line 459) | fn test_generic_enum_newtype() {
  function test_generic_enum_seq (line 473) | fn test_generic_enum_seq() {
  function test_generic_enum_map (line 490) | fn test_generic_enum_map() {
  function test_default_ty_param (line 509) | fn test_default_ty_param() {
  function test_enum_state_field (line 529) | fn test_enum_state_field() {
  function test_internally_tagged_struct (line 556) | fn test_internally_tagged_struct() {
  function test_internally_tagged_braced_struct_with_zero_fields (line 593) | fn test_internally_tagged_braced_struct_with_zero_fields() {
  function test_internally_tagged_struct_with_flattened_field (line 610) | fn test_internally_tagged_struct_with_flattened_field() {
  function test_rename_all (line 655) | fn test_rename_all() {
  function test_rename_all_fields (line 782) | fn test_rename_all_fields() {
  function test_packed_struct_can_derive_serialize (line 838) | fn test_packed_struct_can_derive_serialize() {

FILE: test_suite/tests/test_remote.rs
  type Unit (line 6) | pub struct Unit;
  type PrimitivePriv (line 8) | pub struct PrimitivePriv(u8);
    method new (line 35) | pub fn new(a: u8) -> Self {
    method get (line 39) | pub fn get(&self) -> u8 {
  type PrimitivePub (line 11) | pub struct PrimitivePub(pub u8);
  type NewtypePriv (line 13) | pub struct NewtypePriv(Unit);
    method new (line 45) | pub fn new(a: Unit) -> Self {
    method get (line 49) | pub fn get(&self) -> &Unit {
  type NewtypePub (line 16) | pub struct NewtypePub(pub Unit);
  type TuplePriv (line 18) | pub struct TuplePriv(u8, Unit);
    method new (line 55) | pub fn new(a: u8, b: Unit) -> Self {
    method first (line 59) | pub fn first(&self) -> u8 {
    method second (line 63) | pub fn second(&self) -> &Unit {
  type TuplePub (line 21) | pub struct TuplePub(pub u8, pub Unit);
  type StructPriv (line 23) | pub struct StructPriv {
    method new (line 69) | pub fn new(a: u8, b: Unit) -> Self {
    method a (line 73) | pub fn a(&self) -> u8 {
    method b (line 77) | pub fn b(&self) -> &Unit {
  type StructPub (line 29) | pub struct StructPub {
  type StructGeneric (line 82) | pub struct StructGeneric<T> {
  function get_value (line 88) | pub fn get_value(&self) -> &T {
  type EnumGeneric (line 94) | pub enum EnumGeneric<T> {
  type Test (line 101) | struct Test {
  type UnitDef (line 142) | struct UnitDef;
  type PrimitivePrivDef (line 146) | struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] ...
  type PrimitivePubDef (line 151) | struct PrimitivePubDef(u8);
  type NewtypePrivDef (line 155) | struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with ...
  type NewtypePubDef (line 160) | struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
  type TuplePrivDef (line 164) | struct TuplePrivDef(
  type TuplePubDef (line 172) | struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
  type StructPrivDef (line 176) | struct StructPrivDef {
  type StructPubDef (line 188) | struct StructPubDef {
  type StructGenericWithGetterDef (line 197) | struct StructGenericWithGetterDef<T> {
  type StructConcrete (line 205) | struct StructConcrete {
  type EnumConcrete (line 212) | enum EnumConcrete {
  type ErrorKind (line 218) | enum ErrorKind {
  type ErrorKindDef (line 229) | enum ErrorKindDef {
  function from (line 236) | fn from(def: PrimitivePrivDef) -> Self {
  function from (line 242) | fn from(def: NewtypePrivDef) -> Self {
  function from (line 248) | fn from(def: TuplePrivDef) -> Self {
  function from (line 254) | fn from(def: StructPrivDef) -> Self {
  function from (line 260) | fn from(def: StructGenericWithGetterDef<T>) -> Self {

FILE: test_suite/tests/test_roundtrip.rs
  function ip_addr_roundtrip (line 9) | fn ip_addr_roundtrip() {
  function socket_addr_roundtrip (line 25) | fn socket_addr_roundtrip() {

FILE: test_suite/tests/test_self.rs
  function test_self (line 6) | fn test_self() {

FILE: test_suite/tests/test_ser.rs
  type UnitStruct (line 31) | struct UnitStruct;
  type TupleStruct (line 34) | struct TupleStruct(i32, i32, i32);
  type Struct (line 37) | struct Struct {
  type NotSerializable (line 44) | struct NotSerializable;
  type Enum (line 47) | enum Enum {
  function test_unit (line 72) | fn test_unit() {
  function test_bool (line 77) | fn test_bool() {
  function test_isizes (line 83) | fn test_isizes() {
  function test_usizes (line 91) | fn test_usizes() {
  function test_floats (line 99) | fn test_floats() {
  function test_char (line 105) | fn test_char() {
  function test_str (line 110) | fn test_str() {
  function test_option (line 116) | fn test_option() {
  function test_result (line 122) | fn test_result() {
  function test_slice (line 146) | fn test_slice() {
  function test_array (line 161) | fn test_array() {
  function test_vec (line 176) | fn test_vec() {
  function test_btreeset (line 200) | fn test_btreeset() {
  function test_hashset (line 212) | fn test_hashset() {
  function test_tuple (line 228) | fn test_tuple() {
  function test_btreemap (line 246) | fn test_btreemap() {
  function test_hashmap (line 287) | fn test_hashmap() {
  function test_unit_struct (line 313) | fn test_unit_struct() {
  function test_tuple_struct (line 318) | fn test_tuple_struct() {
  function test_struct (line 335) | fn test_struct() {
  function test_enum (line 355) | fn test_enum() {
  function test_box (line 411) | fn test_box() {
  function test_boxed_slice (line 416) | fn test_boxed_slice() {
  function test_duration (line 430) | fn test_duration() {
  function test_system_time (line 448) | fn test_system_time() {
  function test_range (line 467) | fn test_range() {
  function test_range_inclusive (line 485) | fn test_range_inclusive() {
  function test_range_from (line 503) | fn test_range_from() {
  function test_range_to (line 519) | fn test_range_to() {
  function test_bound (line 535) | fn test_bound() {
  function test_path (line 563) | fn test_path() {
  function test_path_buf (line 571) | fn test_path_buf() {
  function test_cstring (line 579) | fn test_cstring() {
  function test_cstr (line 584) | fn test_cstr() {
  function test_rc (line 590) | fn test_rc() {
  function test_rc_weak_some (line 595) | fn test_rc_weak_some() {
  function test_rc_weak_none (line 601) | fn test_rc_weak_none() {
  function test_arc (line 606) | fn test_arc() {
  function test_arc_weak_some (line 611) | fn test_arc_weak_some() {
  function test_arc_weak_none (line 617) | fn test_arc_weak_none() {
  function test_wrapping (line 622) | fn test_wrapping() {
  function test_saturating (line 627) | fn test_saturating() {
  function test_rc_dst (line 632) | fn test_rc_dst() {
  function test_arc_dst (line 645) | fn test_arc_dst() {
  function test_fmt_arguments (line 658) | fn test_fmt_arguments() {
  function test_atomic (line 663) | fn test_atomic() {
  function test_atomic64 (line 678) | fn test_atomic64() {
  function test_net_ipv4addr_readable (line 690) | fn test_net_ipv4addr_readable() {
  function test_net_ipv6addr_readable (line 698) | fn test_net_ipv6addr_readable() {
  function test_net_ipaddr_readable (line 706) | fn test_net_ipaddr_readable() {
  function test_net_socketaddr_readable (line 714) | fn test_net_socketaddr_readable() {
  function test_net_ipv4addr_compact (line 739) | fn test_net_ipv4addr_compact() {
  function test_net_ipv6addr_compact (line 751) | fn test_net_ipv6addr_compact() {
  function test_net_ipaddr_compact (line 763) | fn test_net_ipaddr_compact() {
  function test_net_socketaddr_compact (line 779) | fn test_net_socketaddr_compact() {
  function test_never_result (line 821) | fn test_never_result() {
  function test_cannot_serialize_paths (line 836) | fn test_cannot_serialize_paths() {
  function test_cannot_serialize_mutably_borrowed_ref_cell (line 848) | fn test_cannot_serialize_mutably_borrowed_ref_cell() {
  function test_enum_skipped (line 855) | fn test_enum_skipped() {
  function test_integer128 (line 879) | fn test_integer128() {
  function test_refcell_dst (line 886) | fn test_refcell_dst() {
  function test_mutex_dst (line 898) | fn test_mutex_dst() {
  function test_rwlock_dst (line 910) | fn test_rwlock_dst() {

FILE: test_suite/tests/test_serde_path.rs
  function test_gen_custom_serde (line 9) | fn test_gen_custom_serde() {
  function assert (line 25) | pub fn assert<T>()
  type Serialize (line 33) | pub trait Serialize {
    method serialize (line 34) | fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::...
  type Deserialize (line 38) | pub trait Deserialize<'a>: Sized {
    method deserialize (line 39) | fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D...
  type AssertNotSerdeSerialize (line 43) | pub trait AssertNotSerdeSerialize {}
  type AssertNotSerdeDeserialize (line 47) | pub trait AssertNotSerdeDeserialize<'a> {}

FILE: test_suite/tests/test_value.rs
  function test_u32_to_enum (line 10) | fn test_u32_to_enum() {
  function test_integer128 (line 23) | fn test_integer128() {
  function test_map_access_to_enum (line 41) | fn test_map_access_to_enum() {

FILE: test_suite/tests/ui/borrow/bad_lifetimes.rs
  type Test (line 4) | struct Test<'a> {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/borrow/duplicate_lifetime.rs
  type Test (line 4) | struct Test<'a> {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/borrow/duplicate_variant.rs
  type Str (line 4) | struct Str<'a>(&'a str);
  type Test (line 7) | enum Test<'a> {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/borrow/empty_lifetimes.rs
  type Test (line 4) | struct Test<'a> {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/borrow/no_lifetimes.rs
  type Test (line 4) | struct Test {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/borrow/struct_variant.rs
  type Str (line 4) | struct Str<'a>(&'a str);
  type Test (line 7) | enum Test<'a> {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/borrow/wrong_lifetime.rs
  type Test (line 4) | struct Test<'a> {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/conflict/adjacent-tag.rs
  type E (line 5) | enum E {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/conflict/alias-enum.rs
  type E (line 6) | enum E {
  type E1 (line 40) | enum E1 {
  type E2 (line 53) | enum E2 {
  type E3 (line 64) | enum E3 {
  function main (line 73) | fn main() {

FILE: test_suite/tests/ui/conflict/alias.rs
  type S1 (line 4) | struct S1 {
  type S2 (line 17) | struct S2 {
  type S3 (line 28) | struct S3 {
  function main (line 37) | fn main() {

FILE: test_suite/tests/ui/conflict/flatten-newtype-struct.rs
  type Foo (line 5) | struct Foo(#[serde(flatten)] HashMap<String, String>);
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/conflict/flatten-tuple-struct.rs
  type Foo (line 5) | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/conflict/from-try-from.rs
  type S (line 5) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/conflict/internal-tag-alias.rs
  type E (line 5) | enum E {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/conflict/internal-tag.rs
  type E (line 5) | enum E {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/enum.rs
  type E (line 5) | enum E {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/enum_path.rs
  type E (line 5) | enum E {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.rs
  type Enum (line 7) | enum Enum {
  function main (line 20) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_enum_externally_tagged.rs
  type Enum (line 6) | enum Enum {
  function main (line 19) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_enum_internally_tagged.rs
  type Enum (line 7) | enum Enum {
  function main (line 20) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_enum_untagged.rs
  type Enum (line 7) | enum Enum {
  function main (line 20) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_newtype.rs
  type Newtype (line 7) | struct Newtype(#[serde(default = "main")] u8);
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_struct.rs
  type Struct (line 7) | struct Struct {
  function main (line 15) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/incorrect_type_tuple.rs
  type Tuple (line 7) | struct Tuple(u8, #[serde(default = "main")] i8);
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/tuple_struct.rs
  type T0 (line 5) | struct T0(u8, u8);
  type T1 (line 11) | struct T1(u8, #[serde(default)] u8);
  type T2 (line 16) | struct T2(#[serde(default)] u8, u8, u8);
  type T3 (line 23) | struct T3(#[serde(default)] u8, #[serde(default)] u8);
  type T4 (line 30) | struct T4(u8, u8);
  type T5 (line 35) | struct T5(#[serde(default)] u8, u8);
  type T6 (line 40) | struct T6(u8, #[serde(default)] u8);
  type T7 (line 45) | struct T7(#[serde(default)] u8, #[serde(default)] u8);
  function main (line 47) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/tuple_struct_path.rs
  function d (line 3) | fn d<T>() -> T {
  type T1 (line 11) | struct T1(u8, #[serde(default = "d")] u8);
  type T2 (line 16) | struct T2(#[serde(default = "d")] u8, u8, u8);
  type T3 (line 23) | struct T3(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
  type T1D (line 30) | struct T1D(#[serde(default = "d")] u8, u8);
  type T2D (line 35) | struct T2D(u8, #[serde(default = "d")] u8);
  type T3D (line 40) | struct T3D(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
  type T1Path (line 47) | struct T1Path(#[serde(default)] u8, u8);
  type T2Path (line 52) | struct T2Path(u8, #[serde(default)] u8);
  type T3Path (line 57) | struct T3Path(#[serde(default)] u8, #[serde(default)] u8);
  type T1PathD (line 64) | struct T1PathD(#[serde(default = "d")] u8, u8);
  type T2PathD (line 69) | struct T2PathD(u8, #[serde(default = "d")] u8);
  type T3PathD (line 74) | struct T3PathD(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
  function main (line 76) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/union.rs
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/union_path.rs
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/unit.rs
  type Unit (line 5) | struct Unit;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/default-attribute/unit_path.rs
  type Unit (line 5) | struct Unit;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/deprecated/deprecated_de_with.rs
  type Struct (line 7) | pub struct Struct {
  function deprecated_with (line 13) | fn deprecated_with<'de, D>(_deserializer: D) -> Result<i32, D::Error>
  function main (line 20) | fn main() {}

FILE: test_suite/tests/ui/deprecated/deprecated_ser_with.rs
  type Struct (line 7) | pub struct Struct {
  function deprecated_with (line 13) | fn deprecated_with<S>(_field: &i32, _serializer: S) -> Result<S::Ok, S::...
  function main (line 20) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/rename-and-ser.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/rename-ser-rename-ser.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/rename-ser-rename.rs
  type S (line 4) | struct S {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/rename-ser-ser.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/two-rename-ser.rs
  type S (line 4) | struct S {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/duplicate-attribute/with-and-serialize-with.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/content-no-tag.rs
  type E (line 5) | enum E {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/internal-tuple-variant.rs
  type E (line 5) | enum E {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/partially_tagged_wrong_order.rs
  type E (line 4) | enum E {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/untagged-and-adjacent.rs
  type E (line 6) | enum E {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/untagged-and-content.rs
  type E (line 6) | enum E {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/untagged-and-internal.rs
  type E (line 6) | enum E {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/enum-representation/untagged-struct.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/expected-string/boolean.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/expected-string/byte_character.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/expected-string/byte_string.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/expected-string/character.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/expected-string/float.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/expected-string/integer.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/identifier/both.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/identifier/field_struct.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/identifier/field_tuple.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/identifier/newtype_not_last.rs
  type F (line 5) | enum F {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/identifier/not_unit.rs
  type F (line 5) | enum F {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/identifier/other_not_last.rs
  type F (line 5) | enum F {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/identifier/other_untagged.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/identifier/other_variant.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/identifier/variant_struct.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/identifier/variant_tuple.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/malformed/bound.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/malformed/cut_off.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/malformed/not_list.rs
  type S (line 6) | struct S;
  function main (line 8) | fn main() {}

FILE: test_suite/tests/ui/malformed/rename.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/malformed/str_suffix.rs
  type Struct (line 5) | pub struct Struct {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/malformed/trailing_expr.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/precondition/deserialize_de_lifetime.rs
  type S (line 4) | struct S<'de> {
  function main (line 8) | fn main() {}

FILE: test_suite/tests/ui/precondition/deserialize_dst.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/precondition/serialize_field_identifier.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/precondition/serialize_variant_identifier.rs
  type F (line 5) | enum F {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/remote/bad_getter.rs
  type S (line 4) | pub struct S {
  type S (line 11) | struct S {
  function main (line 16) | fn main() {}

FILE: test_suite/tests/ui/remote/bad_remote.rs
  type S (line 4) | pub struct S {
  type S (line 11) | struct S {
  function main (line 15) | fn main() {}

FILE: test_suite/tests/ui/remote/double_generic.rs
  type Struct (line 4) | pub struct Struct<T, U> {
  type StructDef (line 12) | struct StructDef<U> {
  function main (line 17) | fn main() {}

FILE: test_suite/tests/ui/remote/enum_getter.rs
  type E (line 4) | pub enum E {
  type E (line 11) | pub enum E {
  function main (line 18) | fn main() {}

FILE: test_suite/tests/ui/remote/missing_field.rs
  type S (line 4) | pub struct S {
  type S (line 12) | struct S {
  function main (line 16) | fn main() {}

FILE: test_suite/tests/ui/remote/nonremote_getter.rs
  type S (line 4) | struct S {
    method get (line 10) | fn get(&self) -> u8 {
  function main (line 15) | fn main() {}

FILE: test_suite/tests/ui/remote/unknown_field.rs
  type S (line 4) | pub struct S {
  type S (line 11) | struct S {
  function main (line 15) | fn main() {}

FILE: test_suite/tests/ui/remote/wrong_de.rs
  type S (line 4) | pub struct S(pub u16);
  type S (line 9) | struct S(u8);
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/remote/wrong_getter.rs
  type S (line 4) | pub struct S {
    method get (line 9) | pub fn get(&self) -> u16 {
  type S (line 17) | struct S {
    method get (line 9) | pub fn get(&self) -> u16 {
  function main (line 22) | fn main() {}

FILE: test_suite/tests/ui/remote/wrong_ser.rs
  type S (line 4) | pub struct S {
  type S (line 11) | struct S {
  function main (line 15) | fn main() {}

FILE: test_suite/tests/ui/rename/container_unknown_rename_rule.rs
  type S (line 5) | struct S {
  function main (line 11) | fn main() {}

FILE: test_suite/tests/ui/rename/variant_unknown_rename_rule.rs
  type S (line 4) | enum S {
  function main (line 13) | fn main() {}

FILE: test_suite/tests/ui/struct-representation/internally-tagged-tuple.rs
  type S (line 5) | struct S(u8, u8);
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/struct-representation/internally-tagged-unit.rs
  type U (line 5) | struct U;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/transparent/at_most_one.rs
  type S (line 5) | struct S {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/transparent/de_at_least_one.rs
  type S (line 5) | struct S {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/transparent/enum.rs
  type E (line 5) | enum E {}
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/transparent/ser_at_least_one.rs
  type S (line 5) | struct S {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/transparent/unit_struct.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/transparent/with_from.rs
  type S (line 5) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/transparent/with_into.rs
  type S (line 5) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/transparent/with_try_from.rs
  type S (line 5) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/type-attribute/from.rs
  type TestOne (line 5) | enum TestOne {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/type-attribute/into.rs
  type TestOne (line 5) | enum TestOne {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/type-attribute/try_from.rs
  type TestOne (line 5) | enum TestOne {
  function main (line 12) | fn main() {}

FILE: test_suite/tests/ui/unexpected-literal/container.rs
  type S (line 5) | struct S;
  function main (line 7) | fn main() {}

FILE: test_suite/tests/ui/unexpected-literal/field.rs
  type S (line 4) | struct S {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unexpected-literal/variant.rs
  type E (line 4) | enum E {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unimplemented/required_by_dependency.rs
  type MyStruct (line 1) | struct MyStruct;
  function main (line 3) | fn main() {

FILE: test_suite/tests/ui/unimplemented/required_locally.rs
  function to_string (line 4) | fn to_string<T>(_: &T) -> String
  function from_str (line 11) | fn from_str<'de, T>(_: &'de str) -> T
  type MyStruct (line 18) | struct MyStruct;
  function main (line 20) | fn main() {

FILE: test_suite/tests/ui/unknown-attribute/container.rs
  type A (line 5) | struct A {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unknown-attribute/field.rs
  type C (line 4) | struct C {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unknown-attribute/variant.rs
  type E (line 4) | enum E {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unsupported/union_de.rs
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/unsupported/union_ser.rs
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_de_newtype_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_de_struct_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 13) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_de_tuple_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_de_whole_variant.rs
  type Enum (line 4) | enum Enum {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_newtype_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_newtype_field_if.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_struct_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 13) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_struct_field_if.rs
  type Enum (line 4) | enum Enum {
  function main (line 13) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_tuple_field.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_tuple_field_if.rs
  type Enum (line 4) | enum Enum {
  function main (line 9) | fn main() {}

FILE: test_suite/tests/ui/with-variant/skip_ser_whole_variant.rs
  type Enum (line 4) | enum Enum {
  function main (line 10) | fn main() {}

FILE: test_suite/tests/ui/with/incorrect_type.rs
  function deserialize (line 6) | pub fn deserialize<'de, D: Deserializer<'de>>(_: D) -> Result<(), D::Err...
  function serialize (line 9) | pub fn serialize<T, S: Serializer>(_: S) -> Result<S::Ok, S::Error> {
  type W (line 15) | struct W(#[serde(with = "w")] u8, u8);
  type S (line 18) | struct S(#[serde(serialize_with = "w::serialize")] u8, u8);
  type D (line 21) | struct D(#[serde(deserialize_with = "w::deserialize")] u8, u8);
  function main (line 23) | fn main() {}

FILE: test_suite/tests/unstable/mod.rs
  function test_raw_identifiers (line 5) | fn test_raw_identifiers() {