feat(swarm): remove deprecated items

Related: https://github.com/libp2p/rust-libp2p/issues/3647.

Pull-Request: #3956.

libp2p/src/tutorials/ping.rs

@@ -180,7 +180,7 @@
 //! [`Transport`] to the [`NetworkBehaviour`].
 //!
 //! ```rust
-//! use libp2p::swarm::{keep_alive, NetworkBehaviour, Swarm};
+//! use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmBuilder};
 //! use libp2p::{identity, ping, PeerId};
 //! use std::error::Error;
 //!
@@ -194,7 +194,7 @@
 //!
 //!     let behaviour = Behaviour::default();
 //!
-//!     let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+//!     let mut swarm = SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
 //!
 //!     Ok(())
 //! }
@@ -237,7 +237,7 @@
 //! remote peer.
 //!
 //! ```rust
-//! use libp2p::swarm::{keep_alive, NetworkBehaviour, Swarm};
+//! use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmBuilder};
 //! use libp2p::{identity, ping, Multiaddr, PeerId};
 //! use std::error::Error;
 //!
@@ -251,7 +251,7 @@
 //!
 //!     let behaviour = Behaviour::default();
 //!
-//!     let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+//!     let mut swarm = SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
 //!
 //!     // Tell the swarm to listen on all interfaces and a random, OS-assigned
 //!     // port.
@@ -287,7 +287,7 @@
 //!
 //! ```no_run
 //! use futures::prelude::*;
-//! use libp2p::swarm::{keep_alive, NetworkBehaviour, Swarm, SwarmEvent};
+//! use libp2p::swarm::{keep_alive, NetworkBehaviour, SwarmEvent, SwarmBuilder};
 //! use libp2p::{identity, ping, Multiaddr, PeerId};
 //! use std::error::Error;
 //!
@@ -301,7 +301,7 @@
 //!
 //!     let behaviour = Behaviour::default();
 //!
-//!     let mut swarm = Swarm::with_async_std_executor(transport, behaviour, local_peer_id);
+//!     let mut swarm = SwarmBuilder::with_async_std_executor(transport, behaviour, local_peer_id).build();
 //!
 //!     // Tell the swarm to listen on all interfaces and a random, OS-assigned
 //!     // port.

swarm/CHANGELOG.md

@@ -56,6 +56,8 @@
 
 - Rename `ConnectionHandlerEvent::Custom` to `ConnectionHandlerEvent::NotifyBehaviour`. See [PR 3955].
 
+- Remove deprecated items. See [PR 3956].
+
 [PR 3605]: https://github.com/libp2p/rust-libp2p/pull/3605
 [PR 3651]: https://github.com/libp2p/rust-libp2p/pull/3651
 [PR 3715]: https://github.com/libp2p/rust-libp2p/pull/3715
@@ -70,6 +72,7 @@
 [PR 3919]: https://github.com/libp2p/rust-libp2p/pull/3919
 [PR 3927]: https://github.com/libp2p/rust-libp2p/pull/3927
 [PR 3955]: https://github.com/libp2p/rust-libp2p/pull/3955
+[PR 3956]: https://github.com/libp2p/rust-libp2p/pull/3956
 
 ## 0.42.2
 

swarm/src/behaviour.rs

@@ -219,8 +219,6 @@ pub trait NetworkBehaviour: 'static {
 pub trait PollParameters {
     /// Iterator returned by [`supported_protocols`](PollParameters::supported_protocols).
     type SupportedProtocolsIter: ExactSizeIterator<Item = Vec<u8>>;
-    /// Iterator returned by [`listened_addresses`](PollParameters::listened_addresses).
-    type ListenedAddressesIter: ExactSizeIterator<Item = Multiaddr>;
 
     /// Returns the list of protocol the behaviour supports when a remote negotiates a protocol on
     /// an inbound substream.
@@ -232,20 +230,6 @@ pub trait PollParameters {
         note = "Use `libp2p_swarm::SupportedProtocols` in your `ConnectionHandler` instead."
     )]
     fn supported_protocols(&self) -> Self::SupportedProtocolsIter;
-
-    /// Returns the list of the addresses we're listening on.
-    #[deprecated(
-        since = "0.42.0",
-        note = "Use `libp2p_swarm::ListenAddresses` instead."
-    )]
-    fn listened_addresses(&self) -> Self::ListenedAddressesIter;
-
-    /// Returns the peer id of the local node.
-    #[deprecated(
-        since = "0.42.0",
-        note = "Pass the node's `PeerId` into the behaviour instead."
-    )]
-    fn local_peer_id(&self) -> &PeerId;
 }
 
 /// A command issued from a [`NetworkBehaviour`] for the [`Swarm`].
@@ -413,7 +397,6 @@ pub enum CloseConnection {
 
 /// Enumeration with the list of the possible events
 /// to pass to [`on_swarm_event`](NetworkBehaviour::on_swarm_event).
-#[allow(deprecated)]
 pub enum FromSwarm<'a, Handler> {
     /// Informs the behaviour about a newly established connection to a peer.
     ConnectionEstablished(ConnectionEstablished<'a>),
@@ -470,7 +453,6 @@ pub struct ConnectionEstablished<'a> {
 /// This event is always paired with an earlier
 /// [`FromSwarm::ConnectionEstablished`] with the same peer ID, connection ID
 /// and endpoint.
-#[allow(deprecated)]
 pub struct ConnectionClosed<'a, Handler> {
     pub peer_id: PeerId,
     pub connection_id: ConnectionId,

swarm/src/connection.rs

@@ -66,15 +66,6 @@ static NEXT_CONNECTION_ID: AtomicUsize = AtomicUsize::new(1);
 pub struct ConnectionId(usize);
 
 impl ConnectionId {
-    /// A "dummy" [`ConnectionId`].
-    ///
-    /// Really, you should not use this, not even for testing but it is here if you need it.
-    #[deprecated(
-        since = "0.42.0",
-        note = "Don't use this, it will be removed at a later stage again."
-    )]
-    pub const DUMMY: ConnectionId = ConnectionId(0);
-
     /// Creates an _unchecked_ [`ConnectionId`].
     ///
     /// [`Swarm`](crate::Swarm) enforces that [`ConnectionId`]s are unique and not reused.

swarm/src/connection/pool.rs

@@ -406,7 +406,6 @@ where
 
     /// Adds a pending outgoing connection to the pool in the form of a `Future`
     /// that establishes and negotiates the connection.
-    #[allow(deprecated)]
     pub(crate) fn add_outgoing(
         &mut self,
         dials: Vec<
@@ -486,7 +485,6 @@ where
         );
     }
 
-    #[allow(deprecated)]
     pub(crate) fn spawn_connection(
         &mut self,
         id: ConnectionId,

swarm/src/lib.rs

@@ -132,7 +132,7 @@ use connection::{
     PendingConnectionError, PendingInboundConnectionError, PendingOutboundConnectionError,
 };
 use dial_opts::{DialOpts, PeerCondition};
-use futures::{executor::ThreadPoolBuilder, prelude::*, stream::FusedStream};
+use futures::{prelude::*, stream::FusedStream};
 use libp2p_core::{
     connection::ConnectedPoint,
     multiaddr,
@@ -164,7 +164,6 @@ type TBehaviourOutEvent<TBehaviour> = <TBehaviour as NetworkBehaviour>::ToSwarm;
 
 /// [`ConnectionHandler`] of the [`NetworkBehaviour`] for all the protocols the [`NetworkBehaviour`]
 /// supports.
-#[allow(deprecated)]
 pub type THandler<TBehaviour> = <TBehaviour as NetworkBehaviour>::ConnectionHandler;
 
 /// Custom event that can be received by the [`ConnectionHandler`] of the
@@ -352,121 +351,10 @@ where
 
 impl<TBehaviour> Unpin for Swarm<TBehaviour> where TBehaviour: NetworkBehaviour {}
 
-#[allow(deprecated)]
 impl<TBehaviour> Swarm<TBehaviour>
 where
     TBehaviour: NetworkBehaviour,
 {
-    /// Builds a new `Swarm` with a provided executor.
-    #[deprecated(note = "Use `SwarmBuilder::with_executor` instead.")]
-    pub fn with_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-        executor: impl Executor + Send + 'static,
-    ) -> Self {
-        SwarmBuilder::with_executor(transport, behaviour, local_peer_id, executor).build()
-    }
-
-    /// Builds a new `Swarm` with a tokio executor.
-    #[cfg(all(
-        feature = "tokio",
-        not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown"))
-    ))]
-    #[deprecated(note = "Use `SwarmBuilder::with_tokio_executor` instead.")]
-    pub fn with_tokio_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-    ) -> Self {
-        Self::with_executor(
-            transport,
-            behaviour,
-            local_peer_id,
-            crate::executor::TokioExecutor,
-        )
-    }
-
-    /// Builds a new `Swarm` with an async-std executor.
-    #[cfg(all(
-        feature = "async-std",
-        not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown"))
-    ))]
-    #[deprecated(note = "Use `SwarmBuilder::with_async_std_executor` instead.")]
-    pub fn with_async_std_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-    ) -> Self {
-        Self::with_executor(
-            transport,
-            behaviour,
-            local_peer_id,
-            crate::executor::AsyncStdExecutor,
-        )
-    }
-
-    /// Builds a new `Swarm` with a threadpool executor.
-    #[deprecated(
-        note = "The `futures::executor::ThreadPool` executor is deprecated. See https://github.com/libp2p/rust-libp2p/issues/3107."
-    )]
-    pub fn with_threadpool_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-    ) -> Self {
-        let builder = match ThreadPoolBuilder::new()
-            .name_prefix("libp2p-swarm-task-")
-            .create()
-        {
-            Ok(tp) => SwarmBuilder::with_executor(transport, behaviour, local_peer_id, tp),
-            Err(err) => {
-                log::warn!("Failed to create executor thread pool: {:?}", err);
-                SwarmBuilder::without_executor(transport, behaviour, local_peer_id)
-            }
-        };
-        builder.build()
-    }
-
-    /// Builds a new `Swarm` with a wasm executor.
-    /// Background tasks will be executed by the browser on the next micro-tick.
-    ///
-    /// Spawning a task is similar too:
-    /// ```typescript
-    /// function spawn(task: () => Promise<void>) {
-    ///     task()
-    /// }
-    /// ```
-    #[cfg(feature = "wasm-bindgen")]
-    #[deprecated(note = "Use `SwarmBuilder::with_wasm_executor` instead.")]
-    pub fn with_wasm_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-    ) -> Self {
-        Self::with_executor(
-            transport,
-            behaviour,
-            local_peer_id,
-            crate::executor::WasmBindgenExecutor,
-        )
-    }
-
-    /// Builds a new `Swarm` without an executor, instead using the current task.
-    ///
-    /// ## ⚠️  Performance warning
-    /// All connections will be polled on the current task, thus quite bad performance
-    /// characteristics should be expected. Whenever possible use an executor and
-    /// [`Swarm::with_executor`].
-    #[deprecated(note = "Use `SwarmBuilder::without_executor` instead.")]
-    pub fn without_executor(
-        transport: transport::Boxed<(PeerId, StreamMuxerBox)>,
-        behaviour: TBehaviour,
-        local_peer_id: PeerId,
-    ) -> Self {
-        SwarmBuilder::without_executor(transport, behaviour, local_peer_id).build()
-    }
-
     /// Returns information about the connections underlying the [`Swarm`].
     pub fn network_info(&self) -> NetworkInfo {
         let num_peers = self.pool.num_peers();
@@ -1250,9 +1138,7 @@ where
                 None => {
                     let behaviour_poll = {
                         let mut parameters = SwarmPollParameters {
-                            local_peer_id: &this.local_peer_id,
                             supported_protocols: &this.supported_protocols,
-                            listened_addrs: this.listened_addrs.values().flatten().collect(),
                         };
                         this.behaviour.poll(cx, &mut parameters)
                     };
@@ -1417,26 +1303,15 @@ where
 /// Parameters passed to `poll()`, that the `NetworkBehaviour` has access to.
 // TODO: #[derive(Debug)]
 pub struct SwarmPollParameters<'a> {
-    local_peer_id: &'a PeerId,
     supported_protocols: &'a [Vec<u8>],
-    listened_addrs: Vec<&'a Multiaddr>,
 }
 
 impl<'a> PollParameters for SwarmPollParameters<'a> {
     type SupportedProtocolsIter = std::iter::Cloned<std::slice::Iter<'a, std::vec::Vec<u8>>>;
-    type ListenedAddressesIter = std::iter::Cloned<std::vec::IntoIter<&'a Multiaddr>>;
 
     fn supported_protocols(&self) -> Self::SupportedProtocolsIter {
         self.supported_protocols.iter().cloned()
     }
-
-    fn listened_addresses(&self) -> Self::ListenedAddressesIter {
-        self.listened_addrs.clone().into_iter().cloned()
-    }
-
-    fn local_peer_id(&self) -> &PeerId {
-        self.local_peer_id
-    }
 }
 
 /// A [`SwarmBuilder`] provides an API for configuring and constructing a [`Swarm`].