Google Git
Sign in
rust / rls / refs/heads/beta / . / rls-span / src / serde_expanded.rs
blob: fe40960fbe3a0084c8bda9fee89685666601e00c [file] [log] [blame] [edit]
//! This module exists only because Rust does not support proc macros from
//! crates.io (serde_derive) due to cross-compilation issues
//! (https://github.com/rust-lang/rust/pull/60053).
//!
//! Impls here are copied verbatim from the `cargo expand` output.
//! Please remove this in favour of `#[derive(Serialize, Deserialize)]` if
//! possible.
#![cfg(not(feature = "derive"))]
#![allow(clippy::all)]
use super::*;
use compiler::*;
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DiagnosticSpan: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DiagnosticSpan {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__field4,
__field5,
__field6,
__field7,
__field8,
__field9,
__field10,
__field11,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
4u64 => _serde::export::Ok(__Field::__field4),
5u64 => _serde::export::Ok(__Field::__field5),
6u64 => _serde::export::Ok(__Field::__field6),
7u64 => _serde::export::Ok(__Field::__field7),
8u64 => _serde::export::Ok(__Field::__field8),
9u64 => _serde::export::Ok(__Field::__field9),
10u64 => _serde::export::Ok(__Field::__field10),
11u64 => _serde::export::Ok(__Field::__field11),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 12",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"file_name" => _serde::export::Ok(__Field::__field0),
"byte_start" => _serde::export::Ok(__Field::__field1),
"byte_end" => _serde::export::Ok(__Field::__field2),
"line_start" => _serde::export::Ok(__Field::__field3),
"line_end" => _serde::export::Ok(__Field::__field4),
"column_start" => _serde::export::Ok(__Field::__field5),
"column_end" => _serde::export::Ok(__Field::__field6),
"is_primary" => _serde::export::Ok(__Field::__field7),
"text" => _serde::export::Ok(__Field::__field8),
"label" => _serde::export::Ok(__Field::__field9),
"suggested_replacement" => _serde::export::Ok(__Field::__field10),
"expansion" => _serde::export::Ok(__Field::__field11),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"file_name" => _serde::export::Ok(__Field::__field0),
b"byte_start" => _serde::export::Ok(__Field::__field1),
b"byte_end" => _serde::export::Ok(__Field::__field2),
b"line_start" => _serde::export::Ok(__Field::__field3),
b"line_end" => _serde::export::Ok(__Field::__field4),
b"column_start" => _serde::export::Ok(__Field::__field5),
b"column_end" => _serde::export::Ok(__Field::__field6),
b"is_primary" => _serde::export::Ok(__Field::__field7),
b"text" => _serde::export::Ok(__Field::__field8),
b"label" => _serde::export::Ok(__Field::__field9),
b"suggested_replacement" => _serde::export::Ok(__Field::__field10),
b"expansion" => _serde::export::Ok(__Field::__field11),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DiagnosticSpan>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DiagnosticSpan;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DiagnosticSpan")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<u32>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field2 =
match match _serde::de::SeqAccess::next_element::<u32>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
2usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field3 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
3usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field4 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
4usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field5 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
5usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field6 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
6usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field7 =
match match _serde::de::SeqAccess::next_element::<bool>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
7usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field8 = match match _serde::de::SeqAccess::next_element::<
Vec<DiagnosticSpanLine>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
8usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field9 = match match _serde::de::SeqAccess::next_element::<Option<String>>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
9usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field10 = match match _serde::de::SeqAccess::next_element::<Option<String>>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
10usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
let __field11 = match match _serde::de::SeqAccess::next_element::<
Option<Box<DiagnosticSpanMacroExpansion>>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
11usize,
&"struct DiagnosticSpan with 12 elements",
));
}
};
_serde::export::Ok(DiagnosticSpan {
file_name: __field0,
byte_start: __field1,
byte_end: __field2,
line_start: __field3,
line_end: __field4,
column_start: __field5,
column_end: __field6,
is_primary: __field7,
text: __field8,
label: __field9,
suggested_replacement: __field10,
expansion: __field11,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> = _serde::export::None;
let mut __field1: _serde::export::Option<u32> = _serde::export::None;
let mut __field2: _serde::export::Option<u32> = _serde::export::None;
let mut __field3: _serde::export::Option<usize> = _serde::export::None;
let mut __field4: _serde::export::Option<usize> = _serde::export::None;
let mut __field5: _serde::export::Option<usize> = _serde::export::None;
let mut __field6: _serde::export::Option<usize> = _serde::export::None;
let mut __field7: _serde::export::Option<bool> = _serde::export::None;
let mut __field8: _serde::export::Option<Vec<DiagnosticSpanLine>> =
_serde::export::None;
let mut __field9: _serde::export::Option<Option<String>> = _serde::export::None;
let mut __field10: _serde::export::Option<Option<String>> =
_serde::export::None;
let mut __field11: _serde::export::Option<
Option<Box<DiagnosticSpanMacroExpansion>>,
> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"file_name",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"byte_start",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u32>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"byte_end",
),
);
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<u32>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"line_start",
),
);
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field4 => {
if _serde::export::Option::is_some(&__field4) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"line_end",
),
);
}
__field4 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field5 => {
if _serde::export::Option::is_some(&__field5) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"column_start",
),
);
}
__field5 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field6 => {
if _serde::export::Option::is_some(&__field6) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"column_end",
),
);
}
__field6 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field7 => {
if _serde::export::Option::is_some(&__field7) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"is_primary",
),
);
}
__field7 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<bool>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field8 => {
if _serde::export::Option::is_some(&__field8) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("text"),
);
}
__field8 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Vec<DiagnosticSpanLine>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field9 => {
if _serde::export::Option::is_some(&__field9) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("label"),
);
}
__field9 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Option<String>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field10 => {
if _serde::export::Option::is_some(&__field10) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"suggested_replacement",
),
);
}
__field10 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Option<String>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field11 => {
if _serde::export::Option::is_some(&__field11) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"expansion",
),
);
}
__field11 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<
Option<Box<DiagnosticSpanMacroExpansion>>,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("file_name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("byte_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("byte_end") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => {
match _serde::private::de::missing_field("line_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field4 = match __field4 {
_serde::export::Some(__field4) => __field4,
_serde::export::None => {
match _serde::private::de::missing_field("line_end") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field5 = match __field5 {
_serde::export::Some(__field5) => __field5,
_serde::export::None => {
match _serde::private::de::missing_field("column_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field6 = match __field6 {
_serde::export::Some(__field6) => __field6,
_serde::export::None => {
match _serde::private::de::missing_field("column_end") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field7 = match __field7 {
_serde::export::Some(__field7) => __field7,
_serde::export::None => {
match _serde::private::de::missing_field("is_primary") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field8 = match __field8 {
_serde::export::Some(__field8) => __field8,
_serde::export::None => match _serde::private::de::missing_field("text") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field9 = match __field9 {
_serde::export::Some(__field9) => __field9,
_serde::export::None => match _serde::private::de::missing_field("label") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field10 = match __field10 {
_serde::export::Some(__field10) => __field10,
_serde::export::None => {
match _serde::private::de::missing_field("suggested_replacement") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field11 = match __field11 {
_serde::export::Some(__field11) => __field11,
_serde::export::None => {
match _serde::private::de::missing_field("expansion") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DiagnosticSpan {
file_name: __field0,
byte_start: __field1,
byte_end: __field2,
line_start: __field3,
line_end: __field4,
column_start: __field5,
column_end: __field6,
is_primary: __field7,
text: __field8,
label: __field9,
suggested_replacement: __field10,
expansion: __field11,
})
}
}
const FIELDS: &'static [&'static str] = &[
"file_name",
"byte_start",
"byte_end",
"line_start",
"line_end",
"column_start",
"column_end",
"is_primary",
"text",
"label",
"suggested_replacement",
"expansion",
];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DiagnosticSpan",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DiagnosticSpan>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DiagnosticSpanLine: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DiagnosticSpanLine {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"text" => _serde::export::Ok(__Field::__field0),
"highlight_start" => _serde::export::Ok(__Field::__field1),
"highlight_end" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"text" => _serde::export::Ok(__Field::__field0),
b"highlight_start" => _serde::export::Ok(__Field::__field1),
b"highlight_end" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DiagnosticSpanLine>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DiagnosticSpanLine;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DiagnosticSpanLine")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<String>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct DiagnosticSpanLine with 3 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct DiagnosticSpanLine with 3 elements",
));
}
};
let __field2 =
match match _serde::de::SeqAccess::next_element::<usize>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
2usize,
&"struct DiagnosticSpanLine with 3 elements",
));
}
};
_serde::export::Ok(DiagnosticSpanLine {
text: __field0,
highlight_start: __field1,
highlight_end: __field2,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<String> = _serde::export::None;
let mut __field1: _serde::export::Option<usize> = _serde::export::None;
let mut __field2: _serde::export::Option<usize> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("text"),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"highlight_start",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"highlight_end",
),
);
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<usize>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("text") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("highlight_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("highlight_end") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DiagnosticSpanLine {
text: __field0,
highlight_start: __field1,
highlight_end: __field2,
})
}
}
const FIELDS: &'static [&'static str] = &["text", "highlight_start", "highlight_end"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DiagnosticSpanLine",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DiagnosticSpanLine>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_DiagnosticSpanMacroExpansion: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for DiagnosticSpanMacroExpansion {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"span" => _serde::export::Ok(__Field::__field0),
"macro_decl_name" => _serde::export::Ok(__Field::__field1),
"def_site_span" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"span" => _serde::export::Ok(__Field::__field0),
b"macro_decl_name" => _serde::export::Ok(__Field::__field1),
b"def_site_span" => _serde::export::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de> {
marker: _serde::export::PhantomData<DiagnosticSpanMacroExpansion>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = DiagnosticSpanMacroExpansion;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(
__formatter,
"struct DiagnosticSpanMacroExpansion",
)
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 = match match _serde::de::SeqAccess::next_element::<DiagnosticSpan>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct DiagnosticSpanMacroExpansion with 3 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<String>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct DiagnosticSpanMacroExpansion with 3 elements",
));
}
};
let __field2 = match match _serde::de::SeqAccess::next_element::<
Option<DiagnosticSpan>,
>(&mut __seq)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
2usize,
&"struct DiagnosticSpanMacroExpansion with 3 elements",
));
}
};
_serde::export::Ok(DiagnosticSpanMacroExpansion {
span: __field0,
macro_decl_name: __field1,
def_site_span: __field2,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<DiagnosticSpan> = _serde::export::None;
let mut __field1: _serde::export::Option<String> = _serde::export::None;
let mut __field2: _serde::export::Option<Option<DiagnosticSpan>> =
_serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("span"),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<DiagnosticSpan>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"macro_decl_name",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<String>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"def_site_span",
),
);
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Option<DiagnosticSpan>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("span") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("macro_decl_name") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("def_site_span") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(DiagnosticSpanMacroExpansion {
span: __field0,
macro_decl_name: __field1,
def_site_span: __field2,
})
}
}
const FIELDS: &'static [&'static str] = &["span", "macro_decl_name", "def_site_span"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"DiagnosticSpanMacroExpansion",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<DiagnosticSpanMacroExpansion>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Position: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<I: Indexed> _serde::Serialize for Position<I>
where
I: _serde::Serialize,
{
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Position",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"row",
&self.row,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"col",
&self.col,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Position: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de, I: Indexed> _serde::Deserialize<'de> for Position<I>
where
I: _serde::Deserialize<'de>,
{
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"row" => _serde::export::Ok(__Field::__field0),
"col" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"row" => _serde::export::Ok(__Field::__field0),
b"col" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de, I: Indexed>
where
I: _serde::Deserialize<'de>,
{
marker: _serde::export::PhantomData<Position<I>>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de, I: Indexed> _serde::de::Visitor<'de> for __Visitor<'de, I>
where
I: _serde::Deserialize<'de>,
{
type Value = Position<I>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Position")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<Row<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Position with 2 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<Column<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct Position with 2 elements",
));
}
};
_serde::export::Ok(Position { row: __field0, col: __field1 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Row<I>> = _serde::export::None;
let mut __field1: _serde::export::Option<Column<I>> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("row"),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Row<I>>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("col"),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Column<I>>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("row") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => match _serde::private::de::missing_field("col") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
_serde::export::Ok(Position { row: __field0, col: __field1 })
}
}
const FIELDS: &'static [&'static str] = &["row", "col"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Position",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Position<I>>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Range: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<I: Indexed> _serde::Serialize for Range<I>
where
I: _serde::Serialize,
{
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Range",
false as usize + 1 + 1 + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"row_start",
&self.row_start,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"row_end",
&self.row_end,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"col_start",
&self.col_start,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"col_end",
&self.col_end,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Range: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de, I: Indexed> _serde::Deserialize<'de> for Range<I>
where
I: _serde::Deserialize<'de>,
{
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__field2,
__field3,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 4",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"row_start" => _serde::export::Ok(__Field::__field0),
"row_end" => _serde::export::Ok(__Field::__field1),
"col_start" => _serde::export::Ok(__Field::__field2),
"col_end" => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"row_start" => _serde::export::Ok(__Field::__field0),
b"row_end" => _serde::export::Ok(__Field::__field1),
b"col_start" => _serde::export::Ok(__Field::__field2),
b"col_end" => _serde::export::Ok(__Field::__field3),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de, I: Indexed>
where
I: _serde::Deserialize<'de>,
{
marker: _serde::export::PhantomData<Range<I>>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de, I: Indexed> _serde::de::Visitor<'de> for __Visitor<'de, I>
where
I: _serde::Deserialize<'de>,
{
type Value = Range<I>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Range")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<Row<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Range with 4 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<Row<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct Range with 4 elements",
));
}
};
let __field2 =
match match _serde::de::SeqAccess::next_element::<Column<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
2usize,
&"struct Range with 4 elements",
));
}
};
let __field3 =
match match _serde::de::SeqAccess::next_element::<Column<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
3usize,
&"struct Range with 4 elements",
));
}
};
_serde::export::Ok(Range {
row_start: __field0,
row_end: __field1,
col_start: __field2,
col_end: __field3,
})
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<Row<I>> = _serde::export::None;
let mut __field1: _serde::export::Option<Row<I>> = _serde::export::None;
let mut __field2: _serde::export::Option<Column<I>> = _serde::export::None;
let mut __field3: _serde::export::Option<Column<I>> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"row_start",
),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Row<I>>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"row_end",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Row<I>>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field2 => {
if _serde::export::Option::is_some(&__field2) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"col_start",
),
);
}
__field2 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Column<I>>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field3 => {
if _serde::export::Option::is_some(&__field3) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"col_end",
),
);
}
__field3 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Column<I>>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => {
match _serde::private::de::missing_field("row_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => match _serde::private::de::missing_field("row_end")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2,
_serde::export::None => {
match _serde::private::de::missing_field("col_start") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
let __field3 = match __field3 {
_serde::export::Some(__field3) => __field3,
_serde::export::None => match _serde::private::de::missing_field("col_end")
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
_serde::export::Ok(Range {
row_start: __field0,
row_end: __field1,
col_start: __field2,
col_end: __field3,
})
}
}
const FIELDS: &'static [&'static str] =
&["row_start", "row_end", "col_start", "col_end"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Range",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Range<I>>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Location: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<I: Indexed> _serde::Serialize for Location<I>
where
I: _serde::Serialize,
{
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Location",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"file",
&self.file,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"position",
&self.position,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Location: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de, I: Indexed> _serde::Deserialize<'de> for Location<I>
where
I: _serde::Deserialize<'de>,
{
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"file" => _serde::export::Ok(__Field::__field0),
"position" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"file" => _serde::export::Ok(__Field::__field0),
b"position" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de, I: Indexed>
where
I: _serde::Deserialize<'de>,
{
marker: _serde::export::PhantomData<Location<I>>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de, I: Indexed> _serde::de::Visitor<'de> for __Visitor<'de, I>
where
I: _serde::Deserialize<'de>,
{
type Value = Location<I>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Location")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<PathBuf>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Location with 2 elements",
));
}
};
let __field1 = match match _serde::de::SeqAccess::next_element::<Position<I>>(
&mut __seq,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct Location with 2 elements",
));
}
};
_serde::export::Ok(Location { file: __field0, position: __field1 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<PathBuf> = _serde::export::None;
let mut __field1: _serde::export::Option<Position<I>> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("file"),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PathBuf>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field(
"position",
),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Position<I>>(
&mut __map,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("file") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => {
match _serde::private::de::missing_field("position") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
}
};
_serde::export::Ok(Location { file: __field0, position: __field1 })
}
}
const FIELDS: &'static [&'static str] = &["file", "position"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Location",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Location<I>>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Span: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<I: Indexed> _serde::Serialize for Span<I>
where
I: _serde::Serialize,
{
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
let mut __serde_state = match _serde::Serializer::serialize_struct(
__serializer,
"Span",
false as usize + 1 + 1,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"file",
&self.file,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
match _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state,
"range",
&self.range,
) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Span: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de, I: Indexed> _serde::Deserialize<'de> for Span<I>
where
I: _serde::Deserialize<'de>,
{
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#[allow(non_camel_case_types)]
enum __Field {
__field0,
__field1,
__ignore,
}
struct __FieldVisitor;
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier")
}
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
0u64 => _serde::export::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 2",
)),
}
}
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
"file" => _serde::export::Ok(__Field::__field0),
"range" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
fn visit_bytes<__E>(
self,
__value: &[u8],
) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
b"file" => _serde::export::Ok(__Field::__field0),
b"range" => _serde::export::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore),
}
}
}
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
_serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
}
}
struct __Visitor<'de, I: Indexed>
where
I: _serde::Deserialize<'de>,
{
marker: _serde::export::PhantomData<Span<I>>,
lifetime: _serde::export::PhantomData<&'de ()>,
}
impl<'de, I: Indexed> _serde::de::Visitor<'de> for __Visitor<'de, I>
where
I: _serde::Deserialize<'de>,
{
type Value = Span<I>;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct Span")
}
#[inline]
fn visit_seq<__A>(
self,
mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<'de>,
{
let __field0 =
match match _serde::de::SeqAccess::next_element::<PathBuf>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
0usize,
&"struct Span with 2 elements",
));
}
};
let __field1 =
match match _serde::de::SeqAccess::next_element::<Range<I>>(&mut __seq) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
} {
_serde::export::Some(__value) => __value,
_serde::export::None => {
return _serde::export::Err(_serde::de::Error::invalid_length(
1usize,
&"struct Span with 2 elements",
));
}
};
_serde::export::Ok(Span { file: __field0, range: __field1 })
}
#[inline]
fn visit_map<__A>(
self,
mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<'de>,
{
let mut __field0: _serde::export::Option<PathBuf> = _serde::export::None;
let mut __field1: _serde::export::Option<Range<I>> = _serde::export::None;
while let _serde::export::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
}
{
match __key {
__Field::__field0 => {
if _serde::export::Option::is_some(&__field0) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("file"),
);
}
__field0 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<PathBuf>(&mut __map) {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
__Field::__field1 => {
if _serde::export::Option::is_some(&__field1) {
return _serde::export::Err(
<__A::Error as _serde::de::Error>::duplicate_field("range"),
);
}
__field1 = _serde::export::Some(
match _serde::de::MapAccess::next_value::<Range<I>>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
);
}
_ => {
let _ = match _serde::de::MapAccess::next_value::<
_serde::de::IgnoredAny,
>(&mut __map)
{
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
};
}
}
}
let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("file") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1,
_serde::export::None => match _serde::private::de::missing_field("range") {
_serde::export::Ok(__val) => __val,
_serde::export::Err(__err) => {
return _serde::export::Err(__err);
}
},
};
_serde::export::Ok(Span { file: __field0, range: __field1 })
}
}
const FIELDS: &'static [&'static str] = &["file", "range"];
_serde::Deserializer::deserialize_struct(
__deserializer,
"Span",
FIELDS,
__Visitor {
marker: _serde::export::PhantomData::<Span<I>>,
lifetime: _serde::export::PhantomData,
},
)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_ZeroIndexed: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for ZeroIndexed {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_unit_struct(__serializer, "ZeroIndexed")
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_ZeroIndexed: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for ZeroIndexed {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor;
impl<'de> _serde::de::Visitor<'de> for __Visitor {
type Value = ZeroIndexed;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "unit struct ZeroIndexed")
}
#[inline]
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(ZeroIndexed)
}
}
_serde::Deserializer::deserialize_unit_struct(__deserializer, "ZeroIndexed", __Visitor)
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_OneIndexed: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl _serde::Serialize for OneIndexed {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
where
__S: _serde::Serializer,
{
_serde::Serializer::serialize_unit_struct(__serializer, "OneIndexed")
}
}
};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_OneIndexed: () = {
#[allow(unknown_lints)]
#[allow(rust_2018_idioms)]
extern crate serde as _serde;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for OneIndexed {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
struct __Visitor;
impl<'de> _serde::de::Visitor<'de> for __Visitor {
type Value = OneIndexed;
fn expecting(
&self,
__formatter: &mut _serde::export::Formatter,
) -> _serde::export::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "unit struct OneIndexed")
}
#[inline]
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
_serde::export::Ok(OneIndexed)
}
}
_serde::Deserializer::deserialize_unit_struct(__deserializer, "OneIndexed", __Visitor)
}
}
};