Merge pull request #9 from sfackler/syn-04

Upgrade to syn 0.12

Author: sfackler

Cargo.toml

@@ -13,8 +13,8 @@ proc-macro = true
 test = false
 
 [dependencies]
-syn = "0.11"
-quote = "0.3"
+syn = "0.12"
+quote = "0.4"
 
 [dev-dependencies]
 postgres = "0.15.1"

src/accepts.rs

@@ -36,7 +36,7 @@ pub fn enum_body(name: &str, variants: &[Variant]) -> Tokens {
 
 pub fn composite_body(name: &str, trait_: &str, fields: &[Field]) -> Tokens {
     let num_fields = fields.len();
-    let trait_ = Ident::new(trait_);
+    let trait_ = Ident::from(trait_);
     let traits = iter::repeat(&trait_);
     let field_names = fields.iter().map(|f| &f.name);
     let field_types = fields.iter().map(|f| &f.type_);

src/composites.rs

@@ -1,11 +1,11 @@
-use syn::{self, Ident, Ty};
+use syn::{self, Ident, Type};
 
 use overrides::Overrides;
 
 pub struct Field {
     pub name: String,
     pub ident: Ident,
-    pub type_: Ty,
+    pub type_: Type,
 }
 
 impl Field {

src/enums.rs

@@ -1,4 +1,4 @@
-use syn::{self, Ident, VariantData};
+use syn::{self, Ident, Fields};
 
 use overrides::Overrides;
 
@@ -9,8 +9,8 @@ pub struct Variant {
 
 impl Variant {
     pub fn parse(raw: &syn::Variant) -> Result<Variant, String> {
-        match raw.data {
-            VariantData::Unit => {}
+        match raw.fields {
+            Fields::Unit => {}
             _ => return Err("non-C-like enums are not supported".to_owned()),
         }
 

src/fromsql.rs

@@ -1,28 +1,28 @@
 use std::iter;
-use syn::{self, Body, Ident, MacroInput, VariantData};
+use syn::{self, Ident, DeriveInput, Data, DataStruct, Fields};
 use quote::Tokens;
 
 use accepts;
 use composites::Field;
 use enums::Variant;
 use overrides::Overrides;
 
-pub fn expand_derive_fromsql(input: &MacroInput) -> Result<String, String> {
+pub fn expand_derive_fromsql(input: DeriveInput) -> Result<Tokens, String> {
     let overrides = Overrides::extract(&input.attrs)?;
 
     let name = overrides.name.unwrap_or_else(|| input.ident.to_string());
 
-    let (accepts_body, to_sql_body) = match input.body {
-        Body::Enum(ref variants) => {
-            let variants = variants.iter().map(Variant::parse).collect::<Result<Vec<_>, _>>()?;
+    let (accepts_body, to_sql_body) = match input.data {
+        Data::Enum(ref data) => {
+            let variants = data.variants.iter().map(Variant::parse).collect::<Result<Vec<_>, _>>()?;
             (accepts::enum_body(&name, &variants), enum_body(&input.ident, &variants))
         }
-        Body::Struct(VariantData::Tuple(ref fields)) if fields.len() == 1 => {
-            let field = &fields[0];
+        Data::Struct(DataStruct { fields: Fields::Unnamed(ref fields), .. }) if fields.unnamed.len() == 1 => {
+            let field = fields.unnamed.first().unwrap().into_value();
             (domain_accepts_body(field), domain_body(&input.ident, field))
         }
-        Body::Struct(VariantData::Struct(ref fields)) => {
-            let fields = fields.iter().map(Field::parse).collect::<Result<Vec<_>, _>>()?;
+        Data::Struct(DataStruct { fields: Fields::Named(ref fields), .. }) => {
+            let fields = fields.named.iter().map(Field::parse).collect::<Result<Vec<_>, _>>()?;
             (accepts::composite_body(&name, "FromSql", &fields),
              composite_body(&input.ident, &fields))
         }
@@ -50,7 +50,7 @@ pub fn expand_derive_fromsql(input: &MacroInput) -> Result<String, String> {
         }
     };
 
-    Ok(out.to_string())
+    Ok(out)
 }
 
 fn enum_body(ident: &Ident, variants: &[Variant]) -> Tokens {
@@ -86,7 +86,7 @@ fn domain_body(ident: &Ident, field: &syn::Field) -> Tokens {
 }
 
 fn composite_body(ident: &Ident, fields: &[Field]) -> Tokens {
-    let temp_vars = &fields.iter().map(|f| Ident::new(format!("__{}", f.ident))).collect::<Vec<_>>();
+    let temp_vars = &fields.iter().map(|f| Ident::from(format!("__{}", f.ident))).collect::<Vec<_>>();
     let field_names = &fields.iter().map(|f| &f.name).collect::<Vec<_>>();
     let field_idents = &fields.iter().map(|f| &f.ident).collect::<Vec<_>>();
 

src/lib.rs

@@ -16,12 +16,12 @@ mod tosql;
 
 #[proc_macro_derive(ToSql, attributes(postgres))]
 pub fn derive_tosql(input: TokenStream) -> TokenStream {
-    let input = syn::parse_macro_input(&input.to_string()).unwrap();
-    tosql::expand_derive_tosql(&input).unwrap().parse().unwrap()
+    let input = syn::parse(input).unwrap();
+    tosql::expand_derive_tosql(input).unwrap().into()
 }
 
 #[proc_macro_derive(FromSql, attributes(postgres))]
 pub fn derive_fromsql(input: TokenStream) -> TokenStream {
-    let input = syn::parse_macro_input(&input.to_string()).unwrap();
-    fromsql::expand_derive_fromsql(&input).unwrap().parse().unwrap()
+    let input = syn::parse(input).unwrap();
+    fromsql::expand_derive_fromsql(input).unwrap().into()
 }

src/overrides.rs

@@ -1,4 +1,4 @@
-use syn::{Attribute, MetaItem, NestedMetaItem, Lit};
+use syn::{Attribute, Meta, NestedMeta, Lit};
 
 pub struct Overrides {
     pub name: Option<String>,
@@ -11,24 +11,29 @@ impl Overrides {
         };
 
         for attr in attrs {
-            if attr.value.name() != "postgres" {
+            let attr = match attr.interpret_meta() {
+                Some(meta) => meta,
+                None => continue,
+            };
+
+            if attr.name() != "postgres" {
                 continue;
             }
 
-            let list = match attr.value {
-                MetaItem::List(_, ref list) => list,
+            let list = match attr {
+                Meta::List(ref list) => list,
                 _ => return Err("expected a #[postgres(...)]".to_owned()),
             };
 
-            for item in list {
+            for item in &list.nested {
                 match *item {
-                    NestedMetaItem::MetaItem(MetaItem::NameValue(ref name, ref value)) => {
-                        if name != "name" {
-                            return Err(format!("unknown override `{}`", name));
+                    NestedMeta::Meta(Meta::NameValue(ref meta)) => {
+                        if meta.ident.as_ref() != "name" {
+                            return Err(format!("unknown override `{}`", meta.ident.as_ref()));
                         }
 
-                        let value = match *value {
-                            Lit::Str(ref s, _) => s.to_owned(),
+                        let value = match meta.lit {
+                            Lit::Str(ref s) => s.value(),
                             _ => return Err("expected a string literal".to_owned()),
                         };
 

src/tosql.rs

@@ -1,28 +1,28 @@
 use std::iter;
-use syn::{self, Body, Ident, MacroInput, VariantData};
+use syn::{self, Ident, DeriveInput, Data, DataStruct, Fields};
 use quote::Tokens;
 
 use accepts;
 use composites::Field;
 use enums::Variant;
 use overrides::Overrides;
 
-pub fn expand_derive_tosql(input: &MacroInput) -> Result<String, String> {
+pub fn expand_derive_tosql(input: DeriveInput) -> Result<Tokens, String> {
     let overrides = Overrides::extract(&input.attrs)?;
 
     let name = overrides.name.unwrap_or_else(|| input.ident.to_string());
 
-    let (accepts_body, to_sql_body) = match input.body {
-        Body::Enum(ref variants) => {
-            let variants = variants.iter().map(Variant::parse).collect::<Result<Vec<_>, _>>()?;
+    let (accepts_body, to_sql_body) = match input.data {
+        Data::Enum(ref data) => {
+            let variants = data.variants.iter().map(Variant::parse).collect::<Result<Vec<_>, _>>()?;
             (accepts::enum_body(&name, &variants), enum_body(&input.ident, &variants))
         }
-        Body::Struct(VariantData::Tuple(ref fields)) if fields.len() == 1 => {
-            let field = &fields[0];
+        Data::Struct(DataStruct { fields: Fields::Unnamed(ref fields), .. }) if fields.unnamed.len() == 1 => {
+            let field = fields.unnamed.first().unwrap().into_value();
             (domain_accepts_body(&name, &field), domain_body())
         }
-        Body::Struct(VariantData::Struct(ref fields)) => {
-            let fields = fields.iter().map(Field::parse).collect::<Result<Vec<_>, _>>()?;
+        Data::Struct(DataStruct { fields: Fields::Named(ref fields), .. }) => {
+            let fields = fields.named.iter().map(Field::parse).collect::<Result<Vec<_>, _>>()?;
             (accepts::composite_body(&name, "ToSql", &fields),
              composite_body(&fields))
         }
@@ -53,7 +53,7 @@ pub fn expand_derive_tosql(input: &MacroInput) -> Result<String, String> {
         }
     };
 
-    Ok(out.to_string())
+    Ok(out)
 }
 
 fn enum_body(ident: &Ident, variants: &[Variant]) -> Tokens {