fix async_scoped 'static return type

futures-derive/src/lib.rs

···
 use proc_macro::TokenStream;
-use quote::quote;
+use quote::{ToTokens, quote};
 use syn::{
-    Expr, ExprAwait, FnArg, ItemFn, Pat, ReturnType, Signature,
-    parse_macro_input, visit_mut::VisitMut,
+    Expr, ExprAwait, FnArg, GenericArgument, ItemFn, Pat, ReturnType,
+    Signature, parse_macro_input, visit_mut::VisitMut,
 };
 
 #[proc_macro_attribute]
···
         })
         .collect();
 
-    // let has_refs = inputs
+    let has_lifetime_dependency = inputs.iter().any(|param| match param {
+        FnArg::Receiver(receiver) => receiver.reference.is_some(),
+        FnArg::Typed(pat) => has_lifetime_dependency(&pat.ty),
+    });
+
+    let outer_output = if has_lifetime_dependency {
+        quote! { futures_core::ScopedFuture<'_, Output = #output> + '_ }
+    } else {
+        quote! { futures_core::ScopedFuture<'static, Output = #output> }
+    };
 
     quote! {
-        #(#attrs)* #vis #constness #unsafety fn #ident #generics (#inputs) -> impl futures_core::ScopedFuture<'_, Output = #output> + '_ {
+        #(#attrs)* #vis #constness #unsafety fn #ident #generics (#inputs) -> impl #outer_output {
             async #constness #unsafety fn __inner (#inputs) -> #output #block
 
             let future = __inner(#(#inner_args),*);
 
             unsafe { futures_compat::UnscopedFutureWrapper::from_future(future) }
         }
+    }
+}
+
+/// Determines if typed pattern contains a reference or dependency on a
+/// lifetime (used for deciding between '_ and 'static ScopedFuture).
+fn has_lifetime_dependency(ty: &syn::Type) -> bool {
+    match ty {
+        syn::Type::Reference(_) => true,
+        syn::Type::Path(type_path) => {
+            type_path.path.segments.iter().any(|segment| {
+                if let syn::PathArguments::AngleBracketed(args) =
+                    &segment.arguments
+                {
+                    args.args.iter().any(|arg| match arg {
+                        GenericArgument::Type(ty) => {
+                            has_lifetime_dependency(ty)
+                        }
+                        syn::GenericArgument::Lifetime(_) => true,
+                        _ => false,
+                    })
+                } else {
+                    false
+                }
+            })
+        }
+        syn::Type::Tuple(tuple) => {
+            tuple.elems.iter().any(has_lifetime_dependency)
+        }
+        syn::Type::Slice(slice) => has_lifetime_dependency(&slice.elem),
+        syn::Type::Array(array) => has_lifetime_dependency(&array.elem),
+        syn::Type::Ptr(ptr) => has_lifetime_dependency(&ptr.elem),
+        syn::Type::Group(group) => has_lifetime_dependency(&group.elem),
+        syn::Type::Paren(paren) => has_lifetime_dependency(&paren.elem),
+        syn::Type::BareFn(bare_fn) => {
+            bare_fn
+                .inputs
+                .iter()
+                .any(|input| has_lifetime_dependency(&input.ty))
+                || match &bare_fn.output {
+                    ReturnType::Default => false,
+                    ReturnType::Type(_, ty) => has_lifetime_dependency(ty),
+                }
+        }
+
+        _ => false,
     }
 }