Merge pull request hobofan#70 from glandium/syn2

Switch to syn 2

Author: dewert99

.github/workflows/lint.yml

@@ -8,7 +8,7 @@ jobs:
     strategy:
       matrix:
         rust:
-          - 1.53.0
+          - 1.68.0
     steps:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1
@@ -34,7 +34,7 @@ jobs:
     strategy:
       matrix:
         rust:
-          - 1.53.0
+          - 1.68.0
     steps:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1

.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       matrix:
         rust:
-          - 1.53.0
+          - 1.68.0
     steps:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1
@@ -34,7 +34,7 @@ jobs:
       matrix:
         rust:
           - 1.79.0
-          # It's useful to test applications of these macros to newer features so using 1.53 for tests doesn't work
+          # It's useful to test applications of these macros to newer features so using 1.68 for tests doesn't work
           # This needs to be locked to a specific version of Rust since the exact error messages may change
           # When switching this Rust version make sure to also update tests to use newer error messages if applicable
     steps:

README.md

@@ -16,7 +16,7 @@
 
 Delegating the implementation of traits to enum variants or fields of a struct normally requires a lot of boilerplate code. Ambassador is an attempt to eliminate that boilerplate by deriving the delegating trait implementation via procedural macros.
 
-**The minimum supported Rust version is 1.53.0.**
+**The minimum supported Rust version is 1.68.0.**
 
 ## Installation
 

ambassador/Cargo.toml

@@ -13,7 +13,7 @@ readme = "README.md"
 proc-macro = true
 
 [dependencies]
-syn = { version = "1.0.25", features = ["full", "extra-traits"] }
+syn = { version = "2", features = ["full", "extra-traits"] }
 quote = "1.0.2"
 proc-macro2 = "1.0.6"
 itertools = "0.10.3"

ambassador/src/delegate_shared.rs

@@ -90,8 +90,8 @@ pub(super) fn delegate_macro<I>(
     // Parse the input tokens into a syntax tree
     let mut delegate_attributes = attrs
         .into_iter()
-        .filter(|attr| attr.path.is_ident("delegate"))
-        .map(|attr| attr.tokens)
+        .filter(|attr| attr.path().is_ident("delegate"))
+        .map(|attr| attr.meta.to_token_stream().into_iter().skip(1).collect())
         .peekable();
     if delegate_attributes.peek().is_none() {
         return error!(

ambassador/src/delegate_to_methods.rs

@@ -4,7 +4,7 @@ use super::util;
 use crate::util::{error, try_option, ReceiverType};
 use itertools::Itertools;
 use proc_macro::TokenStream;
-use proc_macro2::{Ident, TokenStream as TokenStream2};
+use proc_macro2::{Ident, TokenStream as TokenStream2, TokenTree};
 use quote::{quote, ToTokens};
 use std::cell::Cell;
 use std::convert::{TryFrom, TryInto};
@@ -30,19 +30,18 @@ struct MethodInfo {
     used: Cell<bool>, // modified when a usage is found
 }
 
-impl TryFrom<syn::ImplItemMethod> for MethodInfo {
+impl TryFrom<syn::ImplItemFn> for MethodInfo {
     type Error = (Ident, syn::Error);
 
-    fn try_from(method: syn::ImplItemMethod) -> std::result::Result<Self, (Ident, syn::Error)> {
+    fn try_from(method: syn::ImplItemFn) -> std::result::Result<Self, (Ident, syn::Error)> {
         let receiver_or_err = util::receiver_type(&method.sig);
         let return_span = method.sig.paren_token.span;
         let mut ident = Some(method.sig.ident);
         let mut add_ident = |err| (ident.take().unwrap(), err);
         let receiver = receiver_or_err.map_err(&mut add_ident)?;
         let ret = match method.sig.output {
-            ReturnType::Default => {
-                error!(return_span, "delegated to methods must return").map_err(&mut add_ident)?
-            }
+            ReturnType::Default => error!(return_span.open(), "delegated to methods must return")
+                .map_err(&mut add_ident)?,
             ReturnType::Type(_, t) => *t,
         };
         let ret = match (ret, receiver) {
@@ -188,20 +187,37 @@ impl DelegateTarget {
     }
 }
 
+fn replace_semi_with_block(input: TokenStream2) -> TokenStream2 {
+    input
+        .into_iter()
+        .map(|token| match token {
+            TokenTree::Punct(p) if p.as_char() == ';' => TokenTree::Group(proc_macro2::Group::new(
+                proc_macro2::Delimiter::Brace,
+                TokenStream2::new(),
+            )),
+            token => token,
+        })
+        .collect()
+}
+
 // Checks that:
 //   - all the items in an impl are methods
 //   - all the methods are _empty_ (no body, just the signature)
 fn check_for_method_impls_and_extras(impl_items: &[syn::ImplItem]) -> Result<()> {
     let iter = impl_items.iter().filter_map(|i| {
+        let mut i = i;
         // We're looking for *only* empty methods (no block).
-        if let syn::ImplItem::Method(m) = i {
+        let mut _item: Option<syn::ImplItem> = None;
+        // syn 2 doesn't parse functions with omitted blocks as ImplItemFn.
+        if let syn::ImplItem::Verbatim(v) = i {
+            _item = Some(syn::parse2::<syn::ImplItem>(replace_semi_with_block(v.clone())).ok()?);
+            i = _item.as_ref().unwrap();
+        }
+        if let syn::ImplItem::Fn(m) = i {
             let block = &m.block;
-            let empty_block = syn::parse2::<syn::ImplItemMethod>(quote! { fn foo(); })
-                .unwrap()
-                .block;
 
             // We'll accept `{}` blocks and omitted blocks (i.e. `fn foo();`):
-            if block.stmts.is_empty() || block == &empty_block {
+            if block.stmts.is_empty() {
                 None
             } else {
                 Some(syn::Error::new(
@@ -257,7 +273,7 @@ pub fn delegate_macro(input: TokenStream, keep_impl_block: bool) -> TokenStream
     let mut input = parse_macro_input!(input as ItemImpl);
     let attrs = std::mem::take(&mut input.attrs);
     assert!(
-        attrs.iter().all(|attr| attr.path.is_ident("delegate")),
+        attrs.iter().all(|attr| attr.path().is_ident("delegate")),
         "All attributes must be \"delegate\""
     );
     let keep_info = if keep_impl_block {
@@ -269,7 +285,13 @@ pub fn delegate_macro(input: TokenStream, keep_impl_block: bool) -> TokenStream
         .items
         .into_iter()
         .filter_map(|item| match item {
-            syn::ImplItem::Method(method) => Some(method.try_into()),
+            syn::ImplItem::Fn(method) => Some(method.try_into()),
+            syn::ImplItem::Verbatim(v) => {
+                // syn 2 doesn't parse functions with omitted blocks as ImplItemFn.
+                syn::parse2::<syn::ImplItemFn>(replace_semi_with_block(v))
+                    .ok()
+                    .map(MethodInfo::try_from)
+            }
             _ => None,
         })
         .partition_result();

ambassador/src/derive.rs

@@ -89,18 +89,14 @@ fn try_info_from_data(span: Span, data: syn::Data) -> Result<DelegateImplementer
     Ok(res)
 }
 
+#[derive(Default)]
 enum DelegateTarget {
     Field(syn::Member),
+    #[default]
     TrgNone,
     TrgSelf,
 }
 
-impl Default for DelegateTarget {
-    fn default() -> Self {
-        DelegateTarget::TrgNone
-    }
-}
-
 impl delegate_shared::DelegateTarget for DelegateTarget {
     fn try_update(&mut self, key: &str, lit: LitStr) -> Option<Result<()>> {
         match key {

ambassador/src/lib.rs

@@ -17,7 +17,7 @@
 //!
 //! Delegating the implementation of traits to enum variants or fields of a struct normally requires a lot of boilerplate code. Ambassador is an attempt to eliminate that boilerplate by deriving the delegating trait implementation via procedural macros.
 //!
-//! **The minimum supported Rust version is 1.53.0.**
+//! **The minimum supported Rust version is 1.68.0.**
 //!
 //! See individual macro documentation for detailed instructions.
 //!

ambassador/src/register.rs

@@ -1,11 +1,11 @@
 use crate::util::{error, process_results, receiver_type, ReceiverType};
 use itertools::Itertools;
-use proc_macro2::{Delimiter, Ident, TokenStream, TokenTree};
+use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{quote, ToTokens, TokenStreamExt};
 use syn::spanned::Spanned;
 use syn::{
-    AttrStyle, Attribute, ConstParam, GenericParam, ItemTrait, LifetimeDef, ReturnType, TraitItem,
-    TraitItemConst, TraitItemType, TypeParam, Visibility,
+    AttrStyle, Attribute, ConstParam, GenericParam, ItemTrait, LifetimeParam, ReturnType,
+    TraitItem, TraitItemConst, TraitItemType, TypeParam, Visibility,
 };
 
 pub(crate) fn macro_name(trait_ident: &Ident) -> Ident {
@@ -116,15 +116,15 @@ pub fn build_register_trait(original_item: &ItemTrait) -> TokenStream {
 fn param_to_ident(param: &GenericParam) -> &Ident {
     match param {
         GenericParam::Type(TypeParam { ident, .. }) => ident,
-        GenericParam::Lifetime(LifetimeDef { lifetime, .. }) => &lifetime.ident,
+        GenericParam::Lifetime(LifetimeParam { lifetime, .. }) => &lifetime.ident,
         GenericParam::Const(ConstParam { ident, .. }) => ident,
     }
 }
 
 fn param_to_matcher(param: &GenericParam) -> TokenStream {
     match param {
         GenericParam::Type(TypeParam { ident, .. }) => quote!($ #ident : ty,),
-        GenericParam::Lifetime(LifetimeDef { lifetime, .. }) => {
+        GenericParam::Lifetime(LifetimeParam { lifetime, .. }) => {
             let ident = &lifetime.ident;
             quote!($ #ident : lifetime,)
         }
@@ -135,7 +135,7 @@ fn param_to_matcher(param: &GenericParam) -> TokenStream {
 fn param_to_tokens(param: &GenericParam) -> TokenStream {
     match param {
         GenericParam::Type(TypeParam { ident, .. }) => quote!(#ident,),
-        GenericParam::Lifetime(LifetimeDef { lifetime, .. }) => quote!(#lifetime,),
+        GenericParam::Lifetime(LifetimeParam { lifetime, .. }) => quote!(#lifetime,),
         GenericParam::Const(ConstParam { ident, .. }) => quote!(#ident,),
     }
 }
@@ -220,9 +220,9 @@ fn build_method(
 fn extract_cfg(attrs: &[Attribute]) -> Option<TokenStream> {
     let mut iter = attrs
         .iter()
-        .filter(|attr| attr.style == AttrStyle::Outer && attr.path.is_ident("cfg"))
-        .filter_map(|attr| match attr.tokens.clone().into_iter().next()? {
-            TokenTree::Group(x) if x.delimiter() == Delimiter::Parenthesis => Some(x.stream()),
+        .filter(|attr| attr.style == AttrStyle::Outer && attr.path().is_ident("cfg"))
+        .filter_map(|attr| match &attr.meta {
+            syn::Meta::List(meta_list) => Some(meta_list.tokens.clone()),
             _ => None,
         });
     let e0 = iter.next()?;
@@ -268,7 +268,7 @@ fn build_trait_items(
                 quote! {compile_error!("trg=\"self\" is not allowed with associated types")},
             )
         }
-        TraitItem::Method(original_method) => {
+        TraitItem::Fn(original_method) => {
             let method_sig = original_method.sig.to_token_stream();
             let method_sig = replace_gen_idents(method_sig, gen_idents);
             (
@@ -334,7 +334,7 @@ fn build_trait_items(
     let attrs: &[Attribute] = match original_item {
         TraitItem::Const(c) => &c.attrs,
         TraitItem::Type(t) => &t.attrs,
-        TraitItem::Method(m) => &m.attrs,
+        TraitItem::Fn(m) => &m.attrs,
         _ => &[],
     };
     if let Some(pred) = extract_cfg(attrs) {
@@ -346,7 +346,7 @@ fn build_trait_items(
 }
 
 fn build_method_invocation(
-    original_method: &syn::TraitItemMethod,
+    original_method: &syn::TraitItemFn,
     field_ident: &TokenStream,
     force_add_await: bool,
 ) -> TokenStream {

ambassador/src/util.rs

@@ -122,11 +122,11 @@ fn receiver_type_inner(r: &Receiver) -> ReceiverType {
 
 pub(crate) fn receiver_type(sig: &syn::Signature) -> Result<ReceiverType> {
     match sig.receiver() {
-        Some(syn::FnArg::Receiver(r)) => Ok(receiver_type_inner(r)),
-        Some(syn::FnArg::Typed(t)) => error!(
-            t.span(),
+        Some(r) if r.colon_token.is_none() => Ok(receiver_type_inner(r)),
+        Some(r) => error!(
+            r.span(),
             "method's receiver type is not supported (must one of self, &self, or &mut self)"
         ),
-        None => error!(sig.paren_token.span, "method must have a receiver"),
+        None => error!(sig.paren_token.span.open(), "method must have a receiver"),
     }
 }