Auto-fixed clippy::pedantic lints

axelkar · axelkar · commit 7204f13f8273 · 2025-07-23T14:51:52.000+03:00
Notes:
- Exact command done: `cargo clippy --fix --features calloop,tokio -- -W clippy::pedantic`
- Undid fixes for auto-generated files, for now
- Ran `cargo fmt`
diff --git a/examples/list-devices.rs b/examples/list-devices.rs
@@ -104,13 +104,12 @@ impl State {
                     _ => {}
                 }
             }
-            ei::Event::Callback(callback, request) => match request {
-                ei::callback::Event::Done { callback_data: _ } => {
+            ei::Event::Callback(callback, request) => {
+                if let ei::callback::Event::Done { callback_data: _ } = request {
                     // TODO: Callback being called after first device, but not later ones?
                     // self.print_and_exit_if_done();
                 }
-                _ => {}
-            },
+            }
             _ => {}
         }
 
diff --git a/examples/receive-synchronous.rs b/examples/receive-synchronous.rs
@@ -78,11 +78,11 @@ fn main() {
                 println!("  seat: {:?}", evt.device.seat().name());
                 println!("  type: {:?}", evt.device.device_type());
                 if let Some(dimensions) = evt.device.dimensions() {
-                    println!("  dimensions: {:?}", dimensions);
+                    println!("  dimensions: {dimensions:?}");
                 }
                 println!("  regions: {:?}", evt.device.regions());
                 if let Some(keymap) = evt.device.keymap() {
-                    println!("  keymap: {:?}", keymap);
+                    println!("  keymap: {keymap:?}");
                 }
                 // Interfaces?
             }
diff --git a/examples/receive.rs b/examples/receive.rs
@@ -79,11 +79,11 @@ async fn main() {
                 println!("  seat: {:?}", evt.device.seat().name());
                 println!("  type: {:?}", evt.device.device_type());
                 if let Some(dimensions) = evt.device.dimensions() {
-                    println!("  dimensions: {:?}", dimensions);
+                    println!("  dimensions: {dimensions:?}");
                 }
                 println!("  regions: {:?}", evt.device.regions());
                 if let Some(keymap) = evt.device.keymap() {
-                    println!("  keymap: {:?}", keymap);
+                    println!("  keymap: {keymap:?}");
                 }
                 // Interfaces?
             }
diff --git a/examples/reis-demo-server.rs b/examples/reis-demo-server.rs
@@ -112,7 +112,7 @@ struct State {
 
 impl State {
     fn handle_new_connection(&mut self, context: eis::Context) -> io::Result<calloop::PostAction> {
-        println!("New connection: {:?}", context);
+        println!("New connection: {context:?}");
 
         let source = EisRequestSource::new(context, 1);
         let mut context_state = ContextState { seat: None };
diff --git a/examples/type-text.rs b/examples/type-text.rs
@@ -54,7 +54,7 @@ impl State {
         &mut self,
         context: &mut ei::Context,
     ) -> io::Result<calloop::PostAction> {
-        if let Err(_) = context.read() {
+        if context.read().is_err() {
             return Ok(calloop::PostAction::Remove);
         }
 
@@ -193,31 +193,29 @@ impl State {
                     }
                 }
                 ei::Event::Keyboard(keyboard, request) => {
-                    match request {
-                        ei::keyboard::Event::Keymap {
-                            keymap_type,
-                            size,
-                            keymap,
-                        } => {
-                            // XXX format
-                            // flags?
-                            // handle multiple keyboard?
-                            let context = xkb::Context::new(0);
-                            self.keymap = Some(
-                                unsafe {
-                                    xkb::Keymap::new_from_fd(
-                                        &context,
-                                        keymap,
-                                        size as _,
-                                        xkb::KEYMAP_FORMAT_TEXT_V1,
-                                        0,
-                                    )
-                                }
-                                .unwrap()
-                                .unwrap(),
-                            );
-                        }
-                        _ => {}
+                    if let ei::keyboard::Event::Keymap {
+                        keymap_type,
+                        size,
+                        keymap,
+                    } = request
+                    {
+                        // XXX format
+                        // flags?
+                        // handle multiple keyboard?
+                        let context = xkb::Context::new(0);
+                        self.keymap = Some(
+                            unsafe {
+                                xkb::Keymap::new_from_fd(
+                                    &context,
+                                    keymap,
+                                    size as _,
+                                    xkb::KEYMAP_FORMAT_TEXT_V1,
+                                    0,
+                                )
+                            }
+                            .unwrap()
+                            .unwrap(),
+                        );
                     }
                 }
                 _ => {}
diff --git a/src/calloop.rs b/src/calloop.rs
@@ -17,6 +17,7 @@ pub struct EisListenerSource {
 }
 
 impl EisListenerSource {
+    #[must_use]
     pub fn new(listener: eis::Listener) -> Self {
         Self {
             source: Generic::new(listener, Interest::READ, Mode::Level),
@@ -166,6 +167,7 @@ pub struct EisRequestSource {
 }
 
 impl EisRequestSource {
+    #[must_use]
     pub fn new(context: eis::Context, initial_serial: u32) -> Self {
         let handshaker = crate::handshake::EisHandshaker::new(&context, initial_serial);
         Self {
diff --git a/src/ei.rs b/src/ei.rs
@@ -98,6 +98,7 @@ impl Context {
     }
 
     /// Returns the interface proxy for the `ei_handshake` object.
+    #[must_use]
     pub fn handshake(&self) -> handshake::Handshake {
         self.0.object_for_id(0).unwrap().downcast_unchecked()
     }
diff --git a/src/eis.rs b/src/eis.rs
@@ -134,6 +134,7 @@ impl Context {
     }
 
     /// Returns the interface proxy for the `ei_handshake` object.
+    #[must_use]
     pub fn handshake(&self) -> handshake::Handshake {
         self.0.object_for_id(0).unwrap().downcast_unchecked()
     }
diff --git a/src/error.rs b/src/error.rs
@@ -22,7 +22,7 @@ impl fmt::Display for Error {
                 write!(f, "invalid version {version} for interface '{interface}'")
             }
             Self::Event(err) => write!(f, "event error: {err}"),
-            Self::Request(err) => write!(f, "request error: {}", err),
+            Self::Request(err) => write!(f, "request error: {err}"),
             Self::Io(err) => write!(f, "IO error: {err}"),
             Self::Handshake(err) => write!(f, "handshake error: {err}"),
             Self::Parse(err) => write!(f, "parse error: {err}"),
diff --git a/src/event.rs b/src/event.rs
@@ -72,6 +72,7 @@ pub struct Connection(Arc<ConnectionInner>);
 
 impl Connection {
     /// Returns the interface proxy for the underlying `ei_connection` object.
+    #[must_use]
     pub fn connection(&self) -> &ei::Connection {
         &self.0.handshake_resp.connection
     }
@@ -88,6 +89,7 @@ impl Connection {
     // TODO(axka, 2025-07-08): specify in the function name that this is the last serial from
     // the server, and not the client, and create a function for the other way around.
     /// Returns the last serial number used in an event by the server.
+    #[must_use]
     pub fn serial(&self) -> u32 {
         self.0.serial.load(Ordering::Relaxed)
     }
@@ -108,6 +110,7 @@ pub struct EiEventConverter {
 }
 
 impl EiEventConverter {
+    #[must_use]
     pub fn new(context: &ei::Context, handshake_resp: HandshakeResp) -> Self {
         Self {
             pending_seats: HashMap::new(),
@@ -126,6 +129,7 @@ impl EiEventConverter {
         }
     }
 
+    #[must_use]
     pub fn connection(&self) -> &Connection {
         &self.connection
     }
@@ -755,6 +759,7 @@ impl std::hash::Hash for Seat {
 
 impl Seat {
     /// Returns the name of the seat, as provided by the server.
+    #[must_use]
     pub fn name(&self) -> Option<&str> {
         self.0.name.as_deref()
     }
@@ -804,48 +809,57 @@ impl fmt::Debug for Device {
 
 impl Device {
     /// Returns the high-level [`Seat`] wrapper for the device.
+    #[must_use]
     pub fn seat(&self) -> &Seat {
         &self.0.seat
     }
 
     /// Returns the interface proxy for the underlying `ei_device` object.
+    #[must_use]
     pub fn device(&self) -> &ei::Device {
         &self.0.device
     }
 
     /// Returns the name of the device, as provided by the server.
+    #[must_use]
     pub fn name(&self) -> Option<&str> {
         self.0.name.as_deref()
     }
 
     /// Returns the device's type.
+    #[must_use]
     pub fn device_type(&self) -> ei::device::DeviceType {
         self.0.device_type.unwrap()
     }
 
     /// Returns the device's dimensions, if applicable.
+    #[must_use]
     pub fn dimensions(&self) -> Option<(u32, u32)> {
         self.0.dimensions
     }
 
     /// Returns the device's regions.
+    #[must_use]
     pub fn regions(&self) -> &[Region] {
         &self.0.regions
     }
 
     /// Returns the device's keymap, if applicable.
+    #[must_use]
     pub fn keymap(&self) -> Option<&Keymap> {
         self.0.keymap.as_ref()
     }
 
     /// Returns an interface proxy if it is implemented for this device.
     ///
     /// Interfaces of devices are implemented, such that there is one `ei_device` object and other objects (for example `ei_keyboard`) denoting capabilities.
+    #[must_use]
     pub fn interface<T: ei::Interface>(&self) -> Option<T> {
         self.0.interfaces.get(T::NAME)?.clone().downcast()
     }
 
     /// Returns `true` if this device has an interface matching the provided capability.
+    #[must_use]
     pub fn has_capability(&self, capability: DeviceCapability) -> bool {
         self.0.interfaces.contains_key(capability.interface_name())
     }
@@ -1270,7 +1284,7 @@ impl Iterator for EiConvertEventIterator {
                 Err(err) if err.kind() == io::ErrorKind::UnexpectedEof => return None,
                 Err(err) => return Some(Err(err.into())),
                 Ok(_) => {}
-            };
+            }
             while let Some(result) = self.context.pending_event() {
                 let request = match result {
                     PendingRequestResult::Request(request) => request,
diff --git a/src/handshake.rs b/src/handshake.rs
@@ -64,6 +64,7 @@ pub struct EiHandshaker<'a> {
 }
 
 impl<'a> EiHandshaker<'a> {
+    #[must_use]
     pub fn new(name: &'a str, context_type: ei::handshake::ContextType) -> Self {
         Self {
             name,
@@ -84,7 +85,7 @@ impl<'a> EiHandshaker<'a> {
                 handshake.handshake_version(1);
                 handshake.name(self.name);
                 handshake.context_type(self.context_type);
-                for (interface, version) in interfaces().iter() {
+                for (interface, version) in interfaces() {
                     handshake.interface_version(interface, *version);
                 }
                 handshake.finish();
@@ -154,6 +155,7 @@ pub struct EisHandshaker {
 }
 
 impl EisHandshaker {
+    #[must_use]
     pub fn new(context: &eis::Context, initial_serial: u32) -> Self {
         let handshake = context.handshake();
         handshake.handshake_version(1);
@@ -193,11 +195,11 @@ impl EisHandshaker {
                 if let Some((interface, server_version)) = interfaces().get_key_value(name.as_str())
                 {
                     self.negotiated_interfaces
-                        .insert(interface.to_string(), version.min(*server_version));
+                        .insert((*interface).to_string(), version.min(*server_version));
                 }
             }
             eis::handshake::Request::Finish => {
-                for (interface, version) in self.negotiated_interfaces.iter() {
+                for (interface, version) in &self.negotiated_interfaces {
                     handshake.interface_version(interface, *version);
                 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -38,6 +38,7 @@ mod private {
 // XXX
 // Want to fallback to higher number if exists, on server?
 // create on server, not client.
+#[must_use]
 pub fn default_socket_path() -> Option<PathBuf> {
     let mut path = PathBuf::from(env::var_os("XDG_RUNTIME_DIR")?);
     path.push("eis-0");
diff --git a/src/object.rs b/src/object.rs
@@ -30,7 +30,7 @@ impl Eq for Object {}
 
 impl hash::Hash for Object {
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
-        self.0.id.hash(hasher)
+        self.0.id.hash(hasher);
     }
 }
 
@@ -52,8 +52,8 @@ impl Object {
     ) -> Self {
         Self(Arc::new(ObjectInner {
             backend,
-            id,
             client_side,
+            id,
             interface,
             version,
         }))
@@ -62,6 +62,7 @@ impl Object {
     /// Returns a handle to the backend.
     ///
     /// Returns `None` if the backend has been destroyed.
+    #[must_use]
     pub fn backend(&self) -> Option<Backend> {
         self.0.backend.upgrade()
     }
@@ -74,6 +75,7 @@ impl Object {
 
     /// Returns `true` if the backend has this object, and `false` otherwise or if the backend
     /// has been destroyed.
+    #[must_use]
     pub fn is_alive(&self) -> bool {
         if let Some(backend) = self.backend() {
             backend.has_object_for_id(self.id())
@@ -84,6 +86,7 @@ impl Object {
 
     /// Returns the object's
     /// [ID](https://libinput.pages.freedesktop.org/libei/doc/types/index.html#object-ids).
+    #[must_use]
     pub fn id(&self) -> u64 {
         self.0.id
     }
@@ -92,11 +95,13 @@ impl Object {
     ///
     /// Interface names for new objects aren't usually transmitted, but rather come from
     /// the protocol definition.
+    #[must_use]
     pub fn interface(&self) -> &str {
         &self.0.interface
     }
 
     /// Returns the version of the interface of this object.
+    #[must_use]
     pub fn version(&self) -> u32 {
         self.0.version
     }
@@ -139,6 +144,7 @@ impl Object {
     /// keyboard.key(0x41, KeyState::Press);
     /// ```
     // TODO(axka, 2025-07-02): return Result<T, Self>
+    #[must_use]
     pub fn downcast<T: Interface>(self) -> Option<T> {
         if (self.0.client_side, self.interface()) == (T::CLIENT_SIDE, T::NAME) {
             Some(self.downcast_unchecked())
diff --git a/src/request.rs b/src/request.rs
diff --git a/src/util.rs b/src/util.rs
diff --git a/src/wire/backend.rs b/src/wire/backend.rs

Original file line number	Diff line number	Diff line change
`@@ -104,13 +104,12 @@ impl State {`
`104`	`104`	`_ => {}`
`105`	`105`	`}`
`106`	`106`	`}`
`107`		`- ei::Event::Callback(callback, request) => match request {`
`108`		`- ei::callback::Event::Done { callback_data: _ } => {`
	`107`	`+ ei::Event::Callback(callback, request) => {`
	`108`	`+ if let ei::callback::Event::Done { callback_data: _ } = request {`
`109`	`109`	`// TODO: Callback being called after first device, but not later ones?`
`110`	`110`	`// self.print_and_exit_if_done();`
`111`	`111`	`}`
`112`		`- _ => {}`
`113`		`- },`
	`112`	`+ }`
`114`	`113`	`_ => {}`
`115`	`114`	`}`
`116`	`115`
Original file line number	Diff line number	Diff line change
`@@ -78,11 +78,11 @@ fn main() {`
`78`	`78`	`println!(" seat: {:?}", evt.device.seat().name());`
`79`	`79`	`println!(" type: {:?}", evt.device.device_type());`
`80`	`80`	`if let Some(dimensions) = evt.device.dimensions() {`
`81`		`- println!(" dimensions: {:?}", dimensions);`
	`81`	`+ println!(" dimensions: {dimensions:?}");`
`82`	`82`	`}`
`83`	`83`	`println!(" regions: {:?}", evt.device.regions());`
`84`	`84`	`if let Some(keymap) = evt.device.keymap() {`
`85`		`- println!(" keymap: {:?}", keymap);`
	`85`	`+ println!(" keymap: {keymap:?}");`
`86`	`86`	`}`
`87`	`87`	`// Interfaces?`
`88`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,11 +79,11 @@ async fn main() {`
`79`	`79`	`println!(" seat: {:?}", evt.device.seat().name());`
`80`	`80`	`println!(" type: {:?}", evt.device.device_type());`
`81`	`81`	`if let Some(dimensions) = evt.device.dimensions() {`
`82`		`- println!(" dimensions: {:?}", dimensions);`
	`82`	`+ println!(" dimensions: {dimensions:?}");`
`83`	`83`	`}`
`84`	`84`	`println!(" regions: {:?}", evt.device.regions());`
`85`	`85`	`if let Some(keymap) = evt.device.keymap() {`
`86`		`- println!(" keymap: {:?}", keymap);`
	`86`	`+ println!(" keymap: {keymap:?}");`
`87`	`87`	`}`
`88`	`88`	`// Interfaces?`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ pub struct EisListenerSource {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`impl EisListenerSource {`
	`20`	`+ #[must_use]`
`20`	`21`	`pub fn new(listener: eis::Listener) -> Self {`
`21`	`22`	`Self {`
`22`	`23`	`source: Generic::new(listener, Interest::READ, Mode::Level),`
`@@ -166,6 +167,7 @@ pub struct EisRequestSource {`
`166`	`167`	`}`
`167`	`168`
`168`	`169`	`impl EisRequestSource {`
	`170`	`+ #[must_use]`
`169`	`171`	`pub fn new(context: eis::Context, initial_serial: u32) -> Self {`
`170`	`172`	`let handshaker = crate::handshake::EisHandshaker::new(&context, initial_serial);`
`171`	`173`	`Self {`
Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,7 @@ impl Context {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	/// Returns the interface proxy for the `ei_handshake` object.
	`101`	`+ #[must_use]`
`101`	`102`	`pub fn handshake(&self) -> handshake::Handshake {`
`102`	`103`	`self.0.object_for_id(0).unwrap().downcast_unchecked()`
`103`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,6 +134,7 @@ impl Context {`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	/// Returns the interface proxy for the `ei_handshake` object.
	`137`	`+ #[must_use]`
`137`	`138`	`pub fn handshake(&self) -> handshake::Handshake {`
`138`	`139`	`self.0.object_for_id(0).unwrap().downcast_unchecked()`
`139`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ impl fmt::Display for Error {`
`22`	`22`	`write!(f, "invalid version {version} for interface '{interface}'")`
`23`	`23`	`}`
`24`	`24`	`Self::Event(err) => write!(f, "event error: {err}"),`
`25`		`- Self::Request(err) => write!(f, "request error: {}", err),`
	`25`	`+ Self::Request(err) => write!(f, "request error: {err}"),`
`26`	`26`	`Self::Io(err) => write!(f, "IO error: {err}"),`
`27`	`27`	`Self::Handshake(err) => write!(f, "handshake error: {err}"),`
`28`	`28`	`Self::Parse(err) => write!(f, "parse error: {err}"),`