pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-13 19:31:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'v0.6.x' into master

Browse Source 
# Conflicts:
#	serde/Cargo.toml
#	serde/src/ser/impls.rs
#	serde_codegen/src/attr.rs
#	serde_codegen/src/de.rs
#	serde_codegen/src/field.rs
#	serde_codegen/src/ser.rs
This commit is contained in:
Erick Tryzelaar
2016-01-18 12:45:39 -08:00
parent 939e1540d4 8df841f048
commit 42b8b6153e
25 changed files with 388 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/Cargo.toml
+6 -6
View File
@@ -9,13 +9,13 @@ documentation = "https://serde-rs.github.io/serde/serde/serde/index.html"
readme = "../README.md" readme = "../README.md"
keywords = ["serde", "serialization"] keywords = ["serde", "serialization"]
[dependencies.num]
version = "^0.1.27"
default-features = false
[features] [features]
nightly = [] nightly = ["clippy"]
num-impls = ["num-bigint", "num-complex", "num-rational"]
num-bigint = ["num/bigint"] num-bigint = ["num/bigint"]
num-complex = ["num/complex"] num-complex = ["num/complex"]
num-impls = ["num-bigint", "num-complex", "num-rational"]
num-rational = ["num/rational"] num-rational = ["num/rational"]
[dependencies]
clippy = { version = "^0.0.35", optional = true }
num = { version = "^0.1.27", default-features = false }
serde/src/de/impls.rs
+3 -3
View File
@@ -234,7 +234,7 @@ impl Visitor for StringVisitor {
fn visit_str<E>(&mut self, v: &str) -> Result<String, E> fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
where E: Error, where E: Error,
{ {
Ok(v.to_string()) Ok(v.to_owned())
} }
fn visit_string<E>(&mut self, v: String) -> Result<String, E> fn visit_string<E>(&mut self, v: String) -> Result<String, E>
@@ -247,12 +247,12 @@ impl Visitor for StringVisitor {
where E: Error, where E: Error,
{ {
match str::from_utf8(v) { match str::from_utf8(v) {
Ok(s) => Ok(s.to_string()), Ok(s) => Ok(s.to_owned()),
Err(_) => Err(Error::type_mismatch(Type::String)), Err(_) => Err(Error::type_mismatch(Type::String)),
} }
} }
fn visit_byte_buf<'a, E>(&mut self, v: Vec<u8>) -> Result<String, E> fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<String, E>
where E: Error, where E: Error,
{ {
match String::from_utf8(v) { match String::from_utf8(v) {
serde/src/lib.rs
+4 -1
View File
@@ -10,7 +10,10 @@
//! [github repository](https://github.com/serde-rs/serde) //! [github repository](https://github.com/serde-rs/serde)
#![doc(html_root_url="https://serde-rs.github.io/serde/serde")] #![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
#![cfg_attr(feature = "nightly", feature(collections, enumset, nonzero, step_trait, zero_one))] #![cfg_attr(feature = "nightly", feature(collections, enumset, nonzero, plugin, step_trait,
zero_one))]
#![cfg_attr(feature = "nightly", plugin(clippy))]
#![cfg_attr(feature = "nightly", allow(linkedlist))]
#![deny(missing_docs)] #![deny(missing_docs)]
serde/src/ser/impls.rs
+2 -2
View File
@@ -566,8 +566,8 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
{ {
match self.iter.next() { match self.iter.next() {
Some((key, value)) => { Some((key, value)) => {
let value = try!(serializer.serialize_map_elt(key, value)); try!(serializer.serialize_map_elt(key, value));
Ok(Some(value)) Ok(Some(()))
} }
None => Ok(None) None => Ok(None)
} }
serde/src/ser/mod.rs
+2
View File
@@ -322,6 +322,7 @@ pub trait Serializer {
} }
/// A trait that is used by a `Serialize` to iterate through a sequence. /// A trait that is used by a `Serialize` to iterate through a sequence.
#[cfg_attr(feature = "nightly", allow(len_without_is_empty))]
pub trait SeqVisitor { pub trait SeqVisitor {
/// Serializes a sequence item in the serializer. /// Serializes a sequence item in the serializer.
/// ///
@@ -338,6 +339,7 @@ pub trait SeqVisitor {
} }
/// A trait that is used by a `Serialize` to iterate through a map. /// A trait that is used by a `Serialize` to iterate through a map.
#[cfg_attr(feature = "nightly", allow(len_without_is_empty))]
pub trait MapVisitor { pub trait MapVisitor {
/// Serializes a map item in the serializer. /// Serializes a map item in the serializer.
/// ///
serde_codegen/Cargo.toml
+2 -1
View File
@@ -11,7 +11,7 @@ keywords = ["serde", "serialization"]
[features] [features]
default = ["with-syntex"] default = ["with-syntex"]
nightly = ["quasi_macros"] nightly = ["clippy", "quasi_macros"]
with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"] with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
[build-dependencies] [build-dependencies]
@@ -20,6 +20,7 @@ syntex = { version = "^0.26.0", optional = true }
[dependencies] [dependencies]
aster = { version = "^0.10.0", default-features = false } aster = { version = "^0.10.0", default-features = false }
clippy = { version = "^0.0.35", optional = true }
quasi = { version = "^0.4.0", default-features = false } quasi = { version = "^0.4.0", default-features = false }
quasi_macros = { version = "^0.4.0", optional = true } quasi_macros = { version = "^0.4.0", optional = true }
syntex = { version = "^0.26.0", optional = true } syntex = { version = "^0.26.0", optional = true }
serde_codegen/src/attr.rs
+60 -31
View File
@@ -4,6 +4,7 @@ use std::collections::HashSet;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
use syntax::ext::base::ExtCtxt; use syntax::ext::base::ExtCtxt;
use syntax::print::pprust::meta_item_to_string;
use syntax::ptr::P; use syntax::ptr::P;
use aster; use aster;
@@ -32,7 +33,7 @@ impl FieldAttrs {
/// Return a set of formats that the field has attributes for. /// Return a set of formats that the field has attributes for.
pub fn formats(&self) -> HashSet<P<ast::Expr>> { pub fn formats(&self) -> HashSet<P<ast::Expr>> {
match self.names { match self.names {
FieldNames::Format{ref formats, default: _} => { FieldNames::Format { ref formats, .. } => {
let mut set = HashSet::new(); let mut set = HashSet::new();
for (fmt, _) in formats.iter() { for (fmt, _) in formats.iter() {
set.insert(fmt.clone()); set.insert(fmt.clone());
@@ -70,7 +71,7 @@ impl FieldAttrs {
pub fn default_key_expr(&self) -> &P<ast::Expr> { pub fn default_key_expr(&self) -> &P<ast::Expr> {
match self.names { match self.names {
FieldNames::Global(ref expr) => expr, FieldNames::Global(ref expr) => expr,
FieldNames::Format{formats: _, ref default} => default, FieldNames::Format { ref default, .. } => default,
} }
} }
@@ -104,6 +105,7 @@ impl FieldAttrs {
} }
pub struct FieldAttrsBuilder<'a> { pub struct FieldAttrsBuilder<'a> {
cx: &'a ExtCtxt<'a>,
builder: &'a aster::AstBuilder, builder: &'a aster::AstBuilder,
skip_serializing_field: bool, skip_serializing_field: bool,
skip_serializing_field_if_empty: bool, skip_serializing_field_if_empty: bool,
@@ -114,8 +116,10 @@ pub struct FieldAttrsBuilder<'a> {
} }
impl<'a> FieldAttrsBuilder<'a> { impl<'a> FieldAttrsBuilder<'a> {
pub fn new(builder: &'a aster::AstBuilder) -> FieldAttrsBuilder<'a> { pub fn new(cx: &'a ExtCtxt<'a>,
builder: &'a aster::AstBuilder) -> FieldAttrsBuilder<'a> {
FieldAttrsBuilder { FieldAttrsBuilder {
cx: cx,
builder: builder, builder: builder,
skip_serializing_field: false, skip_serializing_field: false,
skip_serializing_field_if_empty: false, skip_serializing_field_if_empty: false,
@@ -126,7 +130,7 @@ impl<'a> FieldAttrsBuilder<'a> {
} }
} }
pub fn field(mut self, field: &ast::StructField) -> FieldAttrsBuilder<'a> { pub fn field(mut self, field: &ast::StructField) -> Result<FieldAttrsBuilder<'a>, ()> {
match field.node.kind { match field.node.kind {
ast::NamedField(name, _) => { ast::NamedField(name, _) => {
self.name = Some(self.builder.expr().str(name)); self.name = Some(self.builder.expr().str(name));
@@ -137,28 +141,36 @@ impl<'a> FieldAttrsBuilder<'a> {
self.attrs(&field.node.attrs) self.attrs(&field.node.attrs)
} }
pub fn attrs(self, attrs: &[ast::Attribute]) -> FieldAttrsBuilder<'a> { pub fn attrs(mut self, attrs: &[ast::Attribute]) -> Result<FieldAttrsBuilder<'a>, ()> {
attrs.iter().fold(self, FieldAttrsBuilder::attr) for attr in attrs {
self = try!(self.attr(attr));
}
Ok(self)
} }
pub fn attr(self, attr: &ast::Attribute) -> FieldAttrsBuilder<'a> { pub fn attr(mut self, attr: &ast::Attribute) -> Result<FieldAttrsBuilder<'a>, ()> {
match attr.node.value.node { match attr.node.value.node {
ast::MetaList(ref name, ref items) if name == &"serde" => { ast::MetaList(ref name, ref items) if name == &"serde" => {
attr::mark_used(&attr); attr::mark_used(&attr);
items.iter().fold(self, FieldAttrsBuilder::meta_item) for item in items {
self = try!(self.meta_item(item));
}
Ok(self)
} }
_ => { _ => {
self Ok(self)
} }
} }
} }
pub fn meta_item(mut self, meta_item: &P<ast::MetaItem>) -> FieldAttrsBuilder<'a> { pub fn meta_item(mut self, meta_item: &P<ast::MetaItem>) -> Result<FieldAttrsBuilder<'a>, ()> {
match meta_item.node { match meta_item.node {
ast::MetaNameValue(ref name, ref lit) if name == &"rename" => { ast::MetaNameValue(ref name, ref lit) if name == &"rename" => {
let expr = self.builder.expr().build_lit(P(lit.clone())); let expr = self.builder.expr().build_lit(P(lit.clone()));
self.name(expr) Ok(self.name(expr))
} }
ast::MetaList(ref name, ref items) if name == &"rename" => { ast::MetaList(ref name, ref items) if name == &"rename" => {
for item in items { for item in items {
@@ -172,23 +184,27 @@ impl<'a> FieldAttrsBuilder<'a> {
_ => { } _ => { }
} }
} }
self
Ok(self)
} }
ast::MetaWord(ref name) if name == &"default" => { ast::MetaWord(ref name) if name == &"default" => {
self.default() Ok(self.default())
} }
ast::MetaWord(ref name) if name == &"skip_serializing" => { ast::MetaWord(ref name) if name == &"skip_serializing" => {
self.skip_serializing_field() Ok(self.skip_serializing_field())
} }
ast::MetaWord(ref name) if name == &"skip_serializing_if_empty" => { ast::MetaWord(ref name) if name == &"skip_serializing_if_empty" => {
self.skip_serializing_field_if_empty() Ok(self.skip_serializing_field_if_empty())
} }
ast::MetaWord(ref name) if name == &"skip_serializing_if_none" => { ast::MetaWord(ref name) if name == &"skip_serializing_if_none" => {
self.skip_serializing_field_if_none() Ok(self.skip_serializing_field_if_none())
} }
_ => { _ => {
// Ignore unknown meta variables for now. self.cx.span_err(
self meta_item.span,
&format!("unknown serde field attribute `{}`",
meta_item_to_string(meta_item)));
Err(())
} }
} }
} }
@@ -256,46 +272,59 @@ impl ContainerAttrs {
} }
} }
pub struct ContainerAttrsBuilder { pub struct ContainerAttrsBuilder<'a> {
cx: &'a ExtCtxt<'a>,
deny_unknown_fields: bool, deny_unknown_fields: bool,
} }
impl ContainerAttrsBuilder { impl<'a> ContainerAttrsBuilder<'a> {
pub fn new() -> ContainerAttrsBuilder { pub fn new(cx: &'a ExtCtxt) -> Self {
ContainerAttrsBuilder { ContainerAttrsBuilder {
cx: cx,
deny_unknown_fields: false, deny_unknown_fields: false,
} }
} }
pub fn attrs(self, attrs: &[ast::Attribute]) -> ContainerAttrsBuilder { pub fn attrs(mut self, attrs: &[ast::Attribute]) -> Result<Self, ()> {
attrs.iter().fold(self, ContainerAttrsBuilder::attr) for attr in attrs {
self = try!(self.attr(attr));
}
Ok(self)
} }
pub fn attr(self, attr: &ast::Attribute) -> ContainerAttrsBuilder { pub fn attr(mut self, attr: &ast::Attribute) -> Result<Self, ()> {
match attr.node.value.node { match attr.node.value.node {
ast::MetaList(ref name, ref items) if name == &"serde" => { ast::MetaList(ref name, ref items) if name == &"serde" => {
attr::mark_used(&attr); attr::mark_used(&attr);
items.iter().fold(self, ContainerAttrsBuilder::meta_item) for item in items {
self = try!(self.meta_item(item));
}
Ok(self)
} }
_ => { _ => {
self Ok(self)
} }
} }
} }
pub fn meta_item(self, meta_item: &P<ast::MetaItem>) -> ContainerAttrsBuilder { pub fn meta_item(self, meta_item: &P<ast::MetaItem>) -> Result<Self, ()> {
match meta_item.node { match meta_item.node {
ast::MetaWord(ref name) if name == &"deny_unknown_fields" => { ast::MetaWord(ref name) if name == &"deny_unknown_fields" => {
self.deny_unknown_fields() Ok(self.deny_unknown_fields())
} }
_ => { _ => {
// Ignore unknown meta variables for now. self.cx.span_err(
self meta_item.span,
&format!("unknown serde container attribute `{}`",
meta_item_to_string(meta_item)));
Err(())
} }
} }
} }
pub fn deny_unknown_fields(mut self) -> ContainerAttrsBuilder { pub fn deny_unknown_fields(mut self) -> Self {
self.deny_unknown_fields = true; self.deny_unknown_fields = true;
self self
} }
serde_codegen/src/de.rs
+114 -118
View File
@@ -57,13 +57,13 @@ pub fn expand_derive_deserialize(
.segment(item.ident).with_generics(impl_generics.clone()).build() .segment(item.ident).with_generics(impl_generics.clone()).build()
.build(); .build();
let body = deserialize_body( let body = match deserialize_body(cx, &builder, &item, &impl_generics, ty.clone()) {
cx, Ok(body) => body,
&builder, Err(()) => {
&item, // An error occured, but it should have been reported already.
&impl_generics, return;
ty.clone(), }
); };
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
@@ -86,8 +86,8 @@ fn deserialize_body(
item: &Item, item: &Item,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let container_attrs = field::container_attrs(cx, item); let container_attrs = try!(field::container_attrs(cx, item));
match item.node { match item.node {
ast::ItemStruct(ref variant_data, _) => { ast::ItemStruct(ref variant_data, _) => {
@@ -129,7 +129,7 @@ fn deserialize_item_struct(
span: Span, span: Span,
variant_data: &ast::VariantData, variant_data: &ast::VariantData,
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
match *variant_data { match *variant_data {
ast::VariantData::Unit(_) => { ast::VariantData::Unit(_) => {
deserialize_unit_struct( deserialize_unit_struct(
@@ -186,14 +186,14 @@ fn deserialize_visitor(
trait_generics: &ast::Generics, trait_generics: &ast::Generics,
forward_ty_params: Vec<ast::TyParam>, forward_ty_params: Vec<ast::TyParam>,
forward_tys: Vec<P<ast::Ty>> forward_tys: Vec<P<ast::Ty>>
) -> (P<ast::Item>, P<ast::Ty>, P<ast::Expr>, ast::Generics) { ) -> Result<(P<ast::Item>, P<ast::Ty>, P<ast::Expr>, ast::Generics), ()> {
if trait_generics.ty_params.is_empty() && forward_tys.is_empty() { if trait_generics.ty_params.is_empty() && forward_tys.is_empty() {
( Ok((
builder.item().tuple_struct("__Visitor").build(), builder.item().tuple_struct("__Visitor").build(),
builder.ty().id("__Visitor"), builder.ty().id("__Visitor"),
builder.expr().id("__Visitor"), builder.expr().id("__Visitor"),
trait_generics.clone(), trait_generics.clone(),
) ))
} else { } else {
let placeholders : Vec<_> = trait_generics.ty_params.iter() let placeholders : Vec<_> = trait_generics.ty_params.iter()
.map(|t| builder.ty().id(t.ident)) .map(|t| builder.ty().id(t.ident))
@@ -203,7 +203,7 @@ fn deserialize_visitor(
ty_params.extend(trait_generics.ty_params.into_vec()); ty_params.extend(trait_generics.ty_params.into_vec());
trait_generics.ty_params = P::from_vec(ty_params); trait_generics.ty_params = P::from_vec(ty_params);
( Ok((
builder.item().tuple_struct("__Visitor") builder.item().tuple_struct("__Visitor")
.generics().with(trait_generics.clone()).build() .generics().with(trait_generics.clone()).build()
.with_tys({ .with_tys({
@@ -241,7 +241,7 @@ fn deserialize_visitor(
}) })
.build(), .build(),
trait_generics, trait_generics,
) ))
} }
} }
@@ -265,10 +265,10 @@ fn deserialize_unit_struct(
cx: &ExtCtxt, cx: &ExtCtxt,
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
type_ident: Ident, type_ident: Ident,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
struct __Visitor; struct __Visitor;
impl ::serde::de::Visitor for __Visitor { impl ::serde::de::Visitor for __Visitor {
@@ -291,7 +291,7 @@ fn deserialize_unit_struct(
} }
deserializer.deserialize_unit_struct($type_name, __Visitor) deserializer.deserialize_unit_struct($type_name, __Visitor)
}) }))
} }
fn deserialize_newtype_struct( fn deserialize_newtype_struct(
@@ -300,16 +300,15 @@ fn deserialize_newtype_struct(
type_ident: Ident, type_ident: Ident,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
deserialize_visitor( builder,
builder, impl_generics,
impl_generics, vec![deserializer_ty_param(builder)],
vec![deserializer_ty_param(builder)], vec![deserializer_ty_arg(builder)],
vec![deserializer_ty_arg(builder)], ));
);
let visit_seq_expr = deserialize_seq( let visit_seq_expr = deserialize_seq(
cx, cx,
@@ -320,7 +319,7 @@ fn deserialize_newtype_struct(
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_item $visitor_item
impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause { impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
@@ -343,7 +342,7 @@ fn deserialize_newtype_struct(
} }
deserializer.deserialize_newtype_struct($type_name, $visitor_expr) deserializer.deserialize_newtype_struct($type_name, $visitor_expr)
}) }))
} }
fn deserialize_tuple_struct( fn deserialize_tuple_struct(
@@ -353,16 +352,15 @@ fn deserialize_tuple_struct(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: usize, fields: usize,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
deserialize_visitor( builder,
builder, impl_generics,
impl_generics, vec![deserializer_ty_param(builder)],
vec![deserializer_ty_param(builder)], vec![deserializer_ty_arg(builder)],
vec![deserializer_ty_arg(builder)], ));
);
let visit_seq_expr = deserialize_seq( let visit_seq_expr = deserialize_seq(
cx, cx,
@@ -373,7 +371,7 @@ fn deserialize_tuple_struct(
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_item $visitor_item
impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause { impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
@@ -388,7 +386,7 @@ fn deserialize_tuple_struct(
} }
deserializer.deserialize_tuple_struct($type_name, $fields, $visitor_expr) deserializer.deserialize_tuple_struct($type_name, $fields, $visitor_expr)
}) }))
} }
fn deserialize_seq( fn deserialize_seq(
@@ -430,7 +428,7 @@ fn deserialize_struct_as_seq(
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
struct_path: ast::Path, struct_path: ast::Path,
fields: &[ast::StructField], fields: &[ast::StructField],
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let let_values: Vec<P<ast::Stmt>> = (0 .. fields.len()) let let_values: Vec<P<ast::Stmt>> = (0 .. fields.len())
.map(|i| { .map(|i| {
let name = builder.id(format!("__field{}", i)); let name = builder.id(format!("__field{}", i));
@@ -463,13 +461,13 @@ fn deserialize_struct_as_seq(
) )
.build(); .build();
quote_expr!(cx, { Ok(quote_expr!(cx, {
$let_values $let_values
try!(visitor.end()); try!(visitor.end());
Ok($result) Ok($result)
}) }))
} }
fn deserialize_struct( fn deserialize_struct(
@@ -480,36 +478,36 @@ fn deserialize_struct(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[ast::StructField], fields: &[ast::StructField],
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor( let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
builder, builder,
&impl_generics, &impl_generics,
vec![deserializer_ty_param(builder)], vec![deserializer_ty_param(builder)],
vec![deserializer_ty_arg(builder)], vec![deserializer_ty_arg(builder)],
); ));
let type_path = builder.path().id(type_ident).build(); let type_path = builder.path().id(type_ident).build();
let visit_seq_expr = deserialize_struct_as_seq( let visit_seq_expr = try!(deserialize_struct_as_seq(
cx, cx,
builder, builder,
type_path.clone(), type_path.clone(),
fields, fields,
); ));
let (field_visitor, fields_stmt, visit_map_expr) = deserialize_struct_visitor( let (field_visitor, fields_stmt, visit_map_expr) = try!(deserialize_struct_visitor(
cx, cx,
builder, builder,
type_path.clone(), type_path.clone(),
fields, fields,
container_attrs container_attrs
); ));
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$field_visitor $field_visitor
$visitor_item $visitor_item
@@ -535,7 +533,7 @@ fn deserialize_struct(
$fields_stmt $fields_stmt
deserializer.deserialize_struct($type_name, FIELDS, $visitor_expr) deserializer.deserialize_struct($type_name, FIELDS, $visitor_expr)
}) }))
} }
fn deserialize_item_enum( fn deserialize_item_enum(
@@ -546,7 +544,7 @@ fn deserialize_item_enum(
ty: P<ast::Ty>, ty: P<ast::Ty>,
enum_def: &EnumDef, enum_def: &EnumDef,
container_attrs: &ContainerAttrs container_attrs: &ContainerAttrs
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
@@ -557,7 +555,7 @@ fn deserialize_item_enum(
enum_def.variants.iter() enum_def.variants.iter()
.map(|variant| { .map(|variant| {
let expr = builder.expr().str(variant.node.name); let expr = builder.expr().str(variant.node.name);
attr::FieldAttrsBuilder::new(builder) attr::FieldAttrsBuilder::new(cx, builder)
.name(expr) .name(expr)
.build() .build()
}) })
@@ -585,37 +583,35 @@ fn deserialize_item_enum(
}; };
// Match arms to extract a variant from a string // Match arms to extract a variant from a string
let variant_arms: Vec<_> = enum_def.variants.iter() let mut variant_arms = vec![];
.enumerate() for (i, variant) in enum_def.variants.iter().enumerate() {
.map(|(i, variant)| { let variant_name = builder.pat().enum_()
let variant_name = builder.pat().enum_() .id("__Field").id(format!("__field{}", i)).build()
.id("__Field").id(format!("__field{}", i)).build() .build();
.build();
let expr = deserialize_variant( let expr = try!(deserialize_variant(
cx, cx,
builder,
type_ident,
impl_generics,
ty.clone(),
variant,
container_attrs,
);
quote_arm!(cx, $variant_name => { $expr })
})
.chain(ignored_arm.into_iter())
.collect();
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) =
deserialize_visitor(
builder, builder,
type_ident,
impl_generics, impl_generics,
vec![deserializer_ty_param(builder)], ty.clone(),
vec![deserializer_ty_arg(builder)], variant,
); container_attrs,
));
quote_expr!(cx, { let arm = quote_arm!(cx, $variant_name => { $expr });
variant_arms.push(arm);
}
variant_arms.extend(ignored_arm.into_iter());
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
builder,
impl_generics,
vec![deserializer_ty_param(builder)],
vec![deserializer_ty_arg(builder)],
));
Ok(quote_expr!(cx, {
$variant_visitor $variant_visitor
$visitor_item $visitor_item
@@ -635,7 +631,7 @@ fn deserialize_item_enum(
$variants_stmt $variants_stmt
deserializer.deserialize_enum($type_name, VARIANTS, $visitor_expr) deserializer.deserialize_enum($type_name, VARIANTS, $visitor_expr)
}) }))
} }
fn deserialize_variant( fn deserialize_variant(
@@ -646,21 +642,21 @@ fn deserialize_variant(
ty: P<ast::Ty>, ty: P<ast::Ty>,
variant: &ast::Variant, variant: &ast::Variant,
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let variant_ident = variant.node.name; let variant_ident = variant.node.name;
match variant.node.data { match variant.node.data {
ast::VariantData::Unit(_) => { ast::VariantData::Unit(_) => {
quote_expr!(cx, { Ok(quote_expr!(cx, {
try!(visitor.visit_unit()); try!(visitor.visit_unit());
Ok($type_ident::$variant_ident) Ok($type_ident::$variant_ident)
}) }))
} }
ast::VariantData::Tuple(ref args, _) if args.len() == 1 => { ast::VariantData::Tuple(ref args, _) if args.len() == 1 => {
quote_expr!(cx, { Ok(quote_expr!(cx, {
let val = try!(visitor.visit_newtype()); let val = try!(visitor.visit_newtype());
Ok($type_ident::$variant_ident(val)) Ok($type_ident::$variant_ident(val))
}) }))
} }
ast::VariantData::Tuple(ref fields, _) => { ast::VariantData::Tuple(ref fields, _) => {
deserialize_tuple_variant( deserialize_tuple_variant(
@@ -696,16 +692,15 @@ fn deserialize_tuple_variant(
generics: &ast::Generics, generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: usize, fields: usize,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &generics.where_clause; let where_clause = &generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
deserialize_visitor( builder,
builder, generics,
generics, vec![deserializer_ty_param(builder)],
vec![deserializer_ty_param(builder)], vec![deserializer_ty_arg(builder)],
vec![deserializer_ty_arg(builder)], ));
);
let visit_seq_expr = deserialize_seq( let visit_seq_expr = deserialize_seq(
cx, cx,
@@ -714,7 +709,7 @@ fn deserialize_tuple_variant(
fields, fields,
); );
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_item $visitor_item
impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause { impl $visitor_generics ::serde::de::Visitor for $visitor_ty $where_clause {
@@ -728,7 +723,7 @@ fn deserialize_tuple_variant(
} }
visitor.visit_tuple($fields, $visitor_expr) visitor.visit_tuple($fields, $visitor_expr)
}) }))
} }
fn deserialize_struct_variant( fn deserialize_struct_variant(
@@ -740,7 +735,7 @@ fn deserialize_struct_variant(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[ast::StructField], fields: &[ast::StructField],
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let where_clause = &generics.where_clause; let where_clause = &generics.where_clause;
let type_path = builder.path() let type_path = builder.path()
@@ -748,30 +743,29 @@ fn deserialize_struct_variant(
.id(variant_ident) .id(variant_ident)
.build(); .build();
let visit_seq_expr = deserialize_struct_as_seq( let visit_seq_expr = try!(deserialize_struct_as_seq(
cx, cx,
builder, builder,
type_path.clone(), type_path.clone(),
fields, fields,
); ));
let (field_visitor, fields_stmt, field_expr) = deserialize_struct_visitor( let (field_visitor, fields_stmt, field_expr) = try!(deserialize_struct_visitor(
cx, cx,
builder, builder,
type_path, type_path,
fields, fields,
container_attrs, container_attrs,
); ));
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = try!(deserialize_visitor(
deserialize_visitor( builder,
builder, generics,
generics, vec![deserializer_ty_param(builder)],
vec![deserializer_ty_param(builder)], vec![deserializer_ty_arg(builder)],
vec![deserializer_ty_arg(builder)], ));
);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$field_visitor $field_visitor
$visitor_item $visitor_item
@@ -797,7 +791,7 @@ fn deserialize_struct_variant(
$fields_stmt $fields_stmt
visitor.visit_struct(FIELDS, $visitor_expr) visitor.visit_struct(FIELDS, $visitor_expr)
}) }))
} }
fn deserialize_field_visitor( fn deserialize_field_visitor(
@@ -969,21 +963,21 @@ fn deserialize_struct_visitor(
struct_path: ast::Path, struct_path: ast::Path,
fields: &[ast::StructField], fields: &[ast::StructField],
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> (Vec<P<ast::Item>>, P<ast::Stmt>, P<ast::Expr>) { ) -> Result<(Vec<P<ast::Item>>, P<ast::Stmt>, P<ast::Expr>), ()> {
let field_visitor = deserialize_field_visitor( let field_visitor = deserialize_field_visitor(
cx, cx,
builder, builder,
field::struct_field_attrs(cx, builder, fields), try!(field::struct_field_attrs(cx, builder, fields)),
container_attrs container_attrs
); );
let visit_map_expr = deserialize_map( let visit_map_expr = try!(deserialize_map(
cx, cx,
builder, builder,
struct_path, struct_path,
fields, fields,
container_attrs, container_attrs,
); ));
let fields_expr = builder.expr().addr_of().slice() let fields_expr = builder.expr().addr_of().slice()
.with_exprs( .with_exprs(
@@ -1003,7 +997,7 @@ fn deserialize_struct_visitor(
const FIELDS: &'static [&'static str] = $fields_expr; const FIELDS: &'static [&'static str] = $fields_expr;
).unwrap(); ).unwrap();
(field_visitor, fields_stmt, visit_map_expr) Ok((field_visitor, fields_stmt, visit_map_expr))
} }
fn deserialize_map( fn deserialize_map(
@@ -1012,7 +1006,7 @@ fn deserialize_map(
struct_path: ast::Path, struct_path: ast::Path,
fields: &[ast::StructField], fields: &[ast::StructField],
container_attrs: &ContainerAttrs, container_attrs: &ContainerAttrs,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
// Create the field names for the fields. // Create the field names for the fields.
let field_names: Vec<ast::Ident> = (0 .. fields.len()) let field_names: Vec<ast::Ident> = (0 .. fields.len())
.map(|i| builder.id(format!("__field{}", i))) .map(|i| builder.id(format!("__field{}", i)))
@@ -1045,8 +1039,10 @@ fn deserialize_map(
.chain(ignored_arm.into_iter()) .chain(ignored_arm.into_iter())
.collect(); .collect();
let field_attrs = try!(field::struct_field_attrs(cx, builder, fields));
let extract_values: Vec<P<ast::Stmt>> = field_names.iter() let extract_values: Vec<P<ast::Stmt>> = field_names.iter()
.zip(field::struct_field_attrs(cx, builder, fields).iter()) .zip(field_attrs.iter())
.map(|(field_name, field_attr)| { .map(|(field_name, field_attr)| {
let missing_expr = if field_attr.use_default() { let missing_expr = if field_attr.use_default() {
quote_expr!(cx, ::std::default::Default::default()) quote_expr!(cx, ::std::default::Default::default())
@@ -1099,7 +1095,7 @@ fn deserialize_map(
) )
.build(); .build();
quote_expr!(cx, { Ok(quote_expr!(cx, {
$let_values $let_values
while let Some(key) = try!(visitor.visit_key()) { while let Some(key) = try!(visitor.visit_key()) {
@@ -1113,5 +1109,5 @@ fn deserialize_map(
try!(visitor.end()); try!(visitor.end());
Ok($result) Ok($result)
}) }))
} }
serde_codegen/src/field.rs
+18 -12
View File
@@ -2,23 +2,29 @@ use syntax::ast;
use syntax::ext::base::ExtCtxt; use syntax::ext::base::ExtCtxt;
use aster; use aster;
use attr::{ContainerAttrs, ContainerAttrsBuilder, FieldAttrs, FieldAttrsBuilder}; use attr;
pub fn struct_field_attrs( pub fn struct_field_attrs(
_cx: &ExtCtxt, cx: &ExtCtxt,
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
fields: &[ast::StructField], fields: &[ast::StructField],
) -> Vec<FieldAttrs> { ) -> Result<Vec<attr::FieldAttrs>, ()> {
fields.iter() let mut attrs = vec![];
.map(|field| { for field in fields {
FieldAttrsBuilder::new(builder).field(field).build() let builder = attr::FieldAttrsBuilder::new(cx, builder);
}) let builder = try!(builder.field(field));
.collect() let attr = builder.build();
attrs.push(attr);
}
Ok(attrs)
} }
pub fn container_attrs( pub fn container_attrs(
_cx: &ExtCtxt, cx: &ExtCtxt,
container: &ast::Item, container: &ast::Item,
) -> ContainerAttrs { ) -> Result<attr::ContainerAttrs, ()> {
ContainerAttrsBuilder::new().attrs(container.attrs()).build() let builder = attr::ContainerAttrsBuilder::new(cx);
} let builder = try!(builder.attrs(container.attrs()));
Ok(builder.build())
}
serde_codegen/src/lib.rs
+7
View File
@@ -1,3 +1,5 @@
#![cfg_attr(feature = "nightly", plugin(clippy))]
#![cfg_attr(feature = "nightly", allow(used_underscore_binding))]
#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))] #![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))] #![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
@@ -16,6 +18,9 @@ extern crate syntax;
#[cfg(not(feature = "with-syntex"))] #[cfg(not(feature = "with-syntex"))]
extern crate rustc_plugin; extern crate rustc_plugin;
#[cfg(not(feature = "with-syntex"))]
use syntax::feature_gate::AttributeType;
#[cfg(feature = "with-syntex")] #[cfg(feature = "with-syntex")]
include!(concat!(env!("OUT_DIR"), "/lib.rs")); include!(concat!(env!("OUT_DIR"), "/lib.rs"));
@@ -70,4 +75,6 @@ pub fn register(reg: &mut rustc_plugin::Registry) {
syntax::parse::token::intern("derive_Deserialize"), syntax::parse::token::intern("derive_Deserialize"),
syntax::ext::base::MultiDecorator( syntax::ext::base::MultiDecorator(
Box::new(de::expand_derive_deserialize))); Box::new(de::expand_derive_deserialize)));
reg.register_attribute("serde".to_owned(), AttributeType::Normal);
} }
serde_codegen/src/ser.rs
+78 -62
View File
@@ -11,7 +11,7 @@ use syntax::ext::base::{Annotatable, ExtCtxt};
use syntax::ext::build::AstBuilder; use syntax::ext::build::AstBuilder;
use syntax::ptr::P; use syntax::ptr::P;
use field::struct_field_attrs; use field;
pub fn expand_derive_serialize( pub fn expand_derive_serialize(
cx: &mut ExtCtxt, cx: &mut ExtCtxt,
@@ -53,13 +53,13 @@ pub fn expand_derive_serialize(
.segment(item.ident).with_generics(impl_generics.clone()).build() .segment(item.ident).with_generics(impl_generics.clone()).build()
.build(); .build();
let body = serialize_body( let body = match serialize_body(cx, &builder, &item, &impl_generics, ty.clone()) {
cx, Ok(body) => body,
&builder, Err(()) => {
&item, // An error occured, but it should have been reported already.
&impl_generics, return;
ty.clone(), }
); };
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
@@ -82,7 +82,11 @@ fn serialize_body(
item: &Item, item: &Item,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
// Note: While we don't have any container attributes, we still want to try to
// parse them so we can report a proper error if we get passed an unknown attribute.
let _ = try!(field::container_attrs(cx, item));
match item.node { match item.node {
ast::ItemStruct(ref variant_data, _) => { ast::ItemStruct(ref variant_data, _) => {
serialize_item_struct( serialize_item_struct(
@@ -107,7 +111,7 @@ fn serialize_body(
} }
_ => { _ => {
cx.span_bug(item.span, cx.span_bug(item.span,
"expected ItemStruct or ItemEnum in #[derive(Serialize)]") "expected ItemStruct or ItemEnum in #[derive(Serialize)]");
} }
} }
} }
@@ -120,7 +124,7 @@ fn serialize_item_struct(
ty: P<ast::Ty>, ty: P<ast::Ty>,
span: Span, span: Span,
variant_data: &ast::VariantData, variant_data: &ast::VariantData,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
match *variant_data { match *variant_data {
ast::VariantData::Unit(_) => { ast::VariantData::Unit(_) => {
serialize_unit_struct( serialize_unit_struct(
@@ -171,20 +175,24 @@ fn serialize_unit_struct(
cx: &ExtCtxt, cx: &ExtCtxt,
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
type_ident: Ident type_ident: Ident
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, serializer.serialize_unit_struct($type_name)) Ok(quote_expr!(cx,
serializer.serialize_unit_struct($type_name)
))
} }
fn serialize_newtype_struct( fn serialize_newtype_struct(
cx: &ExtCtxt, cx: &ExtCtxt,
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
type_ident: Ident type_ident: Ident
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, serializer.serialize_newtype_struct($type_name, &self.0)) Ok(quote_expr!(cx,
serializer.serialize_newtype_struct($type_name, &self.0)
))
} }
fn serialize_tuple_struct( fn serialize_tuple_struct(
@@ -194,7 +202,7 @@ fn serialize_tuple_struct(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: usize, fields: usize,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor( let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
cx, cx,
builder, builder,
@@ -209,7 +217,7 @@ fn serialize_tuple_struct(
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_struct $visitor_struct
$visitor_impl $visitor_impl
serializer.serialize_tuple_struct($type_name, Visitor { serializer.serialize_tuple_struct($type_name, Visitor {
@@ -217,7 +225,7 @@ fn serialize_tuple_struct(
state: 0, state: 0,
_structure_ty: ::std::marker::PhantomData::<&$ty>, _structure_ty: ::std::marker::PhantomData::<&$ty>,
}) })
}) }))
} }
fn serialize_struct( fn serialize_struct(
@@ -227,8 +235,13 @@ fn serialize_struct(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[ast::StructField], fields: &[ast::StructField],
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let (visitor_struct, visitor_impl) = serialize_struct_visitor( let value_exprs = fields.iter().map(|field| {
let name = field.node.ident().expect("struct has unnamed field");
quote_expr!(cx, &self.value.$name)
});
let (visitor_struct, visitor_impl) = try!(serialize_struct_visitor(
cx, cx,
builder, builder,
ty.clone(), ty.clone(),
@@ -238,15 +251,12 @@ fn serialize_struct(
.build_ty(ty.clone()), .build_ty(ty.clone()),
fields, fields,
impl_generics, impl_generics,
fields.iter().map(|field| { value_exprs,
let name = field.node.ident().expect("struct has unnamed field"); ));
quote_expr!(cx, &self.value.$name)
})
);
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_struct $visitor_struct
$visitor_impl $visitor_impl
serializer.serialize_struct($type_name, Visitor { serializer.serialize_struct($type_name, Visitor {
@@ -254,7 +264,7 @@ fn serialize_struct(
state: 0, state: 0,
_structure_ty: ::std::marker::PhantomData::<&$ty>, _structure_ty: ::std::marker::PhantomData::<&$ty>,
}) })
}) }))
} }
fn serialize_item_enum( fn serialize_item_enum(
@@ -264,27 +274,28 @@ fn serialize_item_enum(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
enum_def: &ast::EnumDef, enum_def: &ast::EnumDef,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let arms: Vec<ast::Arm> = enum_def.variants.iter() let mut arms = vec![];
.enumerate()
.map(|(variant_index, variant)| {
serialize_variant(
cx,
builder,
type_ident,
impl_generics,
ty.clone(),
variant,
variant_index,
)
})
.collect();
quote_expr!(cx, for (variant_index, variant) in enum_def.variants.iter().enumerate() {
let arm = try!(serialize_variant(
cx,
builder,
type_ident,
impl_generics,
ty.clone(),
variant,
variant_index,
));
arms.push(arm);
}
Ok(quote_expr!(cx,
match *self { match *self {
$arms $arms
} }
) ))
} }
fn serialize_variant( fn serialize_variant(
@@ -295,7 +306,7 @@ fn serialize_variant(
ty: P<ast::Ty>, ty: P<ast::Ty>,
variant: &ast::Variant, variant: &ast::Variant,
variant_index: usize, variant_index: usize,
) -> ast::Arm { ) -> Result<ast::Arm, ()> {
let type_name = builder.expr().str(type_ident); let type_name = builder.expr().str(type_ident);
let variant_ident = variant.node.name; let variant_ident = variant.node.name;
let variant_name = builder.expr().str(variant_ident); let variant_name = builder.expr().str(variant_ident);
@@ -306,7 +317,7 @@ fn serialize_variant(
.id(type_ident).id(variant_ident).build() .id(type_ident).id(variant_ident).build()
.build(); .build();
quote_arm!(cx, Ok(quote_arm!(cx,
$pat => { $pat => {
::serde::ser::Serializer::serialize_unit_variant( ::serde::ser::Serializer::serialize_unit_variant(
serializer, serializer,
@@ -315,7 +326,7 @@ fn serialize_variant(
$variant_name, $variant_name,
) )
} }
) ))
}, },
ast::VariantData::Tuple(ref fields, _) if fields.len() == 1 => { ast::VariantData::Tuple(ref fields, _) if fields.len() == 1 => {
let field = builder.id("__simple_value"); let field = builder.id("__simple_value");
@@ -324,7 +335,8 @@ fn serialize_variant(
.id(type_ident).id(variant_ident).build() .id(type_ident).id(variant_ident).build()
.with_pats(Some(field).into_iter()) .with_pats(Some(field).into_iter())
.build(); .build();
quote_arm!(cx,
Ok(quote_arm!(cx,
$pat => { $pat => {
::serde::ser::Serializer::serialize_newtype_variant( ::serde::ser::Serializer::serialize_newtype_variant(
serializer, serializer,
@@ -334,7 +346,7 @@ fn serialize_variant(
__simple_value, __simple_value,
) )
} }
) ))
}, },
ast::VariantData::Tuple(ref fields, _) => { ast::VariantData::Tuple(ref fields, _) => {
let field_names: Vec<ast::Ident> = (0 .. fields.len()) let field_names: Vec<ast::Ident> = (0 .. fields.len())
@@ -361,7 +373,9 @@ fn serialize_variant(
field_names, field_names,
); );
quote_arm!(cx, $pat => { $expr }) Ok(quote_arm!(cx,
$pat => { $expr }
))
} }
ast::VariantData::Struct(ref fields, _) => { ast::VariantData::Struct(ref fields, _) => {
let field_names: Vec<_> = (0 .. fields.len()) let field_names: Vec<_> = (0 .. fields.len())
@@ -386,7 +400,7 @@ fn serialize_variant(
) )
.build(); .build();
let expr = serialize_struct_variant( let expr = try!(serialize_struct_variant(
cx, cx,
builder, builder,
type_name, type_name,
@@ -396,9 +410,11 @@ fn serialize_variant(
ty, ty,
fields, fields,
field_names, field_names,
); ));
quote_arm!(cx, $pat => { $expr }) Ok(quote_arm!(cx,
$pat => { $expr }
))
} }
} }
} }
@@ -463,7 +479,7 @@ fn serialize_struct_variant(
structure_ty: P<ast::Ty>, structure_ty: P<ast::Ty>,
fields: &[ast::StructField], fields: &[ast::StructField],
field_names: Vec<Ident>, field_names: Vec<Ident>,
) -> P<ast::Expr> { ) -> Result<P<ast::Expr>, ()> {
let value_ty = builder.ty().tuple() let value_ty = builder.ty().tuple()
.with_tys( .with_tys(
fields.iter().map(|field| { fields.iter().map(|field| {
@@ -483,7 +499,7 @@ fn serialize_struct_variant(
) )
.build(); .build();
let (visitor_struct, visitor_impl) = serialize_struct_visitor( let (visitor_struct, visitor_impl) = try!(serialize_struct_visitor(
cx, cx,
builder, builder,
structure_ty.clone(), structure_ty.clone(),
@@ -495,9 +511,9 @@ fn serialize_struct_variant(
.tup_field(i) .tup_field(i)
.field("value").self_() .field("value").self_()
}) })
); ));
quote_expr!(cx, { Ok(quote_expr!(cx, {
$visitor_struct $visitor_struct
$visitor_impl $visitor_impl
serializer.serialize_struct_variant($type_name, $variant_index, $variant_name, Visitor { serializer.serialize_struct_variant($type_name, $variant_index, $variant_name, Visitor {
@@ -505,7 +521,7 @@ fn serialize_struct_variant(
state: 0, state: 0,
_structure_ty: ::std::marker::PhantomData::<&$structure_ty>, _structure_ty: ::std::marker::PhantomData::<&$structure_ty>,
}) })
}) }))
} }
fn serialize_tuple_struct_visitor( fn serialize_tuple_struct_visitor(
@@ -583,12 +599,12 @@ fn serialize_struct_visitor<I>(
fields: &[ast::StructField], fields: &[ast::StructField],
generics: &ast::Generics, generics: &ast::Generics,
value_exprs: I, value_exprs: I,
) -> (P<ast::Item>, P<ast::Item>) ) -> Result<(P<ast::Item>, P<ast::Item>), ()>
where I: Iterator<Item=P<ast::Expr>>, where I: Iterator<Item=P<ast::Expr>>,
{ {
let value_exprs = value_exprs.collect::<Vec<_>>(); let value_exprs = value_exprs.collect::<Vec<_>>();
let field_attrs = struct_field_attrs(cx, builder, fields); let field_attrs = try!(field::struct_field_attrs(cx, builder, fields));
let arms: Vec<ast::Arm> = field_attrs.iter() let arms: Vec<ast::Arm> = field_attrs.iter()
.zip(value_exprs.iter()) .zip(value_exprs.iter())
@@ -651,7 +667,7 @@ fn serialize_struct_visitor<I>(
}) })
.fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
( Ok((
quote_item!(cx, quote_item!(cx,
struct Visitor $visitor_impl_generics $where_clause { struct Visitor $visitor_impl_generics $where_clause {
state: usize, state: usize,
@@ -683,5 +699,5 @@ fn serialize_struct_visitor<I>(
} }
} }
).unwrap(), ).unwrap(),
) ))
} }
serde_macros/Cargo.toml
+2
View File
@@ -13,9 +13,11 @@ name = "serde_macros"
plugin = true plugin = true
[dependencies] [dependencies]
clippy = "^0.0.35"
serde_codegen = { version = "*", path = "../serde_codegen", default-features = false, features = ["nightly"] } serde_codegen = { version = "*", path = "../serde_codegen", default-features = false, features = ["nightly"] }
[dev-dependencies] [dev-dependencies]
compiletest_rs = "^0.0.11"
num = "^0.1.27" num = "^0.1.27"
rustc-serialize = "^0.3.16" rustc-serialize = "^0.3.16"
serde = { version = "*", path = "../serde", features = ["nightly", "num-impls"] } serde = { version = "*", path = "../serde", features = ["nightly", "num-impls"] }
serde_macros/benches/bench.rs
+1
View File
@@ -1,4 +1,5 @@
#![feature(custom_attribute, custom_derive, plugin, test)] #![feature(custom_attribute, custom_derive, plugin, test)]
#![plugin(clippy)]
#![plugin(serde_macros)] #![plugin(serde_macros)]
extern crate num; extern crate num;
serde_macros/src/lib.rs
+2 -1
View File
@@ -1,4 +1,5 @@
#![feature(plugin_registrar, rustc_private)] #![feature(plugin, plugin_registrar, rustc_private)]
#![plugin(clippy)]
extern crate serde_codegen; extern crate serde_codegen;
extern crate rustc_plugin; extern crate rustc_plugin;
serde_macros/tests/compile-fail/reject-unknown-attributes.rs
+30
View File
@@ -0,0 +1,30 @@
#![feature(custom_attribute, custom_derive, plugin)]
#![plugin(serde_macros)]
extern crate serde;
#[derive(Serialize)]
#[serde(abc="xyz")] //~ unknown serde container attribute `abc = "xyz"`
struct Foo {
x: u32,
}
#[derive(Deserialize)]
#[serde(abc="xyz")] //~ unknown serde container attribute `abc = "xyz"`
struct Foo {
x: u32,
}
#[derive(Serialize)]
struct Foo {
#[serde(abc="xyz")] //~ unknown serde field attribute `abc = "xyz"`
x: u32,
}
#[derive(Deserialize)]
struct Foo {
#[serde(abc="xyz")] //~ unknown serde field attribute `abc = "xyz"`
x: u32,
}
fn main() { }
serde_macros/tests/compile_tests.rs
+25
View File
@@ -0,0 +1,25 @@
extern crate compiletest_rs as compiletest;
use std::path::PathBuf;
use std::env::var;
fn run_mode(mode: &'static str) {
let mut config = compiletest::default_config();
let cfg_mode = mode.parse().ok().expect("Invalid mode");
config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
if let Ok(name) = var::<&str>("TESTNAME") {
let s : String = name.to_owned();
config.filter = Some(s)
}
config.mode = cfg_mode;
config.src_base = PathBuf::from(format!("tests/{}", mode));
compiletest::run_tests(&config);
}
#[test]
fn compile_test() {
run_mode("compile-fail");
}
serde_macros/tests/test.rs
+2
View File
@@ -6,3 +6,5 @@ extern crate serde;
extern crate test; extern crate test;
include!("../../serde_tests/tests/test.rs.in"); include!("../../serde_tests/tests/test.rs.in");
mod compile_tests;
serde_tests/Cargo.toml
+6
View File
@@ -10,6 +10,9 @@ readme = "README.md"
keywords = ["serialization"] keywords = ["serialization"]
build = "build.rs" build = "build.rs"
[features]
nightly = ["clippy", "serde/nightly"]
[build-dependencies] [build-dependencies]
syntex = { version = "^0.26.0" } syntex = { version = "^0.26.0" }
syntex_syntax = { version = "^0.26.0" } syntex_syntax = { version = "^0.26.0" }
@@ -21,6 +24,9 @@ rustc-serialize = "^0.3.16"
serde = { version = "*", path = "../serde", features = ["num-impls"] } serde = { version = "*", path = "../serde", features = ["num-impls"] }
syntex = "^0.26.0" syntex = "^0.26.0"
[dependencies]
clippy = { version = "^0.0.35", optional = true }
[[test]] [[test]]
name = "test" name = "test"
path = "tests/test.rs" path = "tests/test.rs"
serde_tests/benches/bench.rs
+2
View File
@@ -1,4 +1,6 @@
#![feature(test)] #![feature(test)]
#![cfg_attr(feature = "nightly", feature(plugin))]
#![cfg_attr(feature = "nightly", plugin(clippy))]
extern crate num; extern crate num;
extern crate rustc_serialize; extern crate rustc_serialize;
serde_tests/benches/bench_enum.rs
+2 -2
View File
@@ -433,7 +433,7 @@ fn bench_decoder_dog(b: &mut Bencher) {
#[bench] #[bench]
fn bench_decoder_frog(b: &mut Bencher) { fn bench_decoder_frog(b: &mut Bencher) {
b.iter(|| { b.iter(|| {
let animal = Animal::Frog("Henry".to_string(), 349); let animal = Animal::Frog("Henry".to_owned(), 349);
let mut d = decoder::AnimalDecoder::new(animal.clone()); let mut d = decoder::AnimalDecoder::new(animal.clone());
let value: Animal = Decodable::decode(&mut d).unwrap(); let value: Animal = Decodable::decode(&mut d).unwrap();
@@ -457,7 +457,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
#[bench] #[bench]
fn bench_deserializer_frog(b: &mut Bencher) { fn bench_deserializer_frog(b: &mut Bencher) {
b.iter(|| { b.iter(|| {
let animal = Animal::Frog("Henry".to_string(), 349); let animal = Animal::Frog("Henry".to_owned(), 349);
let mut d = deserializer::AnimalDeserializer::new(animal.clone()); let mut d = deserializer::AnimalDeserializer::new(animal.clone());
let value: Animal = Deserialize::deserialize(&mut d).unwrap(); let value: Animal = Deserialize::deserialize(&mut d).unwrap();
serde_tests/benches/bench_struct.rs
+11 -11
View File
@@ -632,7 +632,7 @@ mod deserializer {
fn bench_decoder_0_0(b: &mut Bencher) { fn bench_decoder_0_0(b: &mut Bencher) {
b.iter(|| { b.iter(|| {
let mut map = HashMap::new(); let mut map = HashMap::new();
map.insert("abc".to_string(), Some('c')); map.insert("abc".to_owned(), Some('c'));
let outer = Outer { let outer = Outer {
inner: vec!(), inner: vec!(),
@@ -671,11 +671,11 @@ fn bench_decoder_1_0(b: &mut Bencher) {
fn bench_decoder_1_5(b: &mut Bencher) { fn bench_decoder_1_5(b: &mut Bencher) {
b.iter(|| { b.iter(|| {
let mut map = HashMap::new(); let mut map = HashMap::new();
map.insert("1".to_string(), Some('a')); map.insert("1".to_owned(), Some('a'));
map.insert("2".to_string(), None); map.insert("2".to_owned(), None);
map.insert("3".to_string(), Some('b')); map.insert("3".to_owned(), Some('b'));
map.insert("4".to_string(), None); map.insert("4".to_owned(), None);
map.insert("5".to_string(), Some('c')); map.insert("5".to_owned(), Some('c'));
let outer = Outer { let outer = Outer {
inner: vec!( inner: vec!(
@@ -734,11 +734,11 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
fn bench_deserializer_1_5(b: &mut Bencher) { fn bench_deserializer_1_5(b: &mut Bencher) {
b.iter(|| { b.iter(|| {
let mut map = HashMap::new(); let mut map = HashMap::new();
map.insert("1".to_string(), Some('a')); map.insert("1".to_owned(), Some('a'));
map.insert("2".to_string(), None); map.insert("2".to_owned(), None);
map.insert("3".to_string(), Some('b')); map.insert("3".to_owned(), Some('b'));
map.insert("4".to_string(), None); map.insert("4".to_owned(), None);
map.insert("5".to_string(), Some('c')); map.insert("5".to_owned(), Some('c'));
let outer = Outer { let outer = Outer {
inner: vec!( inner: vec!(
serde_tests/tests/test.rs
+3
View File
@@ -1,3 +1,6 @@
#![cfg_attr(feature = "nightly", feature(plugin))]
#![cfg_attr(feature = "nightly", plugin(clippy))]
extern crate num; extern crate num;
extern crate serde; extern crate serde;
serde_tests/tests/test_de.rs
+4 -4
View File
@@ -99,12 +99,12 @@ declare_tests! {
test_char { test_char {
'a' => vec![Token::Char('a')], 'a' => vec![Token::Char('a')],
'a' => vec![Token::Str("a")], 'a' => vec![Token::Str("a")],
'a' => vec![Token::String("a".to_string())], 'a' => vec![Token::String("a".to_owned())],
} }
test_string { test_string {
"abc".to_string() => vec![Token::Str("abc")], "abc".to_owned() => vec![Token::Str("abc")],
"abc".to_string() => vec![Token::String("abc".to_string())], "abc".to_owned() => vec![Token::String("abc".to_owned())],
"a".to_string() => vec![Token::Char('a')], "a".to_owned() => vec![Token::Char('a')],
} }
test_option { test_option {
None::<i32> => vec![Token::Unit], None::<i32> => vec![Token::Unit],
serde_tests/tests/test_ser.rs
+1 -1
View File
@@ -63,7 +63,7 @@ declare_ser_tests! {
} }
test_str { test_str {
"abc" => &[Token::Str("abc")], "abc" => &[Token::Str("abc")],
"abc".to_string() => &[Token::Str("abc")], "abc".to_owned() => &[Token::Str("abc")],
} }
test_option { test_option {
None::<i32> => &[Token::Option(false)], None::<i32> => &[Token::Option(false)],
serde_tests/tests/token.rs
+1 -2
View File
@@ -326,7 +326,7 @@ impl de::Error for Error {
fn end_of_stream() -> Error { Error::EndOfStreamError } fn end_of_stream() -> Error { Error::EndOfStreamError }
fn unknown_field(field: &str) -> Error { fn unknown_field(field: &str) -> Error {
Error::UnknownFieldError(field.to_string()) Error::UnknownFieldError(field.to_owned())
} }
fn missing_field(field: &'static str) -> Error { fn missing_field(field: &'static str) -> Error {
@@ -396,7 +396,6 @@ impl<I> de::Deserializer for Deserializer<I>
fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error> fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
where V: de::Visitor, where V: de::Visitor,
{ {
println!("visit {:?}", self.tokens.peek());
match self.tokens.next() { match self.tokens.next() {
Some(Token::Bool(v)) => visitor.visit_bool(v), Some(Token::Bool(v)) => visitor.visit_bool(v),
Some(Token::Isize(v)) => visitor.visit_isize(v), Some(Token::Isize(v)) => visitor.visit_isize(v),