Merge pull request #107 from taiki-e/impl-lifetime

Replace elided lifetimes to explicit lifetimes in trait impl

Author: dtolnay

src/expand.rs

@@ -81,6 +81,13 @@ pub fn expand(input: &mut Item, is_local: bool) {
             }
         }
         Item::Impl(input) => {
+            let mut lifetimes = CollectLifetimes::with("'impl_life");
+            lifetimes.visit_type_mut(&mut *input.self_ty);
+            lifetimes.visit_path_mut(&mut input.trait_.as_mut().unwrap().1);
+            let params = &input.generics.params;
+            let elided = lifetimes.elided;
+            input.generics.params = parse_quote!( #(#elided,)* #params );
+
             let context = Context::Impl {
                 impl_generics: &input.generics,
                 receiver: &input.self_ty,

src/lifetime.rs

@@ -24,13 +24,23 @@ impl VisitMut for HasAsyncLifetime {
 pub struct CollectLifetimes {
     pub elided: Vec<Lifetime>,
     pub explicit: Vec<Lifetime>,
+    pub name: &'static str,
 }
 
 impl CollectLifetimes {
     pub fn new() -> Self {
         CollectLifetimes {
             elided: Vec::new(),
             explicit: Vec::new(),
+            name: "'life",
+        }
+    }
+
+    pub fn with(name: &'static str) -> Self {
+        CollectLifetimes {
+            elided: Vec::new(),
+            explicit: Vec::new(),
+            name,
         }
     }
 
@@ -50,7 +60,7 @@ impl CollectLifetimes {
     }
 
     fn next_lifetime(&mut self) -> Lifetime {
-        let name = format!("'life{}", self.elided.len());
+        let name = format!("{}{}", self.name, self.elided.len());
         let life = Lifetime::new(&name, Span::call_site());
         self.elided.push(life.clone());
         life

tests/test.rs

@@ -905,3 +905,35 @@ mod issue104 {
 
     impl_t1!(Foo, 1);
 }
+
+// https://github.com/dtolnay/async-trait/issues/106
+mod issue106 {
+    use async_trait::async_trait;
+    use std::future::Future;
+
+    #[async_trait]
+    pub trait ProcessPool: Send + Sync {
+        type ThreadPool;
+
+        async fn spawn<F, Fut, T>(&self, work: F) -> T
+        where
+            F: FnOnce(&Self::ThreadPool) -> Fut + Send,
+            Fut: Future<Output = T> + 'static;
+    }
+
+    #[async_trait]
+    impl<P: ?Sized> ProcessPool for &P
+    where
+        P: ProcessPool,
+    {
+        type ThreadPool = P::ThreadPool;
+
+        async fn spawn<F, Fut, T>(&self, work: F) -> T
+        where
+            F: FnOnce(&Self::ThreadPool) -> Fut + Send,
+            Fut: Future<Output = T> + 'static,
+        {
+            (*self).spawn(work).await
+        }
+    }
+}