Resolve merge conflicts from PR 10

Author: dtolnay

src/expand.rs

@@ -47,32 +47,16 @@ pub fn expand(input: &mut Item, is_local: bool) {
             };
             for inner in &mut input.items {
                 if let TraitItem::Method(method) = inner {
-<<<<<<< HEAD
                     let sig = &mut method.sig;
                     if sig.asyncness.is_some() {
                         let block = &mut method.default;
                         let mut has_self = has_self_in_sig(sig);
                         if let Some(block) = block {
                             has_self |= has_self_in_block(block);
-                            transform_block(context, sig, block, has_self);
-||||||| merged common ancestors
-                    if method.sig.asyncness.is_some() {
-                        if let Some(block) = &mut method.default {
-                            transform_block(context, &method.sig, block);
-=======
-                    if method.sig.asyncness.is_some() {
-                        if let Some(block) = &mut method.default {
-                            transform_block(context, &method.sig, block, is_local);
->>>>>>> pr/10
+                            transform_block(context, sig, block, has_self, is_local);
                         }
                         let has_default = method.default.is_some();
-<<<<<<< HEAD
-                        transform_sig(context, sig, has_self, has_default);
-||||||| merged common ancestors
-                        transform_sig(context, &mut method.sig, has_default);
-=======
-                        transform_sig(context, &mut method.sig, has_default, is_local);
->>>>>>> pr/10
+                        transform_sig(context, sig, has_self, has_default, is_local);
                     }
                 }
             }
@@ -85,22 +69,12 @@ pub fn expand(input: &mut Item, is_local: bool) {
             };
             for inner in &mut input.items {
                 if let ImplItem::Method(method) = inner {
-<<<<<<< HEAD
                     let sig = &mut method.sig;
                     if sig.asyncness.is_some() {
                         let block = &mut method.block;
                         let has_self = has_self_in_sig(sig) || has_self_in_block(block);
-                        transform_block(context, sig, block, has_self);
-                        transform_sig(context, sig, has_self, false);
-||||||| merged common ancestors
-                    if method.sig.asyncness.is_some() {
-                        transform_block(context, &method.sig, &mut method.block);
-                        transform_sig(context, &mut method.sig, false);
-=======
-                    if method.sig.asyncness.is_some() {
-                        transform_block(context, &method.sig, &mut method.block, is_local);
-                        transform_sig(context, &mut method.sig, false, is_local);
->>>>>>> pr/10
+                        transform_block(context, sig, block, has_self, is_local);
+                        transform_sig(context, sig, has_self, false, is_local);
                     }
                 }
             }
@@ -121,13 +95,7 @@ pub fn expand(input: &mut Item, is_local: bool) {
 //         'life1: 'async_trait,
 //         T: 'async_trait,
 //         Self: Sync + 'async_trait;
-<<<<<<< HEAD
-fn transform_sig(context: Context, sig: &mut MethodSig, has_self: bool, has_default: bool) {
-||||||| merged common ancestors
-fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool) {
-=======
-fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool, is_local: bool) {
->>>>>>> pr/10
+fn transform_sig(context: Context, sig: &mut MethodSig, has_self: bool, has_default: bool, is_local: bool) {
     sig.decl.fn_token.span = sig.asyncness.take().unwrap().span;
 
     let ret = match &sig.decl.output {
@@ -244,13 +212,7 @@ fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool, is_lo
 //         _self + x
 //     }
 //     Pin::from(Box::new(async_trait_method::<T, Self>(self, x)))
-<<<<<<< HEAD
-fn transform_block(context: Context, sig: &mut MethodSig, block: &mut Block, has_self: bool) {
-||||||| merged common ancestors
-fn transform_block(context: Context, sig: &MethodSig, block: &mut Block) {
-=======
-fn transform_block(context: Context, sig: &MethodSig, block: &mut Block, is_local: bool) {
->>>>>>> pr/10
+fn transform_block(context: Context, sig: &mut MethodSig, block: &mut Block, has_self: bool, is_local: bool) {
     let inner = Ident::new(&format!("__{}", sig.ident), sig.ident.span());
     let args = sig
         .decl
@@ -319,26 +281,6 @@ fn transform_block(context: Context, sig: &MethodSig, block: &mut Block, is_loca
                     *arg = parse_quote! {
                         #under_self: &#lifetime #mutability AsyncTrait
                     };
-<<<<<<< HEAD
-||||||| merged common ancestors
-                    let (_, generics, _) = generics.split_for_impl();
-                    standalone.decl.generics.params.push(parse_quote! {
-                        AsyncTrait: ?Sized + #name #generics + core::marker::#bound
-                    });
-                    types.push(Ident::new("Self", Span::call_site()));
-=======
-                    let (_, generics, _) = generics.split_for_impl();
-                    if is_local {
-                        standalone.decl.generics.params.push(parse_quote! {
-                            AsyncTrait: ?Sized + #name #generics
-                        });
-                    } else {
-                        standalone.decl.generics.params.push(parse_quote! {
-                            AsyncTrait: ?Sized + #name #generics + core::marker::#bound
-                        });
-                    }
-                    types.push(Ident::new("Self", Span::call_site()));
->>>>>>> pr/10
                 }
                 Context::Impl { receiver, .. } => {
                     *arg = parse_quote! {
@@ -382,7 +324,9 @@ fn transform_block(context: Context, sig: &MethodSig, block: &mut Block, is_loca
         if has_self {
             let (_, generics, _) = generics.split_for_impl();
             let mut self_param: TypeParam = parse_quote!(AsyncTrait: ?Sized + #name #generics);
-            self_param.bounds.extend(self_bound);
+            if !is_local {
+                self_param.bounds.extend(self_bound);
+            }
             standalone
                 .decl
                 .generics