Minor cleanup to use is_some_and(...) instead of map_or(false, ...)

src/analysis/functions.rs

@@ -112,7 +112,7 @@ impl Info {
             .trim_end_matches('_')
             .rsplit('_')
             .next()
-            .map_or(false, |i| i.parse::<special_functions::Type>().is_ok())
+            .is_some_and(|i| i.parse::<special_functions::Type>().is_ok())
     }
 
     // returns whether the method can be linked in the docs

src/analysis/special_functions.rs

@@ -141,9 +141,11 @@ pub fn extract(functions: &mut [FuncInfo], parent_type: &LibType, obj: &GObject)
 
     for (pos, func) in functions.iter_mut().enumerate() {
         if is_stringify(func, parent_type, obj) {
-            let return_transfer_none = func.ret.parameter.as_ref().map_or(false, |ret| {
-                ret.lib_par.transfer == crate::library::Transfer::None
-            });
+            let return_transfer_none = func
+                .ret
+                .parameter
+                .as_ref()
+                .is_some_and(|ret| ret.lib_par.transfer == crate::library::Transfer::None);
 
             // Assume only enumerations and bitfields can return static strings
             let returns_static_ref = return_transfer_none
@@ -198,7 +200,7 @@ pub fn extract(functions: &mut [FuncInfo], parent_type: &LibType, obj: &GObject)
                 .parameters
                 .c_parameters
                 .first()
-                .map_or(false, |p| p.ref_mode == super::ref_mode::RefMode::ByRefMut);
+                .is_some_and(|p| p.ref_mode == super::ref_mode::RefMode::ByRefMut);
 
             specials.traits.insert(
                 type_,

src/codegen/alias.rs

@@ -19,7 +19,7 @@ pub fn generate(env: &Env, root_path: &Path, mod_rs: &mut Vec<String>) {
         .objects
         .values()
         .filter(|c| {
-            c.status.need_generate() && c.type_id.map_or(false, |tid| tid.ns_id == namespaces::MAIN)
+            c.status.need_generate() && c.type_id.is_some_and(|tid| tid.ns_id == namespaces::MAIN)
         })
         .collect();
     let mut has_any = false;

src/codegen/doc/format.rs

@@ -415,7 +415,7 @@ fn find_method_or_function_by_ctype(
         |r| c_type.map_or(true, |t| r.type_(&env.library).c_type == t),
         |r| c_type.map_or(true, |t| r.type_(&env.library).c_type == t),
         |r| c_type.map_or(true, |t| r.type_(&env.library).c_type == t),
-        c_type.map_or(false, |t| t.ends_with("Class")),
+        c_type.is_some_and(|t| t.ends_with("Class")),
         false,
     )
 }

src/codegen/doc/mod.rs

@@ -195,8 +195,7 @@ fn generate_doc(w: &mut dyn Write, env: &Env) -> Result<()> {
                     .map(|analyzed_f| analyzed_f.doc_ignore_parameters.clone())
                     .unwrap_or_default();
 
-                let should_be_documented =
-                    f_info.map_or(false, |f| f.should_docs_be_generated(env));
+                let should_be_documented = f_info.is_some_and(|f| f.should_docs_be_generated(env));
                 if !should_be_documented {
                     continue;
                 }
@@ -512,7 +511,7 @@ fn create_object_doc(w: &mut dyn Write, env: &Env, info: &analysis::object::Info
         };
         if let Some(c_identifier) = &function.c_identifier {
             let f_info = info.functions.iter().find(|f| &f.glib_name == c_identifier);
-            let should_be_documented = f_info.map_or(false, |f| f.should_docs_be_generated(env));
+            let should_be_documented = f_info.is_some_and(|f| f.should_docs_be_generated(env));
 
             if !should_be_documented {
                 continue;
@@ -587,7 +586,7 @@ fn create_object_doc(w: &mut dyn Write, env: &Env, info: &analysis::object::Info
                 .virtual_methods
                 .iter()
                 .find(|f| &f.glib_name == c_identifier);
-            let should_be_documented = f_info.map_or(false, |f| f.should_docs_be_generated(env));
+            let should_be_documented = f_info.is_some_and(|f| f.should_docs_be_generated(env));
             if !should_be_documented {
                 continue;
             }
@@ -695,7 +694,7 @@ fn create_record_doc(w: &mut dyn Write, env: &Env, info: &analysis::record::Info
         };
         if let Some(c_identifier) = &function.c_identifier {
             let f_info = info.functions.iter().find(|f| &f.glib_name == c_identifier);
-            let should_be_documented = f_info.map_or(false, |f| f.should_docs_be_generated(env));
+            let should_be_documented = f_info.is_some_and(|f| f.should_docs_be_generated(env));
             if !should_be_documented {
                 continue;
             }

src/codegen/function.rs

@@ -300,7 +300,7 @@ pub fn bounds(
     let skip_lifetimes = bounds
         .iter()
         // TODO: False or true?
-        .filter(|bound| bound.alias.map_or(false, |alias| skip.contains(&alias)))
+        .filter(|bound| bound.alias.is_some_and(|alias| skip.contains(&alias)))
         .filter_map(|bound| match bound.bound_type {
             IsA(lifetime) | AsRef(lifetime) => lifetime,
             _ => None,

src/codegen/general.rs

@@ -1033,7 +1033,7 @@ pub fn declare_default_from_new(
             && f.status.need_generate()
             && f.name == "new"
             // Cannot generate Default implementation for Option<>
-            && f.ret.parameter.as_ref().map_or(false, |x| !*x.lib_par.nullable)
+            && f.ret.parameter.as_ref().is_some_and(|x| !*x.lib_par.nullable)
     }) {
         if func.parameters.rust_parameters.is_empty() {
             writeln!(w)?;

src/library.rs

@@ -1126,7 +1126,7 @@ impl Library {
                         .config
                         .objects
                         .get(&full_name)
-                        .map_or(false, |obj| obj.generate_builder)
+                        .is_some_and(|obj| obj.generate_builder)
                         && properties
                             .iter()
                             .any(|prop| prop.construct_only || prop.construct || prop.writable)

src/parser.rs

@@ -162,7 +162,7 @@ impl Library {
         let get_type = elem.attr_required("get-type")?;
         let version = self.read_version(parser, ns_id, elem)?;
         let deprecated_version = self.read_deprecated_version(parser, ns_id, elem)?;
-        let is_fundamental = elem.attr("fundamental").map_or(false, |x| x == "1");
+        let is_fundamental = elem.attr("fundamental").is_some_and(|x| x == "1");
         let (ref_fn, unref_fn) = if is_fundamental {
             (
                 elem.attr("ref-func").map(ToOwned::to_owned),
@@ -172,8 +172,8 @@ impl Library {
             (None, None)
         };
 
-        let is_abstract = elem.attr("abstract").map_or(false, |x| x == "1");
-        let final_type = elem.attr("final").map_or(false, |x| x == "1");
+        let is_abstract = elem.attr("abstract").is_some_and(|x| x == "1");
+        let final_type = elem.attr("final").is_some_and(|x| x == "1");
 
         let mut fns = Vec::new();
         let mut signals = Vec::new();