Fix clippy

cprover_bindings/src/goto_program/typ.rs

@@ -898,11 +898,9 @@ impl Type {
         } else if concrete_self.is_scalar() && concrete_other.is_scalar() {
             concrete_self == concrete_other
         } else if concrete_self.is_struct_like() && concrete_other.is_scalar() {
-            concrete_self
-                .unwrap_transparent_type(st) == Some(concrete_other.clone())
+            concrete_self.unwrap_transparent_type(st) == Some(concrete_other.clone())
         } else if concrete_self.is_scalar() && concrete_other.is_struct_like() {
-            concrete_other
-                .unwrap_transparent_type(st) == Some(concrete_self.clone())
+            concrete_other.unwrap_transparent_type(st) == Some(concrete_self.clone())
         } else if concrete_self.is_struct_like() && concrete_other.is_struct_like() {
             let self_components = concrete_self.get_non_empty_components(st).unwrap();
             let other_components = concrete_other.get_non_empty_components(st).unwrap();

kani-compiler/src/codegen_cprover_gotoc/codegen/typ.rs

@@ -1742,11 +1742,11 @@ impl<'tcx> GotocCtx<'tcx> {
     /// TODO: Should we use `std_pointee_type` here?
     /// <https://github.com/model-checking/kani/issues/1529>
     pub fn is_fat_pointer(&self, pointer_ty: Ty<'tcx>) -> bool {
-        pointee_type(pointer_ty).map_or(false, |pointee_ty| self.use_fat_pointer(pointee_ty))
+        pointee_type(pointer_ty).is_some_and(|pointee_ty| self.use_fat_pointer(pointee_ty))
     }
 
     /// Check if the mir type already is a vtable fat pointer.
     pub fn is_vtable_fat_pointer(&self, mir_type: Ty<'tcx>) -> bool {
-        pointee_type(mir_type).map_or(false, |pointee_ty| self.use_vtable_fat_pointer(pointee_ty))
+        pointee_type(mir_type).is_some_and(|pointee_ty| self.use_vtable_fat_pointer(pointee_ty))
     }
 }

kani-compiler/src/codegen_cprover_gotoc/overrides/hooks.rs

@@ -561,7 +561,7 @@ pub struct LoopInvariantRegister;
 impl GotocHook for LoopInvariantRegister {
     fn hook_applies(&self, _tcx: TyCtxt, instance: Instance) -> bool {
         attributes::fn_marker(instance.def)
-            .map_or(false, |marker| marker == "kani_register_loop_contract")
+            .is_some_and(|marker| marker == "kani_register_loop_contract")
     }
 
     fn handle(

kani-compiler/src/kani_middle/abi.rs

@@ -30,18 +30,18 @@ impl LayoutOf {
     /// This will also return `true` if the type is foreign.
     pub fn has_foreign_tail(&self) -> bool {
         self.unsized_tail()
-            .map_or(false, |t| matches!(t.kind(), TyKind::RigidTy(RigidTy::Foreign(_))))
+            .is_some_and(|t| matches!(t.kind(), TyKind::RigidTy(RigidTy::Foreign(_))))
     }
 
     /// Return whether the type is unsized and its tail is a trait object.
     pub fn has_trait_tail(&self) -> bool {
-        self.unsized_tail().map_or(false, |t| t.kind().is_trait())
+        self.unsized_tail().is_some_and(|t| t.kind().is_trait())
     }
 
     /// Return whether the type is unsized and its tail is a slice.
     #[allow(dead_code)]
     pub fn has_slice_tail(&self) -> bool {
-        self.unsized_tail().map_or(false, |tail| {
+        self.unsized_tail().is_some_and(|tail| {
             let kind = tail.kind();
             kind.is_slice() | kind.is_str()
         })

kani-compiler/src/kani_middle/resolve/type_resolution.rs

@@ -173,7 +173,7 @@ pub(super) fn is_type_primitive(typ: &syn::Type) -> bool {
         }
         Type::Path(TypePath { qself: None, path }) => path
             .get_ident()
-            .map_or(false, |ident| PrimitiveIdent::from_str(&ident.to_string()).is_ok()),
+            .is_some_and(|ident| PrimitiveIdent::from_str(&ident.to_string()).is_ok()),
         Type::BareFn(_)
         | Type::Group(_)
         | Type::ImplTrait(_)