Go clippy-clean for the rust/* crates and enforce it

This covers the default clippy warnings.

Signed-off-by: Miguel Ojeda <[email protected]>

Author: ojeda

rust/compiler_builtins.rs

@@ -25,6 +25,10 @@
 #![compiler_builtins]
 #![no_builtins]
 #![no_std]
+#![deny(clippy::complexity)]
+#![deny(clippy::correctness)]
+#![deny(clippy::perf)]
+#![deny(clippy::style)]
 
 macro_rules! define_panicking_intrinsics(
     ($reason: tt, { $($ident: ident, )* }) => {

rust/kernel/file_operations.rs

@@ -160,17 +160,17 @@ impl<T: FileOperations> FileOperationsVtable<T> {
     pub(crate) const VTABLE: bindings::file_operations = bindings::file_operations {
         open: Some(open_callback::<T>),
         release: Some(release_callback::<T>),
-        read: if let Some(_) = T::READ {
+        read: if T::READ.is_some() {
             Some(read_callback::<T>)
         } else {
             None
         },
-        write: if let Some(_) = T::WRITE {
+        write: if T::WRITE.is_some() {
             Some(write_callback::<T>)
         } else {
             None
         },
-        llseek: if let Some(_) = T::SEEK {
+        llseek: if T::SEEK.is_some() {
             Some(llseek_callback::<T>)
         } else {
             None
@@ -184,7 +184,7 @@ impl<T: FileOperations> FileOperationsVtable<T> {
         fasync: None,
         flock: None,
         flush: None,
-        fsync: if let Some(_) = T::FSYNC {
+        fsync: if T::FSYNC.is_some() {
             Some(fsync_callback::<T>)
         } else {
             None

rust/kernel/lib.rs

@@ -13,6 +13,10 @@
 
 #![no_std]
 #![feature(allocator_api, alloc_error_handler)]
+#![deny(clippy::complexity)]
+#![deny(clippy::correctness)]
+#![deny(clippy::perf)]
+#![deny(clippy::style)]
 
 // Ensure conditional compilation based on the kernel configuration works;
 // otherwise we may silently break things like initcall handling.

rust/kernel/miscdev.rs

@@ -73,6 +73,12 @@ impl Registration {
     }
 }
 
+impl Default for Registration {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 // SAFETY: The only method is `register()`, which requires a (pinned) mutable
 // `Registration`, so it is safe to pass `&Registration` to multiple threads
 // because it offers no interior mutability.

rust/kernel/printk.rs

@@ -33,7 +33,6 @@ pub struct LogLineWriter {
     pos: usize,
 }
 
-#[allow(clippy::new_without_default)]
 impl LogLineWriter {
     /// Creates a new [`LogLineWriter`].
     pub fn new() -> LogLineWriter {
@@ -49,6 +48,12 @@ impl LogLineWriter {
     }
 }
 
+impl Default for LogLineWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl fmt::Write for LogLineWriter {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         let copy_len = cmp::min(LOG_LINE_MAX - self.pos, s.as_bytes().len());

rust/module.rs

@@ -4,6 +4,11 @@
 //!
 //! C header: [`include/linux/moduleparam.h`](../../../include/linux/moduleparam.h)
 
+#![deny(clippy::complexity)]
+#![deny(clippy::correctness)]
+#![deny(clippy::perf)]
+#![deny(clippy::style)]
+
 use proc_macro::{token_stream, Delimiter, Group, TokenStream, TokenTree};
 
 fn expect_ident(it: &mut token_stream::IntoIter) -> String {
@@ -39,8 +44,7 @@ fn expect_group(it: &mut token_stream::IntoIter) -> Group {
 }
 
 fn expect_end(it: &mut token_stream::IntoIter) {
-    if let None = it.next() {
-    } else {
+    if it.next().is_some() {
         panic!("Expected end");
     }
 }
@@ -73,7 +77,7 @@ fn get_byte_string(it: &mut token_stream::IntoIter, expected_name: &str) -> Stri
     let byte_string = get_literal(it, expected_name);
 
     assert!(byte_string.starts_with("b\""));
-    assert!(byte_string.ends_with("\""));
+    assert!(byte_string.ends_with('\"'));
 
     byte_string[2..byte_string.len() - 1].to_string()
 }