Warn on clippy::pedantic by default

Author: axelkar

Cargo.toml

@@ -24,6 +24,16 @@ tokio = { version = "1.31.0", features = ["rt", "macros"] }
 signal-hook = "0.3.17"
 pollster = "0.4.0"
 
+[lints.clippy]
+pedantic = "warn"
+allow_attributes = "warn"
+allow_attributes_without_reason = "warn"
+should_panic_without_expect = "warn"
+str_to_string = "warn"
+string_to_string = "warn"
+cast_possible_wrap = { level = "allow", priority = 1 }
+cast_possible_truncation = { level = "allow", priority = 1 }
+
 [features]
 tokio = ["dep:tokio", "futures"]
 # Experimental and somewhat incomplete

examples/receive-synchronous.rs

@@ -34,7 +34,7 @@ async fn open_connection() -> ei::Context {
                 let x = region.x_offset();
                 let y = region.y_offset();
                 let w = region.width() as i32;
-                let h = region.height() as i32;
+                let _h = region.height() as i32;
                 Barrier::new(NonZero::new(n as u32 + 1).unwrap(), (x, y, x + w - 1, y))
             })
             .collect::<Vec<_>>();
@@ -72,7 +72,7 @@ fn main() {
                         | DeviceCapability::Scroll
                         | DeviceCapability::Button,
                 );
-                context.flush();
+                let _ = context.flush();
             }
             reis::event::EiEvent::DeviceAdded(evt) => {
                 println!("  seat: {:?}", evt.device.seat().name());

src/ei.rs

@@ -49,6 +49,10 @@ impl Context {
     ///
     /// let context = Context::new(socket).unwrap();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if setting the socket to non-blocking mode fails.
     pub fn new(socket: UnixStream) -> io::Result<Self> {
         Ok(Self(Backend::new(socket, true)?))
     }
@@ -63,6 +67,11 @@ impl Context {
     ///
     /// let context = Context::connect_to_env().expect("Shouldn't error").unwrap();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if the resolved socket path cannot be connected to or if
+    /// [`Context::new`] fails.
     pub fn connect_to_env() -> io::Result<Option<Self>> {
         let Some(path) = env::var_os("LIBEI_SOCKET") else {
             // XXX return error type
@@ -87,6 +96,10 @@ impl Context {
     /// Reads any pending data on the socket into the internal buffer.
     ///
     /// Returns `UnexpectedEof` if end-of-file is reached.
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if there is an I/O error.
     pub fn read(&self) -> io::Result<usize> {
         self.0.read()
     }
@@ -99,11 +112,19 @@ impl Context {
 
     /// Returns the interface proxy for the `ei_handshake` object.
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "infallible; Backend always creates ei_handshake object at 0"
+    )]
     pub fn handshake(&self) -> handshake::Handshake {
         self.0.object_for_id(0).unwrap().downcast_unchecked()
     }
 
     /// Sends buffered messages. Call after you're finished with sending requests.
+    ///
+    /// # Errors
+    ///
+    /// An error will be returned if sending the buffered messages fails.
     pub fn flush(&self) -> rustix::io::Result<()> {
         self.0.flush()
     }

src/eiproto.rs.jinja

@@ -1,5 +1,23 @@
 {# ei-scanner jinja template, for `` #}
-#![allow(unknown_lints, unused_imports, unused_parens, clippy::useless_conversion, clippy::double_parens, clippy::match_single_binding, clippy::unused_unit, clippy::empty_docs, clippy::doc_lazy_continuation)]
+#![allow(
+    unknown_lints,
+    unused_imports,
+    unused_parens,
+    clippy::useless_conversion,
+    clippy::double_parens,
+    clippy::match_single_binding,
+    clippy::unused_unit,
+    clippy::empty_docs,
+    clippy::doc_lazy_continuation,
+
+    // Explicitly set to warn
+    clippy::doc_markdown,
+    clippy::must_use_candidate,
+    clippy::semicolon_if_nothing_returned,
+    clippy::used_underscore_binding,
+    clippy::match_same_arms,
+    clippy::str_to_string,
+)]
 
 // GENERATED FILE
 

src/eiproto_ei.rs

@@ -7,7 +7,15 @@
     clippy::match_single_binding,
     clippy::unused_unit,
     clippy::empty_docs,
-    clippy::doc_lazy_continuation
+    clippy::doc_lazy_continuation,
+
+    // Explicitly set to warn
+    clippy::doc_markdown,
+    clippy::must_use_candidate,
+    clippy::semicolon_if_nothing_returned,
+    clippy::used_underscore_binding,
+    clippy::match_same_arms,
+    clippy::str_to_string,
 )]
 
 // GENERATED FILE

src/eiproto_eis.rs

@@ -7,7 +7,15 @@
     clippy::match_single_binding,
     clippy::unused_unit,
     clippy::empty_docs,
-    clippy::doc_lazy_continuation
+    clippy::doc_lazy_continuation,
+
+    // Explicitly set to warn
+    clippy::doc_markdown,
+    clippy::must_use_candidate,
+    clippy::semicolon_if_nothing_returned,
+    clippy::used_underscore_binding,
+    clippy::match_same_arms,
+    clippy::str_to_string,
 )]
 
 // GENERATED FILE

src/eis.rs

@@ -29,13 +29,23 @@ pub struct Listener {
 impl Listener {
     // TODO Use a lock here
     /// Listens on a specific path.
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if binding to the given path or setting the socket to
+    /// non-blocking mode fails.
     pub fn bind(path: &Path) -> io::Result<Self> {
         Self::bind_inner(PathBuf::from(path), None)
     }
 
     // XXX result type?
     // Error if XDG_RUNTIME_DIR not set?
     /// Listens on a file in `XDG_RUNTIME_DIR`.
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if a lock file cannot be locked, binding to the generated path
+    /// fails or setting the socket to non-blocking mode fails.
     pub fn bind_auto() -> io::Result<Option<Self>> {
         let xdg_dir = if let Some(var) = env::var_os("XDG_RUNTIME_DIR") {
             PathBuf::from(var)
@@ -65,6 +75,10 @@ impl Listener {
     }
 
     /// Accepts a connection from a client. Returns `Ok(Some(_)` if an incoming connection is ready, and `Ok(None)` if there is no connection ready (would block).
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if [`Context::new`] fails.
     pub fn accept(&self) -> io::Result<Option<Context>> {
         match self.listener.accept() {
             Ok((socket, _)) => Ok(Some(Context::new(socket)?)),
@@ -116,13 +130,21 @@ impl Context {
     ///
     /// // Pass the `b` file descriptor to implement the RemoteDesktop XDG desktop portal
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if setting the socket to non-blocking mode fails.
     pub fn new(socket: UnixStream) -> io::Result<Self> {
         Ok(Self(Backend::new(socket, false)?))
     }
 
     /// Reads any pending data on the socket into the internal buffer.
     ///
     /// Returns `UnexpectedEof` if end-of-file is reached.
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if there is an I/O error.
     pub fn read(&self) -> io::Result<usize> {
         self.0.read()
     }
@@ -135,11 +157,19 @@ impl Context {
 
     /// Returns the interface proxy for the `ei_handshake` object.
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "infallible; Backend always creates ei_handshake object at 0"
+    )]
     pub fn handshake(&self) -> handshake::Handshake {
         self.0.object_for_id(0).unwrap().downcast_unchecked()
     }
 
     /// Sends buffered messages. Call after you're finished with sending events.
+    ///
+    /// # Errors
+    ///
+    /// An error will be returned if sending the buffered messages fails.
     pub fn flush(&self) -> rustix::io::Result<()> {
         self.0.flush()
     }

src/event.rs

@@ -78,6 +78,10 @@ impl Connection {
     }
 
     /// Sends buffered messages. Call after you're finished with sending requests.
+    ///
+    /// # Errors
+    ///
+    /// An error will be returned if sending the buffered messages fails.
     pub fn flush(&self) -> rustix::io::Result<()> {
         self.0.context.flush()
     }
@@ -159,6 +163,7 @@ impl EiEventConverter {
     /// # Errors
     ///
     /// The errors returned are protocol violations.
+    #[expect(clippy::too_many_lines, reason = "Handler is allowed to be big")]
     pub fn handle_event(&mut self, event: ei::Event) -> Result<(), EventError> {
         match event {
             ei::Event::Handshake(_handshake, _event) => {
@@ -171,7 +176,7 @@ impl EiEventConverter {
                         SeatInner {
                             proto_seat: seat,
                             name: None,
-                            capability_map: Default::default(),
+                            capability_map: CapabilityMap::default(),
                         },
                     );
                 }
@@ -286,7 +291,7 @@ impl EiEventConverter {
                         .ok_or(EventError::DeviceSetupEventAfterDone)?;
                     device
                         .interfaces
-                        .insert(object.interface().to_string(), object);
+                        .insert(object.interface().to_owned(), object);
                 }
                 ei::device::Event::Dimensions { width, height } => {
                     let device = self
@@ -702,8 +707,8 @@ impl DeviceCapability {
 
     /// Returns the binary logarithm of the capability's bitwise value, useful for indexing
     /// lookup tables.
-    fn index(&self) -> usize {
-        (*self as u64).trailing_zeros() as usize
+    fn index(self) -> usize {
+        (self as u64).trailing_zeros() as usize
     }
 }
 
@@ -828,6 +833,10 @@ impl Device {
 
     /// Returns the device's type.
     #[must_use]
+    #[expect(
+        clippy::missing_panics_doc,
+        reason = "EiEventConverter makes sure to not return Device if device_type is None"
+    )]
     pub fn device_type(&self) -> ei::device::DeviceType {
         self.0.device_type.unwrap()
     }
@@ -1306,6 +1315,11 @@ impl Iterator for EiConvertEventIterator {
 }
 
 impl ei::Context {
+    /// Executes the handshake in blocking mode.
+    ///
+    /// # Errors
+    ///
+    /// Will return `Err` if there is an I/O error or a protocol violation.
     pub fn handshake_blocking(
         &self,
         name: &str,

src/handshake.rs

@@ -73,6 +73,11 @@ impl<'a> EiHandshaker<'a> {
         }
     }
 
+    /// Handles the given event, possibly returning a filled handshake response.
+    ///
+    /// # Errors
+    ///
+    /// The errors returned are protocol violations.
     pub fn handle_event(
         &mut self,
         event: ei::Event,
@@ -120,6 +125,11 @@ pub(crate) fn request_result<T>(result: PendingRequestResult<T>) -> Result<T, Er
     }
 }
 
+/// Executes the handshake in blocking mode.
+///
+/// # Errors
+///
+/// Will return `Err` if there is an I/O error or a protocol violation.
 pub fn ei_handshake_blocking(
     context: &ei::Context,
     name: &str,
@@ -170,6 +180,11 @@ impl EisHandshaker {
         }
     }
 
+    /// Handles the given request, possibly returning a filled handshake response.
+    ///
+    /// # Errors
+    ///
+    /// The errors returned are protocol violations.
     pub fn handle_request(
         &mut self,
         request: eis::Request,
@@ -195,7 +210,7 @@ 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_owned(), version.min(*server_version));
                 }
             }
             eis::handshake::Request::Finish => {