feat(swarm): deprecate NegotiatedSubstream in favor of Stream

This patch tackles two things at once that are fairly intertwined:

1. There is no such thing as a "substream" in libp2p, the spec and other implementations only talk about "streams". We fix this by deprecating `NegotiatedSubstream`.
2. Previously, `NegotiatedSubstream` was a type alias that pointed to a type from `multistream-select`, effectively leaking the version of `multistream-select` to all dependencies of `libp2p-swarm`. We fix this by introducing a `Stream` newtype.

Resolves: #3759.
Related: #3748.

Pull-Request: #3912.

protocols/rendezvous/src/handler/inbound.rs

@@ -26,7 +26,7 @@ use crate::handler::PROTOCOL_IDENT;
 use crate::substream_handler::{Next, PassthroughProtocol, SubstreamHandler};
 use asynchronous_codec::Framed;
 use futures::{SinkExt, StreamExt};
-use libp2p_swarm::{NegotiatedSubstream, SubstreamProtocol};
+use libp2p_swarm::SubstreamProtocol;
 use std::fmt;
 use std::task::{Context, Poll};
 
@@ -35,13 +35,13 @@ use std::task::{Context, Poll};
 #[allow(clippy::enum_variant_names)]
 pub enum Stream {
     /// We are in the process of reading a message from the substream.
-    PendingRead(Framed<NegotiatedSubstream, RendezvousCodec>),
+    PendingRead(Framed<libp2p_swarm::Stream, RendezvousCodec>),
     /// We read a message, dispatched it to the behaviour and are waiting for the response.
-    PendingBehaviour(Framed<NegotiatedSubstream, RendezvousCodec>),
+    PendingBehaviour(Framed<libp2p_swarm::Stream, RendezvousCodec>),
     /// We are in the process of sending a response.
-    PendingSend(Framed<NegotiatedSubstream, RendezvousCodec>, Message),
+    PendingSend(Framed<libp2p_swarm::Stream, RendezvousCodec>, Message),
     /// We've sent the message and are now closing down the substream.
-    PendingClose(Framed<NegotiatedSubstream, RendezvousCodec>),
+    PendingClose(Framed<libp2p_swarm::Stream, RendezvousCodec>),
 }
 
 impl fmt::Debug for Stream {
@@ -93,7 +93,7 @@ impl SubstreamHandler for Stream {
         SubstreamProtocol::new(PassthroughProtocol::new(PROTOCOL_IDENT), open_info)
     }
 
-    fn new(substream: NegotiatedSubstream, _: Self::OpenInfo) -> Self {
+    fn new(substream: libp2p_swarm::Stream, _: Self::OpenInfo) -> Self {
         Stream::PendingRead(Framed::new(substream, RendezvousCodec::default()))
     }
 

protocols/rendezvous/src/handler/outbound.rs

@@ -25,7 +25,7 @@ use crate::substream_handler::{FutureSubstream, Next, PassthroughProtocol, Subst
 use crate::{ErrorCode, Namespace, Registration, Ttl};
 use asynchronous_codec::Framed;
 use futures::{SinkExt, TryFutureExt, TryStreamExt};
-use libp2p_swarm::{NegotiatedSubstream, SubstreamProtocol};
+use libp2p_swarm::SubstreamProtocol;
 use std::task::Context;
 use void::Void;
 
@@ -43,7 +43,7 @@ impl SubstreamHandler for Stream {
         SubstreamProtocol::new(PassthroughProtocol::new(PROTOCOL_IDENT), open_info)
     }
 
-    fn new(substream: NegotiatedSubstream, info: Self::OpenInfo) -> Self {
+    fn new(substream: libp2p_swarm::Stream, info: Self::OpenInfo) -> Self {
         let mut stream = Framed::new(substream, RendezvousCodec::default());
         let sent_message = match info {
             OpenInfo::RegisterRequest(new_registration) => Message::Register(new_registration),

protocols/rendezvous/src/substream_handler.rs

@@ -31,8 +31,7 @@ use instant::Instant;
 use libp2p_core::{InboundUpgrade, OutboundUpgrade, UpgradeInfo};
 use libp2p_swarm::handler::{ConnectionEvent, FullyNegotiatedInbound, FullyNegotiatedOutbound};
 use libp2p_swarm::{
-    ConnectionHandler, ConnectionHandlerEvent, KeepAlive, NegotiatedSubstream, StreamProtocol,
-    SubstreamProtocol,
+    ConnectionHandler, ConnectionHandlerEvent, KeepAlive, Stream, StreamProtocol, SubstreamProtocol,
 };
 use std::collections::{HashMap, VecDeque};
 use std::fmt;
@@ -51,7 +50,7 @@ pub trait SubstreamHandler: Sized {
 
     fn upgrade(open_info: Self::OpenInfo)
         -> SubstreamProtocol<PassthroughProtocol, Self::OpenInfo>;
-    fn new(substream: NegotiatedSubstream, info: Self::OpenInfo) -> Self;
+    fn new(substream: Stream, info: Self::OpenInfo) -> Self;
     fn on_event(self, event: Self::InEvent) -> Self;
     fn advance(self, cx: &mut Context<'_>) -> Result<Next<Self, Self::OutEvent>, Self::Error>;
 }
@@ -541,7 +540,7 @@ impl SubstreamHandler for void::Void {
     type Error = void::Void;
     type OpenInfo = ();
 
-    fn new(_: NegotiatedSubstream, _: Self::OpenInfo) -> Self {
+    fn new(_: Stream, _: Self::OpenInfo) -> Self {
         unreachable!("we should never yield a substream")
     }