Preserve span of _self tokens

Author: dtolnay

src/expand.rs

@@ -7,9 +7,9 @@ use std::mem;
 use syn::punctuated::Punctuated;
 use syn::visit_mut::VisitMut;
 use syn::{
-    parse_quote, ArgCaptured, ArgSelfRef, Block, FnArg, GenericParam, Generics, Ident, ImplItem,
-    Lifetime, MethodSig, Pat, PatIdent, Path, ReturnType, Token, TraitItem, Type, TypeParam,
-    TypeParamBound, WhereClause,
+    parse_quote, ArgCaptured, ArgSelf, ArgSelfRef, Block, FnArg, GenericParam, Generics, Ident,
+    ImplItem, Lifetime, MethodSig, Pat, PatIdent, Path, ReturnType, Token, TraitItem, Type,
+    TypeParam, TypeParamBound, WhereClause,
 };
 
 impl ToTokens for Item {
@@ -256,44 +256,53 @@ fn transform_block(context: Context, sig: &mut MethodSig, block: &mut Block, has
     let mut self_bound = None::<TypeParamBound>;
     match standalone.decl.inputs.iter_mut().next() {
         Some(arg @ FnArg::SelfRef(_)) => {
-            let (lifetime, mutability) = match arg {
+            let (lifetime, mutability, self_token) = match arg {
                 FnArg::SelfRef(ArgSelfRef {
                     lifetime,
                     mutability,
+                    self_token,
                     ..
-                }) => (lifetime, mutability),
+                }) => (lifetime, mutability, self_token),
                 _ => unreachable!(),
             };
+            let under_self = Ident::new("_self", self_token.span);
             match context {
                 Context::Trait { .. } => {
                     self_bound = Some(match mutability {
                         Some(_) => parse_quote!(core::marker::Send),
                         None => parse_quote!(core::marker::Sync),
                     });
                     *arg = parse_quote! {
-                        _self: &#lifetime #mutability AsyncTrait
+                        #under_self: &#lifetime #mutability AsyncTrait
                     };
                 }
                 Context::Impl { receiver, .. } => {
                     *arg = parse_quote! {
-                        _self: &#lifetime #mutability #receiver
+                        #under_self: &#lifetime #mutability #receiver
                     };
                 }
             }
         }
-        Some(arg @ FnArg::SelfValue(_)) => match context {
-            Context::Trait { .. } => {
-                self_bound = Some(parse_quote!(core::marker::Send));
-                *arg = parse_quote! {
-                    _self: AsyncTrait
-                };
-            }
-            Context::Impl { receiver, .. } => {
-                *arg = parse_quote! {
-                    _self: #receiver
-                };
+        Some(arg @ FnArg::SelfValue(_)) => {
+            let self_token = match arg {
+                FnArg::SelfValue(ArgSelf { self_token, .. }) => self_token,
+                _ => unreachable!(),
+            };
+            let under_self = Ident::new("_self", self_token.span);
+            match context {
+                Context::Trait { .. } => {
+                    self_bound = Some(parse_quote!(core::marker::Send));
+                    *arg = parse_quote! {
+                        #under_self: AsyncTrait
+                    };
+                }
+                Context::Impl { receiver, .. } => {
+                    *arg = parse_quote! {
+                        #under_self: #receiver
+                    };
+                }
             }
-        },
+        }
         Some(FnArg::Captured(ArgCaptured {
             pat: Pat::Ident(arg),
             ..

src/receiver.rs

@@ -2,7 +2,7 @@ use std::mem;
 use syn::punctuated::Punctuated;
 use syn::visit_mut::{self, VisitMut};
 use syn::{
-    parse_quote, ArgSelf, ArgSelfRef, Block, ExprPath, Item, MethodSig, Path, QSelf, Type, TypePath,
+    ArgSelf, ArgSelfRef, Block, ExprPath, Ident, Item, MethodSig, Path, QSelf, Type, TypePath,
 };
 
 pub fn has_self_in_sig(sig: &mut MethodSig) -> bool {
@@ -127,7 +127,8 @@ impl VisitMut for ReplaceReceiver {
     fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
         if expr.qself.is_none() {
             if expr.path.is_ident("self") {
-                expr.path.segments[0].ident = parse_quote!(_self);
+                let ident = &mut expr.path.segments[0].ident;
+                *ident = Ident::new("_self", ident.span());
             }
             self.self_to_qself_expr(&mut expr.qself, &mut expr.path);
         }