Update to syn 3

Author: dtolnay

Cargo.toml

@@ -18,7 +18,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.74"
 quote = "1.0.35"
-syn = { version = "2.0.46", default-features = false, features = ["clone-impls", "full", "parsing", "printing", "proc-macro", "visit-mut"] }
+syn = { version = "3", default-features = false, features = ["clone-impls", "full", "parsing", "printing", "proc-macro", "visit-mut"] }
 
 [dev-dependencies]
 futures = "0.3.30"

src/expand.rs

@@ -12,7 +12,7 @@ use syn::visit_mut::{self, VisitMut};
 use syn::{
     parse_quote, parse_quote_spanned, Attribute, Block, FnArg, GenericArgument, GenericParam,
     Generics, Ident, ImplItem, Lifetime, LifetimeParam, Pat, PatIdent, PathArguments, Receiver,
-    ReturnType, Signature, Token, TraitItem, Type, TypeInfer, TypePath, WhereClause,
+    ReceiverKind, ReturnType, Signature, Token, TraitItem, Type, TypeInfer, TypePath, WhereClause,
 };
 
 impl ToTokens for Item {
@@ -248,30 +248,37 @@ fn transform_sig(
         let bounds: &[InferredBound] = if is_local {
             &[]
         } else if let Some(receiver) = sig.receiver() {
-            match receiver.ty.as_ref() {
-                // self: &Self
-                Type::Reference(ty) if ty.mutability.is_none() => &[InferredBound::Sync],
-                // self: Arc<Self>
-                Type::Path(ty)
-                    if {
-                        let segment = ty.path.segments.last().unwrap();
-                        segment.ident == "Arc"
-                            && match &segment.arguments {
-                                PathArguments::AngleBracketed(arguments) => {
-                                    arguments.args.len() == 1
-                                        && match &arguments.args[0] {
-                                            GenericArgument::Type(Type::Path(arg)) => {
-                                                arg.path.is_ident("Self")
+            match &receiver.kind {
+                // &self
+                ReceiverKind::Reference(_ampersand, _lifetime, None::<Token![mut]>) => {
+                    &[InferredBound::Sync]
+                }
+                ReceiverKind::Typed(_colon, ty) => match ty.as_ref() {
+                    // self: &Self
+                    Type::Reference(ty) if ty.mutability.is_none() => &[InferredBound::Sync],
+                    // self: Arc<Self>
+                    Type::Path(ty)
+                        if {
+                            let segment = ty.path.segments.last().unwrap();
+                            segment.ident == "Arc"
+                                && match &segment.arguments {
+                                    PathArguments::AngleBracketed(arguments) => {
+                                        arguments.args.len() == 1
+                                            && match &arguments.args[0] {
+                                                GenericArgument::Type(Type::Path(arg)) => {
+                                                    arg.path.is_ident("Self")
+                                                }
+                                                _ => false,
                                             }
-                                            _ => false,
-                                        }
+                                    }
+                                    _ => false,
                                 }
-                                _ => false,
-                            }
-                    } =>
-                {
-                    &[InferredBound::Sync, InferredBound::Send]
-                }
+                        } =>
+                    {
+                        &[InferredBound::Sync, InferredBound::Send]
+                    }
+                    _ => &[InferredBound::Send],
+                },
                 _ => &[InferredBound::Send],
             }
         } else {
@@ -293,9 +300,7 @@ fn transform_sig(
     for (i, arg) in sig.inputs.iter_mut().enumerate() {
         match arg {
             FnArg::Receiver(receiver) => {
-                if receiver.reference.is_none() {
-                    receiver.mutability = None;
-                }
+                receiver.mutability = None;
             }
             FnArg::Typed(arg) => {
                 if match *arg.ty {
@@ -493,6 +498,7 @@ fn replace_impl_trait_with_infer(ty: &mut Type) {
         fn visit_type_mut(&mut self, ty: &mut Type) {
             if let Type::ImplTrait(impl_trait) = ty {
                 *ty = Type::Infer(TypeInfer {
+                    attrs: Vec::new(),
                     underscore_token: Token![_](impl_trait.impl_token.span),
                 });
             }

src/lifetime.rs

@@ -2,8 +2,8 @@ use proc_macro2::{Span, TokenStream};
 use std::mem;
 use syn::visit_mut::{self, VisitMut};
 use syn::{
-    parse_quote_spanned, token, Expr, GenericArgument, Lifetime, Receiver, ReturnType, Token, Type,
-    TypeBareFn, TypeImplTrait, TypeParen, TypePtr, TypeReference,
+    parse_quote_spanned, token, Expr, GenericArgument, Lifetime, ReceiverKind, ReturnType, Token,
+    Type, TypeFnPtr, TypeImplTrait, TypeParen, TypePtr, TypeReference,
 };
 
 pub struct CollectLifetimes {
@@ -43,11 +43,16 @@ impl CollectLifetimes {
 }
 
 impl VisitMut for CollectLifetimes {
-    fn visit_receiver_mut(&mut self, arg: &mut Receiver) {
-        if let Some((reference, lifetime)) = &mut arg.reference {
-            self.visit_opt_lifetime(reference, lifetime);
-        } else {
-            visit_mut::visit_type_mut(self, &mut arg.ty);
+    fn visit_receiver_kind_mut(&mut self, receiver: &mut ReceiverKind) {
+        match receiver {
+            ReceiverKind::Value => {}
+            ReceiverKind::Reference(reference, lifetime, _mutability) => {
+                self.visit_opt_lifetime(reference, lifetime);
+            }
+            ReceiverKind::Typed(_colon, ty) => {
+                visit_mut::visit_type_mut(self, ty);
+            }
+            _ => {}
         }
     }
 
@@ -87,11 +92,11 @@ impl VisitMut for AddLifetimeToImplTrait {
         visit_mut::visit_type_ptr_mut(self, ty);
     }
 
-    fn visit_type_bare_fn_mut(&mut self, ty: &mut TypeBareFn) {
+    fn visit_type_fn_ptr_mut(&mut self, ty: &mut TypeFnPtr) {
         if let ReturnType::Type(arrow, return_type) = &mut ty.output {
             parenthesize_impl_trait(return_type, arrow.spans[0]);
         }
-        visit_mut::visit_type_bare_fn_mut(self, ty);
+        visit_mut::visit_type_fn_ptr_mut(self, ty);
     }
 
     fn visit_expr_mut(&mut self, _e: &mut Expr) {
@@ -105,6 +110,7 @@ fn parenthesize_impl_trait(elem: &mut Type, paren_span: Span) {
     if let Type::ImplTrait(_) = *elem {
         let placeholder = Type::Verbatim(TokenStream::new());
         *elem = Type::Paren(TypeParen {
+            attrs: Vec::new(),
             paren_token: token::Paren(paren_span),
             elem: Box::new(mem::replace(elem, placeholder)),
         });