Why is compiler complaining about 'static if I pass only owned values

[ivan770]

Hi everyone!

I have an issue similar to 39620, though I don't have any generic types, and only use two owned fields.

pub struct CloudSpeechRecognizer {
    channel: Receiver<StreamingRecognizeRequest>,
    key: String,
}

impl CloudSpeechRecognizer {
    pub fn new(channel: Receiver<StreamingRecognizeRequest>, key: String) -> Self {
        Self { channel, key }
    }

    pub async fn dispatch(self) -> Result<(), CloudSpeechError> {
        let channel = Channel::from_static(ENDPOINT).connect().await?;

        let oauth_key = MetadataValue::from_str(&self.key)?;

        let mut speech = SpeechClient::with_interceptor(channel, move |mut req: Request<()>| {
            req.metadata_mut()
                .insert("Authorization", oauth_key.clone());

            Ok(req)
        });

        let mut stream = speech
            .streaming_recognize(self.channel.into_stream())
            .await?;

        let m = stream.into_inner().message().await?;

        Ok(())
    }
}

Caller looks like this:

let (sender, receiver) = flume::unbounded();

tokio::spawn(CloudSpeechRecognizer::new(receiver, String::from("test")));

I'm really not sure why is this happening, as into_stream returns RecvStream<'static, _>, thus it should be valid for 'static

[ivan770]

I kinda fixed it by passing R: Stream<Item = StreamingRecognizeRequest> + 'static + Send + Sync instead of Receiver, though I still don't know the cause of problem

[alice]

Please include the use statements so I know which Receiver it is.

[ivan770]

Oh, sorry.
Here's a bit more detailed info:
Receiver - flume::Receiver - Rust
streaming_recognize (auto-generated):

        pub async fn streaming_recognize(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::StreamingRecognizeRequest>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::StreamingRecognizeResponse>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.speech.v1.Speech/StreamingRecognize",
            );
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }

Though the most interesting part of this function is IntoStreamingRequest