feat: use afit and rpitit to optimize Service trait

cloudwego · Oct 19, 2023 · 0209838 · 0209838
1 parent 18fdd56
commit 0209838
Show file tree

Hide file tree

Showing 11 changed files with 265 additions and 137 deletions.
diff --git a/motore-macros/Cargo.toml b/motore-macros/Cargo.toml
@@ -27,6 +27,9 @@ proc-macro2 = "1"
 quote = "1"
 syn = { version = "1", features = ["full"] }
 
-
 [dev-dependencies]
 motore = { path = "../motore" }
+
+[features]
+default = []
+service_send = []
diff --git a/motore-macros/src/lib.rs b/motore-macros/src/lib.rs
@@ -42,7 +42,8 @@ pub fn service(_args: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
-    let generic_params = &item.generics.params;
+    let generic_params: &syn::punctuated::Punctuated<syn::GenericParam, syn::token::Comma> =
+        &item.generics.params;
     let call_method = item
         .items
         .iter_mut()
@@ -89,7 +90,7 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         }
     };
 
-    let cx_is_generic = generic_params
+    let _cx_is_generic = generic_params
         .iter()
         .filter_map(|p| match p {
             syn::GenericParam::Type(t) => Some(t),
@@ -128,9 +129,16 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         }
     };
     sig.asyncness = None;
-    sig.generics = parse_quote!(<'cx, 's>);
-    sig.generics.where_clause = Some(parse_quote!(where 's: 'cx));
-    sig.output = parse_quote!(-> Self::Future<'cx>);
+    sig.generics = parse_quote!(<'s, 'cx>);
+    // sig.generics.where_clause = Some(parse_quote!(where 's: 'cx));
+    #[cfg(feature = "service_send")]
+    {
+        sig.output = parse_quote!(-> impl ::std::future::Future<Output = Result<Self::Response, Self::Error>> + Send);
+    }
+    #[cfg(not(feature = "service_send"))]
+    {
+        sig.output = parse_quote!(-> impl ::std::future::Future<Output = Result<Self::Response, Self::Error>>);
+    }
     sig.inputs[0] = parse_quote!(&'s self);
     let old_stmts = &call_method.block.stmts;
     call_method.block.stmts = vec![parse_quote!(async move { #(#old_stmts)* })];
@@ -143,14 +151,14 @@ fn expand(item: &mut ItemImpl) -> Result<(), syn::Error> {
         type Error = #err_ty;
     ));
 
-    let cx_bound = cx_is_generic.then(|| Some(quote!(Cx: 'cx,))).into_iter();
+    // let cx_bound = cx_is_generic.then(|| Some(quote!(Cx: 'cx,))).into_iter();
 
-    item.items.push(parse_quote!(
-       type Future<'cx> = impl ::std::future::Future<Output = Result<Self::Response, Self::Error>> + 'cx
-        where
-            #(#cx_bound)*
-            Self:'cx;
-    ));
+    // item.items.push(parse_quote!(
+    //    type Future<'cx> = impl ::std::future::Future<Output = Result<Self::Response,
+    // Self::Error>> + 'cx     where
+    //         #(#cx_bound)*
+    //         Self:'cx;
+    // ));
 
     Ok(())
 }
diff --git a/motore/Cargo.toml b/motore/Cargo.toml
@@ -32,7 +32,9 @@ tower = { version = "0.4", optional = true }
 http = "0.2"
 
 [features]
+default = ["service_send"]
 tower = ["dep:tower"]
+service_send = ["motore-macros/service_send"]
 
 [package.metadata.docs.rs]
 all-features = true

diff --git a/motore/src/make/make_connection.rs b/motore/src/make/make_connection.rs
@@ -11,12 +11,17 @@ use crate::{sealed::Sealed, UnaryService};
 pub trait MakeConnection<Address>: Sealed<(Address,)> {
     type Connection: AsyncRead + AsyncWrite + Unpin + Send;
     type Error;
-    type Future<'s>: Future<Output = Result<Self::Connection, Self::Error>> + Send + 's
-    where
-        Self: 's,
-        Address: 's;
 
-    fn make_connection(&self, req: Address) -> Self::Future<'_>;
+    #[cfg(feature = "service_send")]
+    fn make_connection(
+        &self,
+        req: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> + Send;
+    #[cfg(not(feature = "service_send"))]
+    fn make_connection(
+        &self,
+        req: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>>;
 }
 
 impl<S, Address> Sealed<(Address,)> for S where S: UnaryService<Address> {}
@@ -28,9 +33,19 @@ where
 {
     type Connection = S::Response;
     type Error = S::Error;
-    type Future<'s> = impl Future<Output = Result<Self::Connection, Self::Error>> + Send + 's where Self: 's, Address:'s;
 
-    fn make_connection(&self, addr: Address) -> Self::Future<'_> {
+    #[cfg(feature = "service_send")]
+    fn make_connection(
+        &self,
+        addr: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> + Send {
+        self.call(addr)
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn make_connection(
+        &self,
+        addr: Address,
+    ) -> impl Future<Output = Result<Self::Connection, Self::Error>> {
         self.call(addr)
     }
 }
diff --git a/motore/src/service/ext/map_err.rs b/motore/src/service/ext/map_err.rs
@@ -1,4 +1,6 @@
-use futures::{Future, TryFutureExt};
+use std::future::Future;
+
+use futures::TryFutureExt;
 
 use crate::Service;
 
@@ -20,15 +22,20 @@ where
 
     type Error = E;
 
-    type Future<'cx> = impl Future<Output = Result<Self::Response, Self::Error>> + 'cx
-    where
-        Cx: 'cx,
-        Self: 'cx;
-
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
-    where
-        's: 'cx,
-    {
+    #[cfg(feature = "service_send")]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
+        self.inner.call(cx, req).map_err(self.f.clone())
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> {
         self.inner.call(cx, req).map_err(self.f.clone())
     }
 }
diff --git a/motore/src/service/ext/map_response.rs b/motore/src/service/ext/map_response.rs
@@ -1,6 +1,6 @@
-use std::fmt;
+use std::{fmt, future::Future};
 
-use futures::{Future, TryFutureExt};
+use futures::TryFutureExt;
 
 use crate::Service;
 /// Service returned by the [`map_response`] combinator.
@@ -19,15 +19,21 @@ where
 {
     type Response = Response;
     type Error = S::Error;
-    type Future<'cx> = impl Future<Output = Result<Self::Response, Self::Error>> + 'cx
-    where
-        Cx: 'cx,
-        Self: 'cx;
 
-    fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
-    where
-        's: 'cx,
-    {
+    #[cfg(feature = "service_send")]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
+        self.inner.call(cx, req).map_ok(self.f.clone())
+    }
+    #[cfg(not(feature = "service_send"))]
+    fn call<'s, 'cx>(
+        &'s self,
+        cx: &'cx mut Cx,
+        req: Req,
+    ) -> impl Future<Output = Result<Self::Response, Self::Error>> {
         self.inner.call(cx, req).map_ok(self.f.clone())
     }
 }