From 782b983a57bf443a556d7b0f0aba8025f794cdae Mon Sep 17 00:00:00 2001 From: alan poon Date: Wed, 7 Mar 2018 15:56:44 +0800 Subject: [PATCH] Update Syn to 0.4 --- conrod_derive/Cargo.toml | 4 +-- conrod_derive/src/common.rs | 35 ++++++++++++-------- conrod_derive/src/lib.rs | 12 +++---- conrod_derive/src/style.rs | 64 +++++++++++++++---------------------- conrod_derive/src/utils.rs | 11 ++++--- 5 files changed, 60 insertions(+), 66 deletions(-) diff --git a/conrod_derive/Cargo.toml b/conrod_derive/Cargo.toml index 5e4cf3a9a..58a6a2c5d 100644 --- a/conrod_derive/Cargo.toml +++ b/conrod_derive/Cargo.toml @@ -12,5 +12,5 @@ homepage = "https://github.com/pistondevelopers/conrod" proc-macro = true [dependencies] -quote = "0.3" -syn = "0.11" +quote = "0.4" +syn = {version="0.12.13",features=["extra-traits","full"]} diff --git a/conrod_derive/src/common.rs b/conrod_derive/src/common.rs index e677d8346..7e635b89f 100644 --- a/conrod_derive/src/common.rs +++ b/conrod_derive/src/common.rs @@ -7,7 +7,7 @@ pub fn impl_widget_common(ast: &syn::DeriveInput) -> quote::Tokens { let ident = &ast.ident; let common_field = common_builder_field(ast).unwrap(); let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - let dummy_const = syn::Ident::new(format!("_IMPL_WIDGET_COMMON_FOR_{}", ident)); + let dummy_const = syn::Ident::from(format!("_IMPL_WIDGET_COMMON_FOR_{}", ident)); let impl_item = quote! { impl #impl_generics _conrod::widget::Common for #ident #ty_generics #where_clause { @@ -36,8 +36,8 @@ pub fn impl_widget_common_(ast: &syn::DeriveInput) -> quote::Tokens { let ident = &ast.ident; let common_field = common_builder_field(ast).unwrap(); let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); - let dummy_const = syn::Ident::new(format!("_IMPL_WIDGET_COMMON_FOR_{}", ident)); - + let dummy_const = syn::Ident::from(format!("_IMPL_WIDGET_COMMON_FOR_{}", ident)); + let impl_item = quote! { impl #impl_generics ::widget::Common for #ident #ty_generics #where_clause { fn common(&self) -> &::widget::CommonBuilder { @@ -62,32 +62,39 @@ pub fn impl_widget_common_(ast: &syn::DeriveInput) -> quote::Tokens { fn common_builder_field(ast: &syn::DeriveInput) -> Result<&syn::Ident, Error> { // Ensure we are deriving for a struct. - let body = match ast.body { - syn::Body::Struct(ref body) => body, + let body = match ast.data { + syn::Data::Struct(ref body) => body, _ => return Err(Error::NotStruct), }; // We can only derive `WidgetCommon` for structs with fields. - let fields = match *body { - syn::VariantData::Struct(ref fields) => fields, - syn::VariantData::Tuple(_) => return Err(Error::TupleStruct), - syn::VariantData::Unit => return Err(Error::UnitStruct), + match body.fields { + syn::Fields::Named(_) => {}, + syn::Fields::Unnamed(_) => return Err(Error::TupleStruct), + syn::Fields::Unit => return Err(Error::UnitStruct), }; // Find the field on the struct with the `WidgetCommon` attribute. // // We need this to know what field to use for the `common` and `common_mut` accessor methods. let mut common_field = None; - for field in fields { + for field in body.fields.iter() { // First, search for the attribute. for attr in &field.attrs { - if let syn::MetaItem::List(ref ident, ref values) = attr.value { - let has_common_builder = values.iter().any(|v| match *v { - syn::NestedMetaItem::MetaItem(syn::MetaItem::Word(ref w)) + if let Some(_meta) = attr.interpret_meta() { + let mut is_conrod=false; + let mut has_common_builder = false; + if let syn::Meta::List(_metalist) = _meta{ + if _metalist.ident == syn::Ident::from("conrod"){ + is_conrod = true; + } + has_common_builder = _metalist.nested.iter().any(|v| match *v { + syn::NestedMeta::Meta(syn::Meta::Word(ref w)) if w == "common_builder" => true, _ => false, }); - if ident == "conrod" && has_common_builder { + } + if is_conrod && has_common_builder { // There should only be one `CommonBuilder` attribute. if common_field.is_some() { return Err(Error::MultipleCommonBuilderFields); diff --git a/conrod_derive/src/lib.rs b/conrod_derive/src/lib.rs index cf5cb8d77..3e5009fb3 100644 --- a/conrod_derive/src/lib.rs +++ b/conrod_derive/src/lib.rs @@ -44,15 +44,11 @@ fn impl_derive( generate_derive: fn(&syn::DeriveInput) -> quote::Tokens, ) -> TokenStream { - // A string representation of the type definition. - let input_string = input.to_string(); - - // Parse the string representation. - let ast = syn::parse_derive_input(&input_string).unwrap(); - + // Parse the input TokenStream representation. + let ast = syn::parse(input).unwrap(); + // Build the implementation. let gen = generate_derive(&ast); - // Return the generated impl. - gen.parse().unwrap() + gen.into() } diff --git a/conrod_derive/src/style.rs b/conrod_derive/src/style.rs index 2e826631d..538b5e7bd 100644 --- a/conrod_derive/src/style.rs +++ b/conrod_derive/src/style.rs @@ -2,12 +2,12 @@ use quote; use std; use syn; use utils; - +use syn::Expr; // The implementation for `WidgetStyle`. // // This generates an accessor method for every field in the struct pub fn impl_widget_style(ast: &syn::DeriveInput) -> quote::Tokens { - let crate_tokens = quote::Ident::new("_conrod"); + let crate_tokens = Some(syn::Ident::from("_conrod")); let params = params(ast).unwrap(); let impl_tokens = impl_tokens(¶ms, crate_tokens); let dummy_const = ¶ms.dummy_const; @@ -24,7 +24,8 @@ pub fn impl_widget_style(ast: &syn::DeriveInput) -> quote::Tokens { // // The same as `WidgetStyle` but only for use within the conrod crate itself. pub fn impl_widget_style_(ast: &syn::DeriveInput) -> quote::Tokens { - let crate_tokens = quote::Ident::new(""); + // let crate_tokens = syn::Ident::from(syn::token::CapSelf::default()); + let crate_tokens= None; let params = params(ast).unwrap(); let impl_tokens = impl_tokens(¶ms, crate_tokens); let dummy_const = ¶ms.dummy_const; @@ -36,7 +37,7 @@ pub fn impl_widget_style_(ast: &syn::DeriveInput) -> quote::Tokens { } } -fn impl_tokens(params: &Params, crate_tokens: quote::Ident) -> quote::Tokens { +fn impl_tokens(params: &Params, crate_tokens: Option) -> quote::Tokens { let Params { ref impl_generics, ref ty_generics, @@ -45,18 +46,6 @@ fn impl_tokens(params: &Params, crate_tokens: quote::Ident) -> quote::Tokens { ref fields, .. } = *params; - - let mut field_initialisers = quote::Tokens::new(); - for field in fields { - let ident = &field.ident; - field_initialisers.append_all(&[ - quote::Ident::new(ident.as_str()), - quote::Ident::new(":"), - quote::Ident::new("None"), - quote::Ident::new(","), - ]); - } - let getter_methods = fields .iter() .map(|&FieldParams { ref default, ref ty, ref ident }| { @@ -108,22 +97,22 @@ struct FieldParams { fn params(ast: &syn::DeriveInput) -> Result { // Ensure we are deriving for a struct. - let body = match ast.body { - syn::Body::Struct(ref body) => body, + let body = match ast.data { + syn::Data::Struct(ref body) => body, _ => return Err(Error::NotStruct), }; // We can only derive `WidgetStyle` for structs with fields. - let fields = match *body { - syn::VariantData::Struct(ref fields) => fields, - syn::VariantData::Tuple(_) => return Err(Error::TupleStruct), - syn::VariantData::Unit => return Err(Error::UnitStruct), + match body.fields { + syn::Fields::Named(_) => {}, + syn::Fields::Unnamed(_) => return Err(Error::TupleStruct), + syn::Fields::Unit => return Err(Error::UnitStruct), }; // For each field in the struct, create a method // // Produce an iterator yielding `Tokens` for each method. - let fields = fields + let fields = body.fields .iter() .filter_map(|field| { @@ -131,9 +120,9 @@ fn params(ast: &syn::DeriveInput) -> Result { let mut item = None; 'attrs: for nested_items in attr_elems { - for nested_item in nested_items { - if let syn::NestedMetaItem::MetaItem(ref meta_item) = *nested_item { - item = Some(meta_item); + for nested_item in nested_items{ + if let syn::NestedMeta::Meta(ref meta_item) = nested_item { + item = Some(meta_item.clone()); break 'attrs; } } @@ -144,16 +133,15 @@ fn params(ast: &syn::DeriveInput) -> Result { None => return None, }; - let literal = match *item { - syn::MetaItem::NameValue(ref ident, ref literal) if ident == "default" => literal, + let literal = match item { + syn::Meta::NameValue(syn::MetaNameValue{ref ident, ref lit,..}) if ident == "default" => lit, ref item => return Some(Err(Error::UnexpectedMetaItem(item.clone()))), }; - let default = match *literal { - syn::Lit::Str(ref str, _) => quote::Ident::new(&str[..]), + let default:Expr = match *literal { + syn::Lit::Str(ref litstr) => litstr.clone().parse().unwrap(), ref literal => return Some(Err(Error::UnexpectedLiteral(literal.clone()))), }; - let ident = match field.ident { Some(ref ident) => ident, None => return Some(Err(Error::UnnamedStructField)), @@ -161,7 +149,7 @@ fn params(ast: &syn::DeriveInput) -> Result { let ty = { let path = match field.ty { - syn::Ty::Path(_, ref path) => path, + syn::Type::Path(syn::TypePath{ref path,..}) => path, _ => return Some(Err(Error::NonOptionFieldTy)), }; @@ -175,13 +163,13 @@ fn params(ast: &syn::DeriveInput) -> Result { return Some(Err(Error::NonOptionFieldTy)); } - let angle_bracket_data = match path_segment.parameters { - syn::PathParameters::AngleBracketed(ref data) => data, + let angle_bracket_data = match path_segment.arguments { + syn::PathArguments::AngleBracketed(ref data) => data, _ => return Some(Err(Error::NonOptionFieldTy)), }; - let ty = match angle_bracket_data.types.len() { - 1 => &angle_bracket_data.types[0], + let ty = match angle_bracket_data.args.len() { + 1 => angle_bracket_data.args.first().unwrap(), _ => return Some(Err(Error::NonOptionFieldTy)), }; @@ -198,7 +186,7 @@ fn params(ast: &syn::DeriveInput) -> Result { }) .collect::>()?; - let dummy_const = syn::Ident::new(format!("_IMPL_WIDGET_STYLE_FOR_{}", ast.ident)); + let dummy_const = syn::Ident::from(format!("_IMPL_WIDGET_STYLE_FOR_{}", ast.ident)); let ident = &ast.ident; let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl(); @@ -218,7 +206,7 @@ enum Error { TupleStruct, UnitStruct, UnexpectedLiteral(syn::Lit), - UnexpectedMetaItem(syn::MetaItem), + UnexpectedMetaItem(syn::Meta), UnnamedStructField, NonOptionFieldTy, } diff --git a/conrod_derive/src/utils.rs b/conrod_derive/src/utils.rs index ea7a5de47..35f3ee5db 100644 --- a/conrod_derive/src/utils.rs +++ b/conrod_derive/src/utils.rs @@ -14,12 +14,15 @@ pub fn conrod_attrs<'a, I>(attrs: I) -> ConrodAttrs impl<'a, I> Iterator for ConrodAttrs where I: Iterator, { - type Item = &'a [syn::NestedMetaItem]; + type Item = Vec; fn next(&mut self) -> Option { while let Some(attr) = self.attrs.next() { - if let syn::MetaItem::List(ref ident, ref values) = attr.value { - if ident == "conrod" { - return Some(&values[..]); + if let Some(_meta) = attr.interpret_meta() { + if let &syn::Meta::List(ref _metalist) = &_meta{ + if _metalist.ident == syn::Ident::from("conrod"){ + let j = _metalist.nested.clone().into_pairs().map(|pair|pair.into_value()).collect::>(); + return Some(j); + } } } }