refactor: enable unnecessary_self_imports clippy lint (#1005)

Author: RRRadicalEdward

Cargo.toml

@@ -142,6 +142,7 @@ range_plus_one = "warn"
 # TODO: self_named_module_files = "warn"
 # TODO: partial_pub_fields = "warn" (should we enable only in pdu crates?)
 redundant_type_annotations = "warn"
+unnecessary_self_imports = "warn"
 try_err = "warn"
 rest_pat_in_fully_bound_structs = "warn"
 

crates/ironrdp-acceptor/src/channel_connection.rs

@@ -4,9 +4,8 @@ use ironrdp_connector::{
     reason_err, ConnectorError, ConnectorErrorExt as _, ConnectorResult, Sequence, State, Written,
 };
 use ironrdp_core::WriteBuf;
+use ironrdp_pdu::mcs;
 use ironrdp_pdu::x224::X224;
-use ironrdp_pdu::{self as pdu};
-use pdu::mcs;
 use tracing::debug;
 
 #[derive(Debug)]
@@ -57,13 +56,13 @@ impl State for ChannelConnectionState {
 }
 
 impl Sequence for ChannelConnectionSequence {
-    fn next_pdu_hint(&self) -> Option<&dyn pdu::PduHint> {
+    fn next_pdu_hint(&self) -> Option<&dyn ironrdp_pdu::PduHint> {
         match &self.state {
             ChannelConnectionState::Consumed => None,
-            ChannelConnectionState::WaitErectDomainRequest => Some(&pdu::X224_HINT),
-            ChannelConnectionState::WaitAttachUserRequest => Some(&pdu::X224_HINT),
+            ChannelConnectionState::WaitErectDomainRequest => Some(&ironrdp_pdu::X224_HINT),
+            ChannelConnectionState::WaitAttachUserRequest => Some(&ironrdp_pdu::X224_HINT),
             ChannelConnectionState::SendAttachUserConfirm => None,
-            ChannelConnectionState::WaitChannelJoinRequest { .. } => Some(&pdu::X224_HINT),
+            ChannelConnectionState::WaitChannelJoinRequest { .. } => Some(&ironrdp_pdu::X224_HINT),
             ChannelConnectionState::SendChannelJoinConfirm { .. } => None,
             ChannelConnectionState::AllJoined => None,
         }

crates/ironrdp-acceptor/src/finalization.rs

@@ -1,8 +1,7 @@
 use ironrdp_connector::{ConnectorError, ConnectorErrorExt as _, ConnectorResult, Sequence, State, Written};
 use ironrdp_core::WriteBuf;
+use ironrdp_pdu::rdp;
 use ironrdp_pdu::x224::X224;
-use ironrdp_pdu::{self as pdu};
-use pdu::rdp;
 use tracing::debug;
 
 use crate::util::{self, wrap_share_data};
@@ -60,13 +59,13 @@ impl State for FinalizationState {
 }
 
 impl Sequence for FinalizationSequence {
-    fn next_pdu_hint(&self) -> Option<&dyn pdu::PduHint> {
+    fn next_pdu_hint(&self) -> Option<&dyn ironrdp_pdu::PduHint> {
         match &self.state {
             FinalizationState::Consumed => None,
-            FinalizationState::WaitSynchronize => Some(&pdu::X224Hint),
-            FinalizationState::WaitControlCooperate => Some(&pdu::X224Hint),
-            FinalizationState::WaitRequestControl => Some(&pdu::X224Hint),
-            FinalizationState::WaitFontList => Some(&pdu::RdpHint),
+            FinalizationState::WaitSynchronize => Some(&ironrdp_pdu::X224Hint),
+            FinalizationState::WaitControlCooperate => Some(&ironrdp_pdu::X224Hint),
+            FinalizationState::WaitRequestControl => Some(&ironrdp_pdu::X224Hint),
+            FinalizationState::WaitFontList => Some(&ironrdp_pdu::RdpHint),
             FinalizationState::SendSynchronizeConfirm => None,
             FinalizationState::SendControlCooperateConfirm => None,
             FinalizationState::SendGrantedControlConfirm => None,
@@ -221,7 +220,7 @@ fn create_font_map() -> rdp::headers::ShareDataPdu {
 }
 
 fn decode_share_control(input: &[u8]) -> ConnectorResult<rdp::headers::ShareControlHeader> {
-    let data_request = ironrdp_core::decode::<X224<pdu::mcs::SendDataRequest<'_>>>(input)
+    let data_request = ironrdp_core::decode::<X224<ironrdp_pdu::mcs::SendDataRequest<'_>>>(input)
         .map_err(ConnectorError::decode)
         .map(|p| p.0)?;
     let share_control = ironrdp_core::decode::<rdp::headers::ShareControlHeader>(data_request.user_data.as_ref())
@@ -230,7 +229,7 @@ fn decode_share_control(input: &[u8]) -> ConnectorResult<rdp::headers::ShareCont
 }
 
 fn decode_font_list(input: &[u8]) -> Result<rdp::finalization_messages::FontPdu, ()> {
-    use pdu::rdp::headers::{ShareControlPdu, ShareDataPdu};
+    use ironrdp_pdu::rdp::headers::{ShareControlPdu, ShareDataPdu};
 
     let share_control = decode_share_control(input).map_err(|_| ())?;
 

crates/ironrdp-connector/src/connection_activation.rs

@@ -1,7 +1,7 @@
 use core::mem;
 
+use ironrdp_pdu::rdp;
 use ironrdp_pdu::rdp::capability_sets::CapabilitySet;
-use ironrdp_pdu::rdp::{self};
 use tracing::{debug, warn};
 
 use crate::{

crates/ironrdp-server/src/helper.rs

@@ -7,8 +7,7 @@ use anyhow::Context as _;
 use rustls_pemfile::{certs, pkcs8_private_keys};
 use tokio_rustls::rustls::pki_types::pem::PemObject as _;
 use tokio_rustls::rustls::pki_types::{CertificateDer, PrivateKeyDer};
-use tokio_rustls::rustls::{self};
-use tokio_rustls::TlsAcceptor;
+use tokio_rustls::{rustls, TlsAcceptor};
 
 pub struct TlsIdentityCtx {
     pub certs: Vec<CertificateDer<'static>>,

crates/ironrdp-tls/src/rustls.rs

@@ -1,8 +1,8 @@
 use std::io;
 
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt as _};
+use tokio_rustls::rustls;
 use tokio_rustls::rustls::pki_types::ServerName;
-use tokio_rustls::rustls::{self};
 
 pub type TlsStream<S> = tokio_rustls::client::TlsStream<S>;