chore: apply all clippy pedantic fixes

Signed-off-by: azjezz <[email protected]>

Author: azjezz

crates/algebra/src/assertion_set.rs

@@ -78,6 +78,7 @@ pub fn add_and_clause(assertion_set: &mut AssertionSet, or_assertions: &[Asserti
 /// This function applies De Morgan's laws to the formula. The process involves:
 /// 1. Converting the CNF formula `(A OR B) AND C` to its negated DNF form: `(NOT A AND NOT B) OR (NOT C)`.
 /// 2. Converting the resulting DNF back to CNF using the distributive property.
+#[must_use]
 pub fn negate_assertion_set(assertion_set: AssertionSet) -> AssertionSet {
     // 1. Apply De Morgan's laws to get the DNF representation.
     //    `(A OR B) AND C` becomes `(¬A AND ¬B) OR (¬C)`.

crates/algebra/src/clause.rs

@@ -38,6 +38,7 @@ impl Hash for Clause {
 }
 
 impl Clause {
+    #[must_use]
     pub fn new(
         possibilities: IndexMap<Atom, IndexMap<u64, Assertion>>,
         condition_span: Span,
@@ -57,6 +58,7 @@ impl Clause {
         }
     }
 
+    #[must_use]
     pub fn remove_possibilities(&self, var_id: &Atom) -> Option<Clause> {
         let mut possibilities = self.possibilities.clone();
 
@@ -76,6 +78,7 @@ impl Clause {
         ))
     }
 
+    #[must_use]
     pub fn add_possibility(&self, var_id: Atom, new_possibility: IndexMap<u64, Assertion>) -> Clause {
         let mut possibilities = self.possibilities.clone();
 
@@ -91,6 +94,7 @@ impl Clause {
         )
     }
 
+    #[must_use]
     pub fn contains(&self, other_clause: &Self) -> bool {
         if other_clause.possibilities.len() > self.possibilities.len() {
             return false;
@@ -103,6 +107,7 @@ impl Clause {
         })
     }
 
+    #[must_use]
     pub fn get_impossibilities(&self) -> BTreeMap<Atom, Vec<Assertion>> {
         self.possibilities
             .iter()
@@ -114,6 +119,7 @@ impl Clause {
             .collect()
     }
 
+    #[must_use]
     pub fn to_atom(&self) -> Atom {
         if self.possibilities.is_empty() {
             return atom("<empty>");
@@ -176,7 +182,7 @@ fn get_hash(
     if wedge || !reconcilable {
         (Wrapping(clause_span.start.offset)
             + Wrapping(clause_span.end.offset)
-            + Wrapping(if wedge { 100000 } else { 0 }))
+            + Wrapping(if wedge { 100_000 } else { 0 }))
         .0
     } else {
         let mut hasher = AHasher::default();

crates/algebra/src/lib.rs

@@ -381,6 +381,7 @@ pub fn find_satisfying_assignments(
 ///
 /// A `Vec<Clause>` representing the resulting CNF formula.
 #[inline]
+#[must_use]
 pub fn disjoin_clauses(
     left_clauses: Vec<Clause>,
     right_clauses: Vec<Clause>,
@@ -504,6 +505,7 @@ pub fn disjoin_clauses(
 /// A `Some(Vec<Clause>)` representing the negated and simplified CNF formula,
 /// or `None` if the negation is not possible due to complexity or other constraints.
 #[inline]
+#[must_use]
 pub fn negate_formula(mut clauses: Vec<Clause>) -> Option<Vec<Clause>> {
     clauses.retain(|clause| clause.reconcilable);
 

crates/analyzer/src/analysis_result.rs

@@ -12,6 +12,7 @@ pub struct AnalysisResult {
 }
 
 impl AnalysisResult {
+    #[must_use]
     pub fn new(symbol_references: SymbolReferences) -> Self {
         Self {
             issues: IssueCollection::default(),

crates/analyzer/src/assertion.rs

@@ -17,7 +17,18 @@ use mago_codex::ttype::get_array_value_parameter;
 use mago_codex::ttype::get_iterable_value_parameter;
 use mago_span::HasSpan;
 use mago_span::Span;
-use mago_syntax::ast::*;
+use mago_syntax::ast::Access;
+use mago_syntax::ast::BinaryOperator;
+use mago_syntax::ast::Call;
+use mago_syntax::ast::ClassConstantAccess;
+use mago_syntax::ast::ClassLikeConstantSelector;
+use mago_syntax::ast::Construct;
+use mago_syntax::ast::Expression;
+use mago_syntax::ast::FunctionCall;
+use mago_syntax::ast::Literal;
+use mago_syntax::ast::LocalIdentifier;
+use mago_syntax::ast::UnaryPrefix;
+use mago_syntax::ast::UnaryPrefixOperator;
 
 use crate::artifacts::AnalysisArtifacts;
 use crate::context::assertion::AssertionContext;
@@ -115,7 +126,7 @@ pub fn scrape_assertions(
                 }
             }
             Construct::Isset(isset_construct) => {
-                for value in isset_construct.values.iter() {
+                for value in &isset_construct.values {
                     if let Some(value_id) = get_expression_id(
                         value,
                         assertion_context.this_class_name,

crates/analyzer/src/code.rs

@@ -291,6 +291,7 @@ pub enum IssueCode {
 }
 
 impl IssueCode {
+    #[must_use]
     pub fn as_str(&self) -> &'static str {
         match self {
             Self::AbstractClassUsedAsAttribute => "abstract-class-used-as-attribute",
@@ -583,6 +584,7 @@ impl IssueCode {
         }
     }
 
+    #[must_use]
     pub fn as_u16(&self) -> u16 {
         *self as u16
     }

crates/analyzer/src/common/construct.rs

@@ -9,7 +9,8 @@ use mago_reporting::Annotation;
 use mago_reporting::Issue;
 use mago_span::HasSpan;
 use mago_span::Span;
-use mago_syntax::ast::*;
+use mago_syntax::ast::ArgumentList;
+use mago_syntax::ast::Expression;
 
 use crate::analyzable::Analyzable;
 use crate::artifacts::AnalysisArtifacts;
@@ -38,7 +39,7 @@ pub fn analyze_construct_inputs<'ctx, 'arena>(
     construct_kind: &'static str,
     construct_keyword: Span,
     inputs: ConstructInput<'_, 'arena>,
-    expected_type: TUnion,
+    expected_type: &TUnion,
     is_variadic: bool,
     has_default: bool,
     has_side_effects: bool,
@@ -83,7 +84,7 @@ pub fn analyze_construct_inputs<'ctx, 'arena>(
                 verify_construct_input_type(
                     context,
                     &input_type,
-                    &expected_type,
+                    expected_type,
                     index,
                     argument.value(),
                     construct_kind,
@@ -101,7 +102,7 @@ pub fn analyze_construct_inputs<'ctx, 'arena>(
             verify_construct_input_type(
                 context,
                 &input_type,
-                &expected_type,
+                expected_type,
                 0,
                 expression,
                 construct_kind,
@@ -139,7 +140,7 @@ pub fn analyze_construct_inputs<'ctx, 'arena>(
                 verify_construct_input_type(
                     context,
                     &input_type,
-                    &expected_type,
+                    expected_type,
                     index,
                     expression,
                     construct_kind,

crates/analyzer/src/common/global.rs

@@ -12,8 +12,17 @@ use mago_codex::ttype::atomic::array::list::TList;
 use mago_codex::ttype::atomic::scalar::TScalar;
 use mago_codex::ttype::atomic::scalar::int::TInteger;
 use mago_codex::ttype::atomic::scalar::string::TString;
+use mago_codex::ttype::get_bool;
+use mago_codex::ttype::get_float;
+use mago_codex::ttype::get_int_range;
+use mago_codex::ttype::get_mixed;
+use mago_codex::ttype::get_non_empty_string;
+use mago_codex::ttype::get_non_negative_int;
+use mago_codex::ttype::get_one_int;
+use mago_codex::ttype::get_positive_int;
+use mago_codex::ttype::get_string;
+use mago_codex::ttype::get_truthy_string;
 use mago_codex::ttype::union::TUnion;
-use mago_codex::ttype::*;
 
 std::thread_local! {
     static SUPERGLOBALS_MAP: LazyLock<HashMap<&'static str, Rc<TUnion>>> = LazyLock::new(|| {
@@ -98,7 +107,7 @@ std::thread_local! {
             // This value (1764191486) was chosen at the time of implementation and has no special meaning.
             // Using a dynamic timestamp would cause baseline matching to fail since error messages
             // include the type, and the type would change on every run.
-            const REQUEST_TIME_MIN: i64 = 1764191486;
+            const REQUEST_TIME_MIN: i64 = 1_764_191_486;
 
             let mut known_items = BTreeMap::new();
             // Standard CGI/1.1 and PHP variables

crates/analyzer/src/common/synthetic.rs

@@ -3,8 +3,22 @@ use bumpalo::vec;
 
 use mago_span::HasSpan;
 use mago_span::Span;
+use mago_syntax::ast::Argument;
+use mago_syntax::ast::ArgumentList;
+use mago_syntax::ast::Binary;
+use mago_syntax::ast::BinaryOperator;
+use mago_syntax::ast::Call;
+use mago_syntax::ast::DirectVariable;
+use mago_syntax::ast::Expression;
+use mago_syntax::ast::FunctionCall;
+use mago_syntax::ast::Literal;
+use mago_syntax::ast::LiteralString;
+use mago_syntax::ast::LiteralStringKind;
+use mago_syntax::ast::PositionalArgument;
+use mago_syntax::ast::UnaryPrefix;
+use mago_syntax::ast::UnaryPrefixOperator;
+use mago_syntax::ast::Variable;
 use mago_syntax::ast::sequence::TokenSeparatedSequence;
-use mago_syntax::ast::*;
 
 pub fn new_synthetic_call<'arena>(arena: &'arena Bump, f: &str, expression: Expression<'arena>) -> Expression<'arena> {
     Expression::Call(Call::Function(FunctionCall {

crates/analyzer/src/context/block.rs

@@ -315,7 +315,7 @@ impl<'ctx> BlockContext<'ctx> {
 
             for key in c.possibilities.keys() {
                 for changed_var_id in changed_var_ids {
-                    if changed_var_id == key || var_has_root(key, changed_var_id) {
+                    if changed_var_id == key || var_has_root(*key, *changed_var_id) {
                         rejected_clauses.push(c.clone());
                         continue 'outer;
                     }
@@ -353,7 +353,7 @@ impl<'ctx> BlockContext<'ctx> {
 
     pub(crate) fn filter_clauses<'arena>(
         context: &mut Context<'ctx, 'arena>,
-        remove_var_id: &Atom,
+        remove_var_id: Atom,
         clauses: Vec<Rc<Clause>>,
         new_type: Option<&TUnion>,
     ) -> Vec<Rc<Clause>> {
@@ -362,7 +362,7 @@ impl<'ctx> BlockContext<'ctx> {
 
         'outer: for clause in clauses {
             for var_id in clause.possibilities.keys() {
-                if var_has_root(var_id, remove_var_id) {
+                if var_has_root(*var_id, remove_var_id) {
                     continue 'outer;
                 }
             }
@@ -381,7 +381,7 @@ impl<'ctx> BlockContext<'ctx> {
         {
             for clause in other_clauses {
                 let mut type_changed = false;
-                let Some(possibilities) = clause.possibilities.get(remove_var_id) else {
+                let Some(possibilities) = clause.possibilities.get(&remove_var_id) else {
                     clauses_to_keep.push(clause.clone());
 
                     continue;
@@ -422,18 +422,18 @@ impl<'ctx> BlockContext<'ctx> {
     pub(crate) fn remove_variable_from_conflicting_clauses<'arena>(
         &mut self,
         context: &mut Context<'ctx, 'arena>,
-        remove_var_id: &Atom,
+        remove_var_id: Atom,
         new_type: Option<&TUnion>,
     ) {
         self.clauses = BlockContext::filter_clauses(context, remove_var_id, self.clauses.clone(), new_type);
 
-        self.parent_conflicting_clause_variables.insert(*remove_var_id);
+        self.parent_conflicting_clause_variables.insert(remove_var_id);
     }
 
     pub(crate) fn remove_descendants<'arena>(
         &mut self,
         context: &mut Context<'ctx, 'arena>,
-        remove_var_id: &Atom,
+        remove_var_id: Atom,
         existing_type: &TUnion,
         new_type: Option<&TUnion>,
     ) {
@@ -452,7 +452,7 @@ impl<'ctx> BlockContext<'ctx> {
         let keys = self.locals.keys().copied().collect::<Vec<_>>();
 
         for var_id in keys {
-            if var_has_root(&var_id, remove_var_id) {
+            if var_has_root(var_id, remove_var_id) {
                 self.locals.remove(&var_id);
             }
         }
@@ -505,7 +505,7 @@ impl<'ctx> BlockContext<'ctx> {
         if let Some(existing_type) = self.locals.remove(&var_atom)
             && remove_descendants
         {
-            self.remove_descendants(context, &var_atom, &existing_type, None);
+            self.remove_descendants(context, var_atom, &existing_type, None);
         }
 
         self.assigned_variable_ids.remove(&var_atom);
@@ -565,7 +565,7 @@ impl<'ctx> BlockContext<'ctx> {
         start_block_context: &Self,
         end_block_context: &mut Self,
         has_leaving_statements: bool,
-        vars_to_update: AtomSet,
+        vars_to_update: &AtomSet,
         updated_vars: &mut AtomSet,
     ) {
         for (variable_id, old_type) in &start_block_context.locals {
@@ -709,8 +709,8 @@ pub fn subtract_union_types(context: &mut Context<'_, '_>, existing_type: TUnion
     result
 }
 
-fn should_keep_clause(clause: &Rc<Clause>, remove_var_id: &Atom, new_type: Option<&TUnion>) -> bool {
-    if let Some(possibilities) = clause.possibilities.get(remove_var_id) {
+fn should_keep_clause(clause: &Rc<Clause>, remove_var_id: Atom, new_type: Option<&TUnion>) -> bool {
+    if let Some(possibilities) = clause.possibilities.get(&remove_var_id) {
         if possibilities.len() == 1
             && let Some((_, Assertion::IsType(assertion_type))) = possibilities.first()
             && let Some(new_type) = new_type