style: Make clippy happy

Author: epage

Cargo.toml

@@ -30,7 +30,7 @@ unused_macro_rules = "warn"
 unused_qualifications = "warn"
 
 [workspace.lints.clippy]
-allow_attributes_without_reason = "warn"
+#allow_attributes_without_reason = "warn"
 bool_assert_comparison = "allow"
 branches_sharing_code = "allow"
 byte_char_slices = "allow"  # sometimes explicit arrays are better
@@ -95,7 +95,7 @@ string_add_assign = "warn"
 string_lit_as_bytes = "warn"
 todo = "warn"
 trait_duplication_in_bounds = "warn"
-undocumented_unsafe_blocks = "warn"
+#undocumented_unsafe_blocks = "warn"
 uninlined_format_args = "warn"
 unnecessary_safety_comment = "warn"
 unnecessary_safety_doc = "warn"

src/boolean.rs

@@ -52,8 +52,8 @@ where
     Item: ?Sized,
 {
     /// Create a new `AndPredicate` over predicates `a` and `b`.
-    pub fn new(a: M1, b: M2) -> AndPredicate<M1, M2, Item> {
-        AndPredicate {
+    pub fn new(a: M1, b: M2) -> Self {
+        Self {
             a,
             b,
             _phantom: PhantomData,
@@ -240,8 +240,8 @@ where
     Item: ?Sized,
 {
     /// Create a new `OrPredicate` over predicates `a` and `b`.
-    pub fn new(a: M1, b: M2) -> OrPredicate<M1, M2, Item> {
-        OrPredicate {
+    pub fn new(a: M1, b: M2) -> Self {
+        Self {
             a,
             b,
             _phantom: PhantomData,
@@ -423,8 +423,8 @@ where
     Item: ?Sized,
 {
     /// Create a new `NotPredicate` over predicate `inner`.
-    pub fn new(inner: M) -> NotPredicate<M, Item> {
-        NotPredicate {
+    pub fn new(inner: M) -> Self {
+        Self {
             inner,
             _phantom: PhantomData,
         }

src/boxed.rs

@@ -24,11 +24,11 @@ where
 {
     /// Creates a new `BoxPredicate`, a wrapper around a dynamically-dispatched
     /// `Predicate` type with useful trait impls.
-    pub fn new<P>(inner: P) -> BoxPredicate<Item>
+    pub fn new<P>(inner: P) -> Self
     where
         P: Predicate<Item> + Send + Sync + 'static,
     {
-        BoxPredicate(Box::new(inner))
+        Self(Box::new(inner))
     }
 }
 

src/ord.rs

@@ -23,8 +23,8 @@ enum EqOps {
 impl fmt::Display for EqOps {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let op = match *self {
-            EqOps::Equal => "==",
-            EqOps::NotEqual => "!=",
+            Self::Equal => "==",
+            Self::NotEqual => "!=",
         };
         write!(f, "{op}")
     }
@@ -143,10 +143,10 @@ enum OrdOps {
 impl fmt::Display for OrdOps {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let op = match *self {
-            OrdOps::LessThan => "<",
-            OrdOps::LessThanOrEqual => "<=",
-            OrdOps::GreaterThanOrEqual => ">=",
-            OrdOps::GreaterThan => ">",
+            Self::LessThan => "<",
+            Self::LessThanOrEqual => "<=",
+            Self::GreaterThanOrEqual => ">=",
+            Self::GreaterThan => ">",
         };
         write!(f, "{op}")
     }

src/path/ft.rs

@@ -22,37 +22,37 @@ enum FileType {
 }
 
 impl FileType {
-    fn from_path(path: &path::Path, follow: bool) -> io::Result<FileType> {
+    fn from_path(path: &path::Path, follow: bool) -> io::Result<Self> {
         let file_type = if follow {
             path.metadata()
         } else {
             path.symlink_metadata()
         }?
         .file_type();
         if file_type.is_dir() {
-            return Ok(FileType::Dir);
+            return Ok(Self::Dir);
         }
         if file_type.is_file() {
-            return Ok(FileType::File);
+            return Ok(Self::File);
         }
-        Ok(FileType::Symlink)
+        Ok(Self::Symlink)
     }
 
     fn eval(self, ft: fs::FileType) -> bool {
         match self {
-            FileType::File => ft.is_file(),
-            FileType::Dir => ft.is_dir(),
-            FileType::Symlink => ft.is_symlink(),
+            Self::File => ft.is_file(),
+            Self::Dir => ft.is_dir(),
+            Self::Symlink => ft.is_symlink(),
         }
     }
 }
 
 impl fmt::Display for FileType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let t = match *self {
-            FileType::File => "file",
-            FileType::Dir => "dir",
-            FileType::Symlink => "symlink",
+            Self::File => "file",
+            Self::Dir => "dir",
+            Self::Symlink => "symlink",
         };
         write!(f, "{t}")
     }
@@ -79,8 +79,8 @@ impl FileTypePredicate {
     }
 
     /// Allow to create an `FileTypePredicate` from a `path`
-    pub fn from_path(path: &path::Path) -> io::Result<FileTypePredicate> {
-        Ok(FileTypePredicate {
+    pub fn from_path(path: &path::Path) -> io::Result<Self> {
+        Ok(Self {
             ft: FileType::from_path(path, true)?,
             follow: true,
         })