fix: clippy warnings

Signed-off-by: Anand Krishnamoorthi <anakrish@microsoft.com>

Author: anakrish

examples/helpers/type_analysis.rs

@@ -377,7 +377,7 @@ pub fn rego_type_analysis(
                             let head_display = spec
                                 .head_fact
                                 .as_ref()
-                                .map(|fact| format_fact_summary(fact))
+                                .map(format_fact_summary)
                                 .unwrap_or_else(|| "Unknown".to_owned());
                             println!("       - {} → {}", signature_display, head_display);
 
@@ -482,7 +482,7 @@ pub fn rego_type_analysis(
                                             let head_display = spec
                                                 .head_fact
                                                 .as_ref()
-                                                .map(|fact| format_fact_summary(fact))
+                                                .map(format_fact_summary)
                                                 .unwrap_or_else(|| "Unknown".to_owned());
                                             println!(
                                                 "           • {} → {}",
@@ -544,7 +544,7 @@ fn format_specialization_signature(rule_path: &str, spec: &RuleSpecializationRec
     let args: Vec<String> = spec
         .parameter_facts
         .iter()
-        .map(|fact| format_fact_summary(fact))
+        .map(format_fact_summary)
         .collect();
 
     let joined = if args.is_empty() {
@@ -674,10 +674,7 @@ fn describe_structural_type_impl(st: &StructuralType) -> String {
             }
         }
         StructuralType::Union(types) => {
-            let rendered: Vec<String> = types
-                .iter()
-                .map(|ty| describe_structural_type_impl(ty))
-                .collect();
+            let rendered: Vec<String> = types.iter().map(describe_structural_type_impl).collect();
             format!("Union[{}]", rendered.join(", "))
         }
         StructuralType::Enum(values) => {

src/engine.rs

@@ -63,6 +63,14 @@ impl Default for Engine {
     }
 }
 
+/// Bundled artifacts used by the type analyzer when operating on an engine.
+pub(crate) type TypeAnalysisContext = (
+    Rc<Vec<Ref<Module>>>,
+    Option<Rc<crate::scheduler::Schedule>>,
+    Option<Rc<crate::compiler::hoist::HoistedLoopsLookup>>,
+    Rc<CompiledPolicyData>,
+);
+
 impl Engine {
     /// Create an instance of [Engine].
     pub fn new() -> Self {
@@ -1613,14 +1621,7 @@ impl Engine {
     /// Get the context needed for type analysis.
     /// Returns (modules, schedule, loop_lookup, compiled_policy) for use by TypeAnalyzer.
     /// The engine will prepare itself if needed. Returns None if preparation fails.
-    pub(crate) fn get_type_analysis_context(
-        &mut self,
-    ) -> Option<(
-        Rc<Vec<Ref<Module>>>,
-        Option<Rc<crate::scheduler::Schedule>>,
-        Option<Rc<crate::compiler::hoist::HoistedLoopsLookup>>,
-        Rc<CompiledPolicyData>,
-    )> {
+    pub(crate) fn get_type_analysis_context(&mut self) -> Option<TypeAnalysisContext> {
         if self.prepare_for_eval(false, false).is_err() {
             return None;
         }
@@ -1641,7 +1642,7 @@ impl Engine {
         rule_path: &str,
     ) -> Option<crate::value::Value> {
         // Prepare the engine if not already prepared
-        if let Err(_) = self.prepare_for_eval(false, false) {
+        if self.prepare_for_eval(false, false).is_err() {
             return None;
         }
 

src/type_analysis/propagation/expressions/rules/calls/effects.rs

@@ -73,9 +73,7 @@ pub(crate) fn apply_rule_call_effects(
         );
 
         if !scratch_result.diagnostics.is_empty() {
-            result
-                .diagnostics
-                .extend(scratch_result.diagnostics.drain(..));
+            result.diagnostics.append(&mut scratch_result.diagnostics);
         }
 
         let head_fact = scratch_result

src/type_analysis/propagation/pipeline/analyzer/rule_analysis/bodies.rs

@@ -14,6 +14,7 @@ use super::super::super::result::AnalysisState;
 use super::super::TypeAnalyzer;
 
 impl TypeAnalyzer {
+    #[allow(clippy::too_many_arguments)]
     pub(super) fn analyze_rule_body(
         &self,
         module_idx: u32,

src/type_analysis/propagation/pipeline/analyzer/rule_analysis/heads.rs

@@ -175,9 +175,7 @@ impl TypeAnalyzer {
             }
             Self::merge_rule_head_origins(&mut existing.origins, origins);
             if !specialization_hits.is_empty() {
-                existing
-                    .specialization_hits
-                    .extend(specialization_hits.into_iter());
+                existing.specialization_hits.extend(specialization_hits);
             }
         } else {
             let mut stored = TypeFact::new(descriptor, provenance);

src/type_analysis/propagation/pipeline/result.rs

@@ -78,7 +78,7 @@ impl AnalysisState {
         let signature = record.signature.clone();
         self.function_rule_specializations
             .entry(key)
-            .or_insert_with(BTreeMap::new)
+            .or_default()
             .insert(signature, record);
     }
 

src/type_analysis/result/mod.rs

@@ -41,12 +41,12 @@ pub struct TypeAnalysisResult {
 }
 
 fn rule_returns_boolean_by_default(head: &RuleHead) -> bool {
-    match head {
-        RuleHead::Func { assign: None, .. } => true,
-        RuleHead::Compr { assign: None, .. } => true,
-        RuleHead::Set { .. } => true,
-        _ => false,
-    }
+    matches!(
+        head,
+        RuleHead::Func { assign: None, .. }
+            | RuleHead::Compr { assign: None, .. }
+            | RuleHead::Set { .. }
+    )
 }
 
 fn default_true_body_fact() -> TypeFact {
@@ -193,17 +193,14 @@ impl TypeAnalysisResult {
                                 col: span.col,
                             };
 
-                            let value_expr_idx = body
-                                .assign
-                                .as_ref()
-                                .map(|assign| assign.value.eidx())
-                                .or_else(|| {
+                            let value_expr_idx =
+                                body.assign.as_ref().map(|assign| assign.value.eidx()).or(
                                     if body_idx == 0 {
                                         head_value_expr_idx
                                     } else {
                                         None
-                                    }
-                                });
+                                    },
+                                );
 
                             let mut value_fact = value_expr_idx
                                 .and_then(|idx| state.lookup.get_expr(module_idx_u32, idx))

src/type_analysis/result/rules.rs

@@ -94,33 +94,23 @@ pub struct RuleBodySummary {
 }
 
 /// Distinguishes the main body from `else` bodies within a definition.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum RuleBodyKind {
+    #[default]
     Primary,
     Else,
 }
 
-impl Default for RuleBodyKind {
-    fn default() -> Self {
-        RuleBodyKind::Primary
-    }
-}
-
 /// Classification for rule heads.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum RuleKind {
+    #[default]
     Complete,
     PartialSet,
     PartialObject,
     Function,
 }
 
-impl Default for RuleKind {
-    fn default() -> Self {
-        RuleKind::Complete
-    }
-}
-
 /// Specialization record captured for function rules.
 #[derive(Clone, Debug)]
 pub struct RuleSpecializationRecord {