Updated syn and quote to 0.15 and 0.6.

Also updated code to compile, but not yet logically correct.

Issue mcarton#25

Cargo.toml

@@ -17,9 +17,10 @@ appveyor = { repository = "mcarton/rust-derivative" }
 proc-macro = true
 
 [dependencies]
-itertools = "~0.5"
-quote = "^0.3"
-syn = { version = "0.10", features = ["aster", "full", "visit"] }
+itertools = "~0.7"
+quote = "^0.6"
+proc-macro2 = "0.4"
+syn = { version = "0.15", features = ["full", "visit", "extra-traits"] }
 compiletest_rs = { version = "^0.3", optional = true }
 
 [features]

rustfmt.toml

@@ -1,3 +1,3 @@
-reorder_imported_names = true
-reorder_imports = true
-write_mode = "Overwrite"
+# reorder_imported_names = true
+# reorder_imports = true
+# write_mode = "Overwrite"

src/ast.rs

@@ -27,7 +27,7 @@ pub struct Variant<'a> {
 pub struct Field<'a> {
     pub attrs: attr::Field,
     pub ident: Option<syn::Ident>,
-    pub ty: &'a syn::Ty,
+    pub ty: &'a syn::Type,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -38,17 +38,18 @@ pub enum Style {
 }
 
 impl<'a> Input<'a> {
-    pub fn from_ast(item: &'a syn::MacroInput) -> Result<Input<'a>, String> {
+    pub fn from_ast(item: &'a syn::DeriveInput) -> Result<Input<'a>, String> {
         let attrs = try!(attr::Input::from_ast(&item.attrs));
 
-        let body = match item.body {
-            syn::Body::Enum(ref variants) => {
+        let body = match item.data {
+            syn::Data::Enum(syn::DataEnum { ref variants, .. }) => {
                 Body::Enum(try!(enum_from_ast(variants)))
             }
-            syn::Body::Struct(ref variant_data) => {
-                let (style, fields) = try!(struct_from_ast(variant_data));
+            syn::Data::Struct(syn::DataStruct { ref fields, .. }) => {
+                let (style, fields) = try!(struct_from_ast(fields));
                 Body::Struct(style, fields)
             }
+            _ => panic!("Unsupported data type"),
         };
 
         Ok(Input {
@@ -63,22 +64,22 @@ impl<'a> Input<'a> {
 impl<'a> Body<'a> {
     pub fn all_fields(&self) -> Vec<&Field> {
         match *self {
-            Body::Enum(ref variants) => {
-                variants
-                    .iter()
-                    .flat_map(|variant| variant.fields.iter())
-                    .collect()
-            }
+            Body::Enum(ref variants) => variants
+                .iter()
+                .flat_map(|variant| variant.fields.iter())
+                .collect(),
             Body::Struct(_, ref fields) => fields.iter().collect(),
         }
     }
 }
 
-fn enum_from_ast<'a>(variants: &'a [syn::Variant]) -> Result<Vec<Variant<'a>>, String> {
+fn enum_from_ast<'a>(
+    variants: &'a syn::punctuated::Punctuated<syn::Variant, syn::token::Comma>,
+) -> Result<Vec<Variant<'a>>, String> {
     variants
         .iter()
         .map(|variant| {
-            let (style, fields) = try!(struct_from_ast(&variant.data));
+            let (style, fields) = try!(struct_from_ast(&variant.fields));
             Ok(Variant {
                 attrs: try!(attr::Input::from_ast(&variant.attrs)),
                 fields: fields,
@@ -89,21 +90,19 @@ fn enum_from_ast<'a>(variants: &'a [syn::Variant]) -> Result<Vec<Variant<'a>>, S
         .collect()
 }
 
-fn struct_from_ast<'a>(data: &'a syn::VariantData) -> Result<(Style, Vec<Field<'a>>), String> {
-    match *data {
-        syn::VariantData::Struct(ref fields) => {
-            Ok((Style::Struct, try!(fields_from_ast(fields))))
-        }
-        syn::VariantData::Tuple(ref fields) => {
-            Ok((Style::Tuple, try!(fields_from_ast(fields))))
-        }
-        syn::VariantData::Unit => {
-            Ok((Style::Unit, Vec::new()))
+fn struct_from_ast<'a>(fields: &'a syn::Fields) -> Result<(Style, Vec<Field<'a>>), String> {
+    match *fields {
+        syn::Fields::Named(ref fields) => Ok((Style::Struct, try!(fields_from_ast(&fields.named)))),
+        syn::Fields::Unnamed(ref fields) => {
+            Ok((Style::Tuple, try!(fields_from_ast(&fields.unnamed))))
         }
+        syn::Fields::Unit => Ok((Style::Unit, Vec::new())),
     }
 }
 
-fn fields_from_ast<'a>(fields: &'a [syn::Field]) -> Result<Vec<Field<'a>>, String> {
+fn fields_from_ast<'a>(
+    fields: &'a syn::punctuated::Punctuated<syn::Field, syn::token::Comma>,
+) -> Result<Vec<Field<'a>>, String> {
     fields
         .iter()
         .map(|field| {