feat: Add IntoRequest and IntoStreamingRequest traits

tonic-build/src/client.rs

@@ -99,12 +99,14 @@ fn generate_unary(method: &Method, proto: &str, path: String) -> TokenStream {
     let (request, response) = crate::replace_wellknown(proto, &method);
 
     quote! {
-        pub async fn #ident(&mut self, request: tonic::Request<#request>)
-            -> Result<tonic::Response<#response>, tonic::Status> {
+        pub async fn #ident(
+            &mut self,
+            request: impl tonic::IntoRequest<Message = #request>,
+        ) -> Result<tonic::Response<#response>, tonic::Status> {
            self.ready().await?;
            let codec = tonic::codec::ProstCodec::new();
            let path = http::uri::PathAndQuery::from_static(#path);
-           self.inner.unary(request, path, codec).await
+           self.inner.unary(request.into_request(), path, codec).await
         }
     }
 }
@@ -115,12 +117,14 @@ fn generate_server_streaming(method: &Method, proto: &str, path: String) -> Toke
     let (request, response) = crate::replace_wellknown(proto, &method);
 
     quote! {
-        pub async fn #ident(&mut self, request: tonic::Request<#request>)
-            -> Result<tonic::Response<tonic::codec::Streaming<#response>>, tonic::Status> {
+        pub async fn #ident(
+            &mut self,
+            request: impl tonic::IntoRequest<Message = #request>,
+        ) -> Result<tonic::Response<tonic::codec::Streaming<#response>>, tonic::Status> {
            self.ready().await?;
            let codec = tonic::codec::ProstCodec::new();
            let path = http::uri::PathAndQuery::from_static(#path);
-           self.inner.server_streaming(request, path, codec).await
+           self.inner.server_streaming(request.into_request(), path, codec).await
         }
     }
 }
@@ -131,14 +135,14 @@ fn generate_client_streaming(method: &Method, proto: &str, path: String) -> Toke
     let (request, response) = crate::replace_wellknown(proto, &method);
 
     quote! {
-        pub async fn #ident<S>(&mut self, request: tonic::Request<S>)
-            -> Result<tonic::Response<#response>, tonic::Status>
-            where S: Stream<Item = #request> + Send + 'static,
-        {
+        pub async fn #ident(
+            &mut self,
+            request: impl tonic::IntoStreamingRequest<Message = #request>
+        ) -> Result<tonic::Response<#response>, tonic::Status> {
            self.ready().await?;
            let codec = tonic::codec::ProstCodec::new();
            let path = http::uri::PathAndQuery::from_static(#path);
-           self.inner.client_streaming(request, path, codec).await
+           self.inner.client_streaming(request.into_streaming_request(), path, codec).await
         }
     }
 }
@@ -149,14 +153,14 @@ fn generate_streaming(method: &Method, proto: &str, path: String) -> TokenStream
     let (request, response) = crate::replace_wellknown(proto, &method);
 
     quote! {
-        pub async fn #ident<S>(&mut self, request: tonic::Request<S>)
-            -> Result<tonic::Response<tonic::codec::Streaming<#response>>, tonic::Status>
-            where S: Stream<Item = #request> + Send + 'static,
-        {
+        pub async fn #ident(
+            &mut self,
+            request: impl tonic::IntoStreamingRequest<Message = #request>
+        ) -> Result<tonic::Response<tonic::codec::Streaming<#response>>, tonic::Status> {
            self.ready().await?;
            let codec = tonic::codec::ProstCodec::new();
            let path = http::uri::PathAndQuery::from_static(#path);
-           self.inner.streaming(request, path, codec).await
+           self.inner.streaming(request.into_streaming_request(), path, codec).await
         }
     }
 }

tonic-build/src/lib.rs

@@ -64,6 +64,7 @@ use quote::{ToTokens, TokenStreamExt};
 #[cfg(feature = "rustfmt")]
 use std::process::Command;
 use std::{
+    collections::HashSet,
     io,
     path::{Path, PathBuf},
 };
@@ -219,6 +220,8 @@ struct ServiceGenerator {
     builder: Builder,
     clients: TokenStream,
     servers: TokenStream,
+    seen_input_types: HashSet<String>,
+    into_request_impls: TokenStream,
 }
 
 impl ServiceGenerator {
@@ -227,6 +230,8 @@ impl ServiceGenerator {
             builder,
             clients: TokenStream::default(),
             servers: TokenStream::default(),
+            seen_input_types: HashSet::new(),
+            into_request_impls: TokenStream::default(),
         }
     }
 }
@@ -243,14 +248,19 @@ impl prost_build::ServiceGenerator for ServiceGenerator {
         if self.builder.build_client {
             let client = client::generate(&service, path);
             self.clients.extend(client);
+
+            let tokens = generate_into_request_impls(&service, &mut self.seen_input_types);
+            self.into_request_impls.extend(tokens);
         }
     }
 
     fn finalize(&mut self, buf: &mut String) {
         if self.builder.build_client && !self.clients.is_empty() {
             let clients = &self.clients;
+            let trait_impls = &self.into_request_impls;
 
             let client_service = quote::quote! {
+                #trait_impls
                 /// Generated client implementations.
                 pub mod client {
                     #![allow(unused_variables, dead_code, missing_docs)]
@@ -329,3 +339,42 @@ fn replace_wellknown(proto_path: &str, method: &Method) -> (TokenStream, TokenSt
 
     (request, response)
 }
+
+fn generate_into_request_impls(
+    service: &prost_build::Service,
+    seen_input_types: &mut HashSet<String>,
+) -> TokenStream {
+    let service_input_types = service
+        .methods
+        .iter()
+        .fold(HashSet::new(), |mut set, method| {
+            set.insert(method.input_type.clone());
+            set
+        });
+
+    let token_stream = service_input_types.difference(seen_input_types).fold(
+        TokenStream::new(),
+        |mut stream, input| {
+            let request: syn::Type = syn::parse_str(&input).unwrap();
+
+            let trait_impl = quote::quote! {
+                impl tonic::IntoRequest for #request {
+                    type Message = Self;
+
+                    fn into_request(self) -> tonic::Request<Self> {
+                        tonic::Request::new(self)
+                    }
+                }
+            };
+
+            stream.extend(trait_impl);
+            stream
+        },
+    );
+
+    for input in service_input_types {
+        seen_input_types.insert(input.to_owned());
+    }
+
+    token_stream
+}

tonic-examples/src/helloworld/client.rs

@@ -8,9 +8,9 @@ use hello_world::{client::GreeterClient, HelloRequest};
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut client = GreeterClient::connect("http://[::1]:50051")?;
 
-    let request = tonic::Request::new(HelloRequest {
+    let request = HelloRequest {
         name: "hello".into(),
-    });
+    };
 
     let response = client.say_hello(request).await?;
 

tonic-examples/src/routeguide/client.rs

@@ -2,7 +2,6 @@ use futures::TryStreamExt;
 use route_guide::{Point, RouteNote};
 use std::time::{Duration, Instant};
 use tokio::timer::Interval;
-use tonic::Request;
 
 pub mod route_guide {
     tonic::include_proto!("routeguide");
@@ -17,10 +16,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let start = Instant::now();
 
     let response = client
-        .get_feature(Request::new(Point {
+        .get_feature(Point {
             latitude: 409146138,
             longitude: -746188906,
-        }))
+        })
         .await?;
 
     println!("FEATURE = {:?}", response);
@@ -42,9 +41,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
-    let request = Request::new(outbound);
-
-    let response = client.route_chat(request).await?;
+    let response = client.route_chat(outbound).await?;
 
     let mut inbound = response.into_inner();
 

tonic/src/lib.rs

@@ -98,7 +98,7 @@ pub use async_trait::async_trait;
 
 #[doc(inline)]
 pub use codec::Streaming;
-pub use request::Request;
+pub use request::{IntoRequest, IntoStreamingRequest, Request};
 pub use response::Response;
 pub use status::{Code, Status};
 

tonic/src/request.rs

@@ -1,4 +1,5 @@
 use crate::metadata::MetadataMap;
+use futures_core::Stream;
 
 /// A gRPC request and metadata from an RPC call.
 #[derive(Debug)]
@@ -7,6 +8,21 @@ pub struct Request<T> {
     message: T,
 }
 
+/// A trait that is implemented for all RPC request request types.
+pub trait IntoRequest {
+    type Message;
+
+    fn into_request(self) -> Request<Self::Message>;
+}
+
+#[doc(hidden)]
+pub trait IntoStreamingRequest {
+    type Stream: Stream<Item = Self::Message> + Send + 'static;
+    type Message;
+
+    fn into_streaming_request(self) -> Request<Self::Stream>;
+}
+
 impl<T> Request<T> {
     /// Create a new gRPC request.
     ///
@@ -88,3 +104,35 @@ impl<T> Request<T> {
         }
     }
 }
+
+impl<T> IntoRequest for Request<T> {
+    type Message = T;
+
+    fn into_request(self) -> Request<T> {
+        self
+    }
+}
+
+impl<T> IntoStreamingRequest for Request<T>
+where
+    T: Stream + Send + 'static,
+{
+    type Stream = T;
+    type Message = T::Item;
+
+    fn into_streaming_request(self) -> Self {
+        self
+    }
+}
+
+impl<T> IntoStreamingRequest for T
+where
+    T: Stream + Send + 'static,
+{
+    type Stream = T;
+    type Message = T::Item;
+
+    fn into_streaming_request(self) -> Request<Self> {
+        Request::new(self)
+    }
+}