pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-12 16:41:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #738 from serde-rs/absolute

Browse Source 
Use absolute paths to Ok, Err, and other types and methods
This commit is contained in:
Oliver Schneider
2017-02-02 08:16:51 +01:00
committed by GitHub
parent 661cdf4e00 a55d812441
commit faaa494579
5 changed files with 67 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/export.rs
+2 -1
View File
@@ -9,7 +9,8 @@ use collections::borrow::Cow;
pub use core::default::Default; pub use core::default::Default;
pub use core::fmt; pub use core::fmt;
pub use core::marker::PhantomData; pub use core::marker::PhantomData;
pub use core::result::Result; pub use core::option::Option::{self, None, Some};
pub use core::result::Result::{self, Ok, Err};
#[cfg(any(feature = "collections", feature = "std"))] #[cfg(any(feature = "collections", feature = "std"))]
pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> { pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
serde/src/lib.rs
+1 -1
View File
@@ -79,7 +79,7 @@ extern crate core as actual_core;
#[cfg(feature = "std")] #[cfg(feature = "std")]
mod core { mod core {
pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize, pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize,
usize, f32, f64, char, str, num, slice, iter, cell, default, result}; usize, f32, f64, char, str, num, slice, iter, cell, default, result, option};
#[cfg(feature = "unstable")] #[cfg(feature = "unstable")]
pub use actual_core::nonzero; pub use actual_core::nonzero;
} }
serde_derive/src/de.rs
+48 -45
View File
@@ -209,21 +209,21 @@ fn deserialize_unit_struct(
type Value = #type_ident; type Value = #type_ident;
fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result { fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
formatter.write_str(#expecting) _serde::export::fmt::Formatter::write_str(formatter, #expecting)
} }
#[inline] #[inline]
fn visit_unit<__E>(self) -> _serde::export::Result<#type_ident, __E> fn visit_unit<__E>(self) -> _serde::export::Result<#type_ident, __E>
where __E: _serde::de::Error, where __E: _serde::de::Error,
{ {
Ok(#type_ident) _serde::export::Ok(#type_ident)
} }
#[inline] #[inline]
fn visit_seq<__V>(self, _: __V) -> _serde::export::Result<#type_ident, __V::Error> fn visit_seq<__V>(self, _: __V) -> _serde::export::Result<#type_ident, __V::Error>
where __V: _serde::de::SeqVisitor, where __V: _serde::de::SeqVisitor,
{ {
Ok(#type_ident) _serde::export::Ok(#type_ident)
} }
} }
@@ -278,10 +278,10 @@ fn deserialize_tuple(
quote!(_serde::de::VariantVisitor::visit_tuple(visitor, #nfields, #visitor_expr)) quote!(_serde::de::VariantVisitor::visit_tuple(visitor, #nfields, #visitor_expr))
} else if nfields == 1 { } else if nfields == 1 {
let type_name = item_attrs.name().deserialize_name(); let type_name = item_attrs.name().deserialize_name();
quote!(deserializer.deserialize_newtype_struct(#type_name, #visitor_expr)) quote!(_serde::Deserializer::deserialize_newtype_struct(deserializer, #type_name, #visitor_expr))
} else { } else {
let type_name = item_attrs.name().deserialize_name(); let type_name = item_attrs.name().deserialize_name();
quote!(deserializer.deserialize_tuple_struct(#type_name, #nfields, #visitor_expr)) quote!(_serde::Deserializer::deserialize_tuple_struct(deserializer, #type_name, #nfields, #visitor_expr))
}; };
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing()); let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
@@ -298,7 +298,7 @@ fn deserialize_tuple(
type Value = #ty; type Value = #ty;
fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result { fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
formatter.write_str(#expecting) _serde::export::fmt::Formatter::write_str(formatter, #expecting)
} }
#visit_newtype_struct #visit_newtype_struct
@@ -341,7 +341,7 @@ fn deserialize_seq(
let visit = match field.attrs.deserialize_with() { let visit = match field.attrs.deserialize_with() {
None => { None => {
let field_ty = &field.ty; let field_ty = &field.ty;
quote!(try!(visitor.visit::<#field_ty>())) quote!(try!(_serde::de::SeqVisitor::visit::<#field_ty>(&mut visitor)))
} }
Some(path) => { Some(path) => {
let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with( let (wrapper, wrapper_impl, wrapper_ty) = wrap_deserialize_with(
@@ -349,7 +349,8 @@ fn deserialize_seq(
quote!({ quote!({
#wrapper #wrapper
#wrapper_impl #wrapper_impl
try!(visitor.visit::<#wrapper_ty>()).map(|wrap| wrap.value) try!(_serde::de::SeqVisitor::visit::<#wrapper_ty>(&mut visitor))
.map(|wrap| wrap.value)
}) })
} }
}; };
@@ -357,7 +358,7 @@ fn deserialize_seq(
let #var = match #visit { let #var = match #visit {
Some(value) => { value }, Some(value) => { value },
None => { None => {
return Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting)); return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
} }
}; };
}; };
@@ -379,7 +380,7 @@ fn deserialize_seq(
quote! { quote! {
#(#let_values)* #(#let_values)*
Ok(#result) _serde::export::Ok(#result)
} }
} }
@@ -411,7 +412,7 @@ fn deserialize_newtype_struct(
fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error> fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
where __E: _serde::Deserializer, where __E: _serde::Deserializer,
{ {
Ok(#type_path(#value)) _serde::export::Ok(#type_path(#value))
} }
} }
} }
@@ -461,7 +462,7 @@ fn deserialize_struct(
} else { } else {
let type_name = item_attrs.name().deserialize_name(); let type_name = item_attrs.name().deserialize_name();
quote! { quote! {
deserializer.deserialize_struct(#type_name, FIELDS, #visitor_expr) _serde::Deserializer::deserialize_struct(deserializer, #type_name, FIELDS, #visitor_expr)
} }
}; };
@@ -481,7 +482,7 @@ fn deserialize_struct(
type Value = #ty; type Value = #ty;
fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result { fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
formatter.write_str(#expecting) _serde::export::fmt::Formatter::write_str(formatter, #expecting)
} }
#[inline] #[inline]
@@ -563,13 +564,14 @@ fn deserialize_item_enum(
// all variants have `#[serde(skip_deserializing)]`. // all variants have `#[serde(skip_deserializing)]`.
quote! { quote! {
// FIXME: Once we drop support for Rust 1.15: // FIXME: Once we drop support for Rust 1.15:
// let Err(err) = visitor.visit_variant::<__Field>(); // let _serde::export::Err(err) = _serde::de::EnumVisitor::visit_variant::<__Field>(visitor);
// Err(err) // _serde::export::Err(err)
visitor.visit_variant::<__Field>().map(|(impossible, _)| match impossible {}) _serde::de::EnumVisitor::visit_variant::<__Field>(visitor)
.map(|(impossible, _)| match impossible {})
} }
} else { } else {
quote! { quote! {
match try!(visitor.visit_variant()) { match try!(_serde::de::EnumVisitor::visit_variant(visitor)) {
#(#variant_arms)* #(#variant_arms)*
} }
} }
@@ -586,7 +588,7 @@ fn deserialize_item_enum(
type Value = #ty; type Value = #ty;
fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result { fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
formatter.write_str(#expecting) _serde::export::fmt::Formatter::write_str(formatter, #expecting)
} }
fn visit_enum<__V>(self, visitor: __V) -> _serde::export::Result<#ty, __V::Error> fn visit_enum<__V>(self, visitor: __V) -> _serde::export::Result<#ty, __V::Error>
@@ -598,7 +600,7 @@ fn deserialize_item_enum(
#variants_stmt #variants_stmt
deserializer.deserialize_enum(#type_name, VARIANTS, #visitor_expr) _serde::Deserializer::deserialize_enum(deserializer, #type_name, VARIANTS, #visitor_expr)
}) })
} }
@@ -615,7 +617,7 @@ fn deserialize_variant(
Style::Unit => { Style::Unit => {
quote!({ quote!({
try!(_serde::de::VariantVisitor::visit_unit(visitor)); try!(_serde::de::VariantVisitor::visit_unit(visitor));
Ok(#type_ident::#variant_ident) _serde::export::Ok(#type_ident::#variant_ident)
}) })
} }
Style::Newtype => { Style::Newtype => {
@@ -673,7 +675,7 @@ fn deserialize_newtype_variant(
} }
}; };
quote! { quote! {
Ok(#type_ident::#variant_ident(#visit)), _serde::export::Ok(#type_ident::#variant_ident(#visit)),
} }
} }
@@ -701,9 +703,9 @@ fn deserialize_field_visitor(
{ {
match value { match value {
#( #(
#variant_indices => Ok(__Field::#field_idents), #variant_indices => _serde::export::Ok(__Field::#field_idents),
)* )*
_ => Err(_serde::de::Error::invalid_value( _ => _serde::export::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(value as u64), _serde::de::Unexpected::Unsigned(value as u64),
&#fallthrough_msg)) &#fallthrough_msg))
} }
@@ -715,15 +717,15 @@ fn deserialize_field_visitor(
let fallthrough_arm = if is_variant { let fallthrough_arm = if is_variant {
quote! { quote! {
Err(_serde::de::Error::unknown_variant(value, VARIANTS)) _serde::export::Err(_serde::de::Error::unknown_variant(value, VARIANTS))
} }
} else if item_attrs.deny_unknown_fields() { } else if item_attrs.deny_unknown_fields() {
quote! { quote! {
Err(_serde::de::Error::unknown_field(value, FIELDS)) _serde::export::Err(_serde::de::Error::unknown_field(value, FIELDS))
} }
} else { } else {
quote! { quote! {
Ok(__Field::__ignore) _serde::export::Ok(__Field::__ignore)
} }
}; };
@@ -755,7 +757,7 @@ fn deserialize_field_visitor(
type Value = __Field; type Value = __Field;
fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result { fn expecting(&self, formatter: &mut _serde::export::fmt::Formatter) -> _serde::export::fmt::Result {
formatter.write_str("field name") _serde::export::fmt::Formatter::write_str(formatter, "field name")
} }
#visit_index #visit_index
@@ -765,7 +767,7 @@ fn deserialize_field_visitor(
{ {
match value { match value {
#( #(
#field_strs => Ok(__Field::#field_idents), #field_strs => _serde::export::Ok(__Field::#field_idents),
)* )*
_ => #fallthrough_arm _ => #fallthrough_arm
} }
@@ -776,7 +778,7 @@ fn deserialize_field_visitor(
{ {
match value { match value {
#( #(
#field_bytes => Ok(__Field::#field_idents), #field_bytes => _serde::export::Ok(__Field::#field_idents),
)* )*
_ => { _ => {
#bytes_to_str #bytes_to_str
@@ -786,7 +788,7 @@ fn deserialize_field_visitor(
} }
} }
deserializer.deserialize_struct_field(__FieldVisitor) _serde::Deserializer::deserialize_struct_field(deserializer, __FieldVisitor)
} }
} }
} }
@@ -848,7 +850,7 @@ fn deserialize_map(
.map(|&(field, ref name)| { .map(|&(field, ref name)| {
let field_ty = &field.ty; let field_ty = &field.ty;
quote! { quote! {
let mut #name: Option<#field_ty> = None; let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
} }
}); });
@@ -862,7 +864,7 @@ fn deserialize_map(
None => { None => {
let field_ty = &field.ty; let field_ty = &field.ty;
quote! { quote! {
try!(visitor.visit_value::<#field_ty>()) try!(_serde::de::MapVisitor::visit_value::<#field_ty>(&mut visitor))
} }
} }
Some(path) => { Some(path) => {
@@ -871,16 +873,16 @@ fn deserialize_map(
quote!({ quote!({
#wrapper #wrapper
#wrapper_impl #wrapper_impl
try!(visitor.visit_value::<#wrapper_ty>()).value try!(_serde::de::MapVisitor::visit_value::<#wrapper_ty>(&mut visitor)).value
}) })
} }
}; };
quote! { quote! {
__Field::#name => { __Field::#name => {
if #name.is_some() { if _serde::export::Option::is_some(&#name) {
return Err(<__V::Error as _serde::de::Error>::duplicate_field(#deser_name)); return _serde::export::Err(<__V::Error as _serde::de::Error>::duplicate_field(#deser_name));
} }
#name = Some(#visit); #name = _serde::export::Some(#visit);
} }
} }
}); });
@@ -890,7 +892,7 @@ fn deserialize_map(
None None
} else { } else {
Some(quote! { Some(quote! {
_ => { let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); } _ => { let _ = try!(_serde::de::MapVisitor::visit_value::<_serde::de::impls::IgnoredAny>(&mut visitor)); }
}) })
}; };
@@ -898,12 +900,13 @@ fn deserialize_map(
let match_keys = if item_attrs.deny_unknown_fields() && all_skipped { let match_keys = if item_attrs.deny_unknown_fields() && all_skipped {
quote! { quote! {
// FIXME: Once we drop support for Rust 1.15: // FIXME: Once we drop support for Rust 1.15:
// let None::<__Field> = try!(visitor.visit_key()); // let _serde::export::None::<__Field> = try!(_serde::de::MapVisitor::visit_key(&mut visitor));
try!(visitor.visit_key::<__Field>()).map(|impossible| match impossible {}); try!(_serde::de::MapVisitor::visit_key::<__Field>(&mut visitor))
.map(|impossible| match impossible {});
} }
} else { } else {
quote! { quote! {
while let Some(key) = try!(visitor.visit_key::<__Field>()) { while let _serde::export::Some(key) = try!(_serde::de::MapVisitor::visit_key::<__Field>(&mut visitor)) {
match key { match key {
#(#value_arms)* #(#value_arms)*
#ignored_arm #ignored_arm
@@ -919,8 +922,8 @@ fn deserialize_map(
quote! { quote! {
let #name = match #name { let #name = match #name {
Some(#name) => #name, _serde::export::Some(#name) => #name,
None => #missing_expr _serde::export::None => #missing_expr
}; };
} }
}); });
@@ -943,7 +946,7 @@ fn deserialize_map(
#(#extract_values)* #(#extract_values)*
Ok(#struct_path { #(#result),* }) _serde::export::Ok(#struct_path { #(#result),* })
} }
} }
@@ -990,7 +993,7 @@ fn wrap_deserialize_with(
where __D: _serde::Deserializer where __D: _serde::Deserializer
{ {
let value = try!(#deserialize_with(__d)); let value = try!(#deserialize_with(__d));
Ok(__SerdeDeserializeWithStruct { _serde::export::Ok(__SerdeDeserializeWithStruct {
value: value, value: value,
phantom: _serde::export::PhantomData, phantom: _serde::export::PhantomData,
}) })
@@ -1021,7 +1024,7 @@ fn expr_is_missing(attrs: &attr::Field) -> Tokens {
} }
Some(_) => { Some(_) => {
quote! { quote! {
return Err(<__V::Error as _serde::de::Error>::missing_field(#name)) return _serde::export::Err(<__V::Error as _serde::de::Error>::missing_field(#name))
} }
} }
} }
serde_derive/src/ser.rs
+11 -9
View File
@@ -125,7 +125,7 @@ fn serialize_unit_struct(item_attrs: &attr::Item) -> Tokens {
let type_name = item_attrs.name().serialize_name(); let type_name = item_attrs.name().serialize_name();
quote! { quote! {
_serializer.serialize_unit_struct(#type_name) _serde::Serializer::serialize_unit_struct(_serializer, #type_name)
} }
} }
@@ -144,7 +144,7 @@ fn serialize_newtype_struct(
} }
quote! { quote! {
_serializer.serialize_newtype_struct(#type_name, #field_expr) _serde::Serializer::serialize_newtype_struct(_serializer, #type_name, #field_expr)
} }
} }
@@ -167,7 +167,7 @@ fn serialize_tuple_struct(
let let_mut = mut_if(len > 0); let let_mut = mut_if(len > 0);
quote! { quote! {
let #let_mut __serde_state = try!(_serializer.serialize_tuple_struct(#type_name, #len)); let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(_serializer, #type_name, #len));
#(#serialize_stmts)* #(#serialize_stmts)*
_serde::ser::SerializeTupleStruct::end(__serde_state) _serde::ser::SerializeTupleStruct::end(__serde_state)
} }
@@ -208,7 +208,7 @@ fn serialize_struct(
.fold(quote!(0), |sum, expr| quote!(#sum + #expr)); .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote! { quote! {
let #let_mut __serde_state = try!(_serializer.serialize_struct(#type_name, #len)); let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(_serializer, #type_name, #len));
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
} }
@@ -260,7 +260,7 @@ fn serialize_variant(
let skipped_msg = format!("the enum variant {}::{} cannot be serialized", let skipped_msg = format!("the enum variant {}::{} cannot be serialized",
type_ident, variant_ident); type_ident, variant_ident);
let skipped_err = quote! { let skipped_err = quote! {
Err(_serde::ser::Error::custom(#skipped_msg)) _serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
}; };
let fields_pat = match variant.style { let fields_pat = match variant.style {
Style::Unit => quote!(), Style::Unit => quote!(),
@@ -380,7 +380,8 @@ fn serialize_tuple_variant(
let let_mut = mut_if(len > 0); let let_mut = mut_if(len > 0);
quote! { quote! {
let #let_mut __serde_state = try!(_serializer.serialize_tuple_variant( let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
_serializer,
#type_name, #type_name,
#variant_index, #variant_index,
#variant_name, #variant_name,
@@ -426,7 +427,8 @@ fn serialize_struct_variant(
.fold(quote!(0), |sum, expr| quote!(#sum + #expr)); .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote! { quote! {
let #let_mut __serde_state = try!(_serializer.serialize_struct_variant( let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
_serializer,
#item_name, #item_name,
#variant_index, #variant_index,
#variant_name, #variant_name,
@@ -537,7 +539,7 @@ fn wrap_serialize_with(
quote!({ quote!({
struct __SerializeWith #wrapper_generics #where_clause { struct __SerializeWith #wrapper_generics #where_clause {
value: &'__a #field_ty, value: &'__a #field_ty,
phantom: ::std::marker::PhantomData<#item_ty>, phantom: _serde::export::PhantomData<#item_ty>,
} }
impl #wrapper_generics _serde::Serialize for #wrapper_ty #where_clause { impl #wrapper_generics _serde::Serialize for #wrapper_ty #where_clause {
@@ -550,7 +552,7 @@ fn wrap_serialize_with(
&__SerializeWith { &__SerializeWith {
value: #value, value: #value,
phantom: ::std::marker::PhantomData::<#item_ty>, phantom: _serde::export::PhantomData::<#item_ty>,
} }
}) })
} }
test_suite/tests/test_gen.rs
+5 -1
View File
@@ -8,11 +8,15 @@ use self::serde::de::{Deserialize, Deserializer};
use std::borrow::Cow; use std::borrow::Cow;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::result::Result as StdResult;
// Try to trip up the generated code if it fails to use fully qualified paths. // Try to trip up the generated code if it fails to use fully qualified paths.
#[allow(dead_code)] #[allow(dead_code)]
struct Result; struct Result;
use std::result::Result as StdResult; #[allow(dead_code)]
struct Ok;
#[allow(dead_code)]
struct Err;
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////