refactor: auto-fix clippy warnings

16 files changed, 468 insertions, 499 deletions

diff --git a/crates/shirabe/src/dependency_resolver/default_policy.rs b/crates/shirabe/src/dependency_resolver/default_policy.rs
index 541ec44..885ff17 100644
--- a/crates/shirabe/src/dependency_resolver/default_policy.rs
+++ b/crates/shirabe/src/dependency_resolver/default_policy.rs
@@ -68,14 +68,14 @@ impl DefaultPolicy {
                 return -1;
             }
 
-            if let Some(ref required_package) = required_package {
-                if let Some(pos) = required_package.find('/') {
-                    let required_vendor = &required_package[..pos];
-                    let a_is_same_vendor = a.get_name().starts_with(required_vendor);
-                    let b_is_same_vendor = b.get_name().starts_with(required_vendor);
-                    if b_is_same_vendor != a_is_same_vendor {
-                        return if a_is_same_vendor { -1 } else { 1 };
-                    }
+            if let Some(ref required_package) = required_package
+                && let Some(pos) = required_package.find('/')
+            {
+                let required_vendor = &required_package[..pos];
+                let a_is_same_vendor = a.get_name().starts_with(required_vendor);
+                let b_is_same_vendor = b.get_name().starts_with(required_vendor);
+                if b_is_same_vendor != a_is_same_vendor {
+                    return if a_is_same_vendor { -1 } else { 1 };
                 }
             }
         }
@@ -140,11 +140,11 @@ impl DefaultPolicy {
 
         for &literal in &literals {
             let package = pool.literal_to_package(literal);
-            if let Some(alias_pkg) = package.as_alias() {
-                if alias_pkg.is_root_package_alias() {
-                    has_local_alias = true;
-                    break;
-                }
+            if let Some(alias_pkg) = package.as_alias()
+                && alias_pkg.is_root_package_alias()
+            {
+                has_local_alias = true;
+                break;
             }
         }
 
@@ -155,10 +155,10 @@ impl DefaultPolicy {
         let mut selected = vec![];
         for &literal in &literals {
             let package = pool.literal_to_package(literal);
-            if let Some(alias_pkg) = package.as_alias() {
-                if alias_pkg.is_root_package_alias() {
-                    selected.push(literal);
-                }
+            if let Some(alias_pkg) = package.as_alias()
+                && alias_pkg.is_root_package_alias()
+            {
+                selected.push(literal);
             }
         }
         selected
@@ -235,10 +235,10 @@ impl PolicyInterface for DefaultPolicy {
 
         {
             let cache = self.preferred_package_result_cache_per_pool.borrow();
-            if let Some(pool_cache) = cache.get(&pool_id) {
-                if let Some(cached) = pool_cache.get(&result_cache_key) {
-                    return cached.clone();
-                }
+            if let Some(pool_cache) = cache.get(&pool_id)
+                && let Some(cached) = pool_cache.get(&result_cache_key)
+            {
+                return cached.clone();
             }
         }
 
@@ -250,10 +250,10 @@ impl PolicyInterface for DefaultPolicy {
                     format!("i{}.{}{}", a, b, required_package.as_deref().unwrap_or(""));
                 {
                     let cache = self.sorting_cache_per_pool.borrow();
-                    if let Some(pool_cache) = cache.get(&pool_id) {
-                        if let Some(&result) = pool_cache.get(&cache_key) {
-                            return result.cmp(&0);
-                        }
+                    if let Some(pool_cache) = cache.get(&pool_id)
+                        && let Some(&result) = pool_cache.get(&cache_key)
+                    {
+                        return result.cmp(&0);
                     }
                 }
                 let result = self.compare_by_priority(
@@ -283,10 +283,10 @@ impl PolicyInterface for DefaultPolicy {
             let cache_key = format!("{}.{}{}", a, b, required_package.as_deref().unwrap_or(""));
             {
                 let cache = self.sorting_cache_per_pool.borrow();
-                if let Some(pool_cache) = cache.get(&pool_id) {
-                    if let Some(&result) = pool_cache.get(&cache_key) {
-                        return result.cmp(&0);
-                    }
+                if let Some(pool_cache) = cache.get(&pool_id)
+                    && let Some(&result) = pool_cache.get(&cache_key)
+                {
+                    return result.cmp(&0);
                 }
             }
             let result = self.compare_by_priority(
diff --git a/crates/shirabe/src/dependency_resolver/lock_transaction.rs b/crates/shirabe/src/dependency_resolver/lock_transaction.rs
index 30706f5..3cabdcd 100644
--- a/crates/shirabe/src/dependency_resolver/lock_transaction.rs
+++ b/crates/shirabe/src/dependency_resolver/lock_transaction.rs
@@ -37,7 +37,7 @@ impl LockTransaction {
         let all: Vec<PackageInterfaceHandle> = this
             .result_packages
             .get("all")
-            .map(|v| v.iter().cloned().collect())
+            .map(|v| v.to_vec())
             .unwrap_or_default();
         let present: Vec<PackageInterfaceHandle> = this.present_map.values().cloned().collect();
         this.inner = Transaction::new(present, all);
@@ -59,12 +59,12 @@ impl LockTransaction {
                 result_packages
                     .get_mut("all")
                     .unwrap()
-                    .push(package.clone().into());
+                    .push(package.clone());
                 if !self.unlockable_map.contains_key(&package.get_id()) {
                     result_packages
                         .get_mut("non-dev")
                         .unwrap()
-                        .push(package.clone().into());
+                        .push(package.clone());
                 }
             }
         }
diff --git a/crates/shirabe/src/dependency_resolver/pool.rs b/crates/shirabe/src/dependency_resolver/pool.rs
index b12d760..7b60002 100644
--- a/crates/shirabe/src/dependency_resolver/pool.rs
+++ b/crates/shirabe/src/dependency_resolver/pool.rs
@@ -120,12 +120,12 @@ impl Pool {
             .get(package_name)
             .unwrap_or(&empty);
         for (version, _package_with_security_advisories) in versions {
-            if let Some(c) = constraint {
-                if c.matches(
+            if let Some(c) = constraint
+                && c.matches(
                     &SimpleConstraint::new("==".to_string(), version.to_string(), None).into(),
-                ) {
-                    return true;
-                }
+                )
+            {
+                return true;
             }
         }
 
@@ -144,15 +144,15 @@ impl Pool {
             .get(package_name)
             .unwrap_or(&empty);
         for (version, package_with_security_advisories) in versions {
-            if let Some(c) = constraint {
-                if c.matches(
+            if let Some(c) = constraint
+                && c.matches(
                     &SimpleConstraint::new("==".to_string(), version.to_string(), None).into(),
-                ) {
-                    return package_with_security_advisories
-                        .iter()
-                        .map(|advisory| advisory.advisory_id().to_string())
-                        .collect();
-                }
+                )
+            {
+                return package_with_security_advisories
+                    .iter()
+                    .map(|advisory| advisory.advisory_id().to_string())
+                    .collect();
             }
         }
 
@@ -170,12 +170,12 @@ impl Pool {
             .get(package_name)
             .unwrap_or(&empty);
         for (version, _pretty_version) in versions {
-            if let Some(c) = constraint {
-                if c.matches(
+            if let Some(c) = constraint
+                && c.matches(
                     &SimpleConstraint::new("==".to_string(), version.to_string(), None).into(),
-                ) {
-                    return true;
-                }
+                )
+            {
+                return true;
             }
         }
 
@@ -207,7 +207,7 @@ impl Pool {
             for provided in package.get_names(true) {
                 self.package_by_name
                     .entry(provided)
-                    .or_insert_with(Vec::new)
+                    .or_default()
                     .push(package.clone());
             }
 
@@ -241,16 +241,16 @@ impl Pool {
             Some(c) => c.to_string(),
             None => String::new(),
         };
-        if let Some(by_key) = self.provider_cache.get(name) {
-            if let Some(cached) = by_key.get(&key) {
-                return cached.clone();
-            }
+        if let Some(by_key) = self.provider_cache.get(name)
+            && let Some(cached) = by_key.get(&key)
+        {
+            return cached.clone();
         }
 
         let computed = self.compute_what_provides(name, constraint);
         self.provider_cache
             .entry(name.to_string())
-            .or_insert_with(IndexMap::new)
+            .or_default()
             .insert(key, computed.clone());
         computed
     }
@@ -352,16 +352,16 @@ impl Pool {
             return false;
         }
 
-        if let Some(provide) = provides.get(name) {
-            if constraint.is_none() || constraint.unwrap().matches(provide.get_constraint()) {
-                return true;
-            }
+        if let Some(provide) = provides.get(name)
+            && (constraint.is_none() || constraint.unwrap().matches(provide.get_constraint()))
+        {
+            return true;
         }
 
-        if let Some(replace) = replaces.get(name) {
-            if constraint.is_none() || constraint.unwrap().matches(replace.get_constraint()) {
-                return true;
-            }
+        if let Some(replace) = replaces.get(name)
+            && (constraint.is_none() || constraint.unwrap().matches(replace.get_constraint()))
+        {
+            return true;
         }
 
         false
diff --git a/crates/shirabe/src/dependency_resolver/pool_builder.rs b/crates/shirabe/src/dependency_resolver/pool_builder.rs
index 9589276..9b4c561 100644
--- a/crates/shirabe/src/dependency_resolver/pool_builder.rs
+++ b/crates/shirabe/src/dependency_resolver/pool_builder.rs
@@ -83,6 +83,7 @@ pub struct PoolBuilder {
 impl PoolBuilder {
     const LOAD_BATCH_SIZE: i64 = 50;
 
+    #[allow(clippy::too_many_arguments, reason = "to keep PHP signature")]
     pub fn new(
         acceptable_stabilities: IndexMap<String, i64>,
         stability_flags: IndexMap<String, i64>,
@@ -148,7 +149,7 @@ impl PoolBuilder {
             None
         };
 
-        if request.get_update_allow_list().len() > 0 {
+        if !request.get_update_allow_list().is_empty() {
             self.update_allow_list = request.get_update_allow_list().clone();
             self.warn_about_non_matching_update_allow_list(request)?;
 
@@ -185,7 +186,7 @@ impl PoolBuilder {
                         }
                     }
 
-                    request.lock_package(locked_package.into());
+                    request.lock_package(locked_package);
                 }
             }
         }
@@ -209,9 +210,9 @@ impl PoolBuilder {
             // TODO in how far can we do the above for conflicts? It's more tricky cause conflicts can be limited to
             // specific versions while replace is a conflict with all versions of the name
 
-            let in_root_or_platform = package.get_repository().map_or(false, |r| {
-                r.is::<RootPackageRepository>() || r.is::<PlatformRepository>()
-            });
+            let in_root_or_platform = package
+                .get_repository()
+                .is_some_and(|r| r.is::<RootPackageRepository>() || r.is::<PlatformRepository>());
             if in_root_or_platform
                 || StabilityFilter::is_package_acceptable(
                     &self.acceptable_stabilities,
@@ -248,11 +249,11 @@ impl PoolBuilder {
             self.packages_to_load.shift_remove(&name);
         }
 
-        while self.packages_to_load.len() > 0 {
+        while !self.packages_to_load.is_empty() {
             self.load_packages_marked_for_loading(request, &repositories)?;
         }
 
-        if self.temporary_constraints.len() > 0 {
+        if !self.temporary_constraints.is_empty() {
             let indices: Vec<i64> = self.packages.keys().cloned().collect();
             for i in indices {
                 let package = match self.packages.get(&i) {
@@ -298,7 +299,7 @@ impl PoolBuilder {
             }
         }
 
-        if self.event_dispatcher.is_some() {
+        if let Some(event_dispatcher) = &self.event_dispatcher {
             // TODO(plugin): PrePoolCreateEvent::new takes Request and Vec<Box<dyn RepositoryInterface>>
             // by value but neither can be cloned (PHP class shared semantics). This event is purely
             // plugin-facing and nothing in the no-plugin path reads it back, so it stays deferred
@@ -312,20 +313,13 @@ impl PoolBuilder {
                 self.root_aliases.clone(),
                 self.root_references.clone(),
                 self.packages.values().cloned().collect(),
-                self.unacceptable_fixed_or_locked_packages
-                    .iter()
-                    .cloned()
-                    .collect(),
+                self.unacceptable_fixed_or_locked_packages.to_vec(),
             );
             let pre_pool_create_event_name = pre_pool_create_event.get_name().to_string();
-            self.event_dispatcher
-                .as_ref()
-                .unwrap()
-                .borrow_mut()
-                .dispatch(
-                    Some(&pre_pool_create_event_name),
-                    Some(&mut pre_pool_create_event),
-                )?;
+            event_dispatcher.borrow_mut().dispatch(
+                Some(&pre_pool_create_event_name),
+                Some(&mut pre_pool_create_event),
+            )?;
             // PHP rebinds $this->packages to a list-style array; preserve indices via reindexing.
             // TODO(plugin)/TODO(phase-c): rebind self.packages from the (handle-based) event packages
             // once EventDispatcher::dispatch returns the mutated event.
@@ -334,10 +328,7 @@ impl PoolBuilder {
 
         let mut pool = Pool::new(
             self.packages.values().cloned().collect(),
-            self.unacceptable_fixed_or_locked_packages
-                .iter()
-                .cloned()
-                .collect(),
+            self.unacceptable_fixed_or_locked_packages.to_vec(),
             IndexMap::new(),
             IndexMap::new(),
             IndexMap::new(),
@@ -390,10 +381,10 @@ impl PoolBuilder {
         // we make sure that we load at most the intervals covered by the root constraint.
         let root_requires = request.get_requires();
         let mut constraint = constraint;
-        if let Some(root_constraint) = root_requires.get(name) {
-            if !Intervals::is_subset_of(&constraint, root_constraint).unwrap_or(false) {
-                constraint = root_constraint.clone();
-            }
+        if let Some(root_constraint) = root_requires.get(name)
+            && !Intervals::is_subset_of(&constraint, root_constraint).unwrap_or(false)
+        {
+            constraint = root_constraint.clone();
         }
 
         // Not yet loaded or already marked for a reload, set the constraint to be loaded
@@ -499,12 +490,12 @@ impl PoolBuilder {
             // never need to load anything else from them
             let is_locked_repo = request
                 .get_locked_repository()
-                .map_or(false, |h| repository.ptr_eq(&h.into()));
+                .is_some_and(|h| repository.ptr_eq(&h.into()));
             if repository.is::<PlatformRepository>() || is_locked_repo {
                 continue;
             }
 
-            if 0 == package_batches.len() {
+            if package_batches.is_empty() {
                 break;
             }
 
@@ -620,7 +611,7 @@ impl PoolBuilder {
         if let Some(alias) = package.as_alias() {
             self.alias_map
                 .entry(alias.get_alias_of().ptr_id().to_string())
-                .or_insert_with(IndexMap::new)
+                .or_default()
                 .insert(index, alias);
         }
 
@@ -649,8 +640,9 @@ impl PoolBuilder {
             .get(&name)
             .and_then(|m| m.get(&package.get_version()))
             .cloned();
-        if (propagate_update || path_repo_match) && alias_for_version.is_some() {
-            let alias = alias_for_version.unwrap();
+        if (propagate_update || path_repo_match)
+            && let Some(alias) = alias_for_version
+        {
             let base_package: BasePackageHandle = if let Some(ap) = package.as_alias() {
                 ap.get_alias_of().into()
             } else {
@@ -674,7 +666,7 @@ impl PoolBuilder {
             self.packages.insert(new_index, alias_handle.clone().into());
             self.alias_map
                 .entry(alias_handle.get_alias_of().ptr_id().to_string())
-                .or_insert_with(IndexMap::new)
+                .or_default()
                 .insert(new_index, alias_handle);
         }
 
@@ -692,7 +684,7 @@ impl PoolBuilder {
                     let skipped_root_requires = self.get_skipped_root_requires(request, &require);
 
                     if request.get_update_allow_transitive_root_dependencies()
-                        || 0 == skipped_root_requires.len()
+                        || skipped_root_requires.is_empty()
                     {
                         self.unlock_package(request, repositories, &require)?;
                         self.mark_package_name_for_loading(request, &require, link_constraint);
@@ -727,7 +719,7 @@ impl PoolBuilder {
                     let skipped_root_requires = self.get_skipped_root_requires(request, &replace);
 
                     if request.get_update_allow_transitive_root_dependencies()
-                        || 0 == skipped_root_requires.len()
+                        || skipped_root_requires.is_empty()
                     {
                         self.unlock_package(request, repositories, &replace)?;
                         // the replaced package only needs to be loaded if something else requires it
@@ -875,7 +867,7 @@ impl PoolBuilder {
         let skipped: Vec<PackageInterfaceHandle> = self
             .skipped_load
             .get(name)
-            .map(|v| v.iter().cloned().collect())
+            .map(|v| v.to_vec())
             .unwrap_or_default();
         for package_or_replacer in &skipped {
             // if we unfixed a replaced package name, we also need to unfix the replacer itself
@@ -1026,7 +1018,7 @@ impl PoolBuilder {
     fn remove_loaded_package(
         &mut self,
         _request: &Request,
-        repositories: &Vec<RepositoryInterfaceHandle>,
+        repositories: &[RepositoryInterfaceHandle],
         package: BasePackageHandle,
         index: i64,
     ) {
@@ -1040,23 +1032,21 @@ impl PoolBuilder {
             })
             .unwrap_or(-1);
 
-        if repo_index >= 0 {
-            if let Some(repo_map) = self.loaded_per_repo.get_mut(&repo_index) {
-                if let Some(name_map) = repo_map.get_mut(&package.get_name()) {
-                    name_map.shift_remove(&package.get_version());
-                }
-            }
+        if repo_index >= 0
+            && let Some(repo_map) = self.loaded_per_repo.get_mut(&repo_index)
+            && let Some(name_map) = repo_map.get_mut(&package.get_name())
+        {
+            name_map.shift_remove(&package.get_version());
         }
         self.packages.shift_remove(&index);
         let object_hash = package.ptr_id().to_string();
         if let Some(aliases) = self.alias_map.shift_remove(&object_hash) {
             for (alias_index, alias_package) in &aliases {
-                if repo_index >= 0 {
-                    if let Some(repo_map) = self.loaded_per_repo.get_mut(&repo_index) {
-                        if let Some(name_map) = repo_map.get_mut(&alias_package.get_name()) {
-                            name_map.shift_remove(&alias_package.get_version());
-                        }
-                    }
+                if repo_index >= 0
+                    && let Some(repo_map) = self.loaded_per_repo.get_mut(&repo_index)
+                    && let Some(name_map) = repo_map.get_mut(&alias_package.get_name())
+                {
+                    name_map.shift_remove(&alias_package.get_version());
                 }
                 self.packages.shift_remove(alias_index);
             }
@@ -1110,7 +1100,7 @@ impl PoolBuilder {
     fn run_security_advisory_filter(
         &mut self,
         pool: Pool,
-        repositories: &Vec<RepositoryInterfaceHandle>,
+        repositories: &[RepositoryInterfaceHandle],
         request: &Request,
     ) -> anyhow::Result<Pool> {
         if self.security_advisory_pool_filter.is_none() {
@@ -1122,7 +1112,7 @@ impl PoolBuilder {
         let before = microtime(true);
         let total = pool.get_packages().len() as f64;
 
-        let repos_owned: Vec<RepositoryInterfaceHandle> = repositories.iter().cloned().collect();
+        let repos_owned: Vec<RepositoryInterfaceHandle> = repositories.to_vec();
         let pool = self
             .security_advisory_pool_filter
             .as_mut()
diff --git a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
index 54ec993..2632dc8 100644
--- a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
+++ b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
@@ -93,7 +93,7 @@ impl PoolOptimizer {
         for (_, package) in request.get_fixed_or_locked_packages() {
             irremovable_package_constraint_groups
                 .entry(package.get_name())
-                .or_insert_with(Vec::new)
+                .or_default()
                 .push(
                     SimpleConstraint::new(
                         "==".to_string(),
@@ -131,7 +131,7 @@ impl PoolOptimizer {
             if let Some(alias_pkg) = package.as_alias() {
                 self.aliases_per_package
                     .entry(alias_pkg.get_alias_of().id())
-                    .or_insert_with(Vec::new)
+                    .or_default()
                     .push(package.clone());
             }
         }
@@ -197,7 +197,7 @@ impl PoolOptimizer {
             } else {
                 removed_versions
                     .entry(package.get_name())
-                    .or_insert_with(IndexMap::new)
+                    .or_default()
                     .insert(
                         package.get_version().to_string(),
                         package.get_pretty_version().to_string(),
@@ -261,7 +261,7 @@ impl PoolOptimizer {
                         ));
                     }
 
-                    if package.get_replaces().len() > 0 {
+                    if !package.get_replaces().is_empty() {
                         for (_, link) in package.get_replaces() {
                             if CompilingMatcher::r#match(
                                 link.get_constraint(),
@@ -294,22 +294,22 @@ impl PoolOptimizer {
                         }
                     }
 
-                    if 0 == group_hash_parts.len() {
+                    if group_hash_parts.is_empty() {
                         continue;
                     }
 
                     let group_hash = implode("", &group_hash_parts);
                     identical_definitions_per_package
                         .entry(package_name.clone())
-                        .or_insert_with(IndexMap::new)
+                        .or_default()
                         .entry(group_hash.clone())
-                        .or_insert_with(IndexMap::new)
+                        .or_default()
                         .entry(dependency_hash.clone())
-                        .or_insert_with(Vec::new)
+                        .or_default()
                         .push(package.clone());
                     package_identical_definition_lookup
                         .entry(package.id())
-                        .or_insert_with(IndexMap::new)
+                        .or_default()
                         .insert(
                             package_name.clone(),
                             IdenticalDefinitionPointers {
@@ -382,7 +382,7 @@ impl PoolOptimizer {
         ];
 
         for (key, links) in hash_relevant_links {
-            if 0 == links.len() {
+            if links.is_empty() {
                 continue;
             }
 
@@ -457,33 +457,32 @@ impl PoolOptimizer {
 
         // record all the versions of the package group so we can list them later in Problem output
         for name in package.get_names(false) {
-            if let Some(per_name) = package_identical_definition_lookup.get(&package.id()) {
-                if let Some(package_group_pointers) = per_name.get(&name) {
-                    let package_group = identical_definitions_per_package
-                        .get(&name)
-                        .and_then(|m| m.get(&package_group_pointers.group_hash))
-                        .and_then(|m| m.get(&package_group_pointers.dependency_hash));
-                    if let Some(package_group) = package_group {
-                        for pkg in package_group {
-                            let pkg: BasePackageHandle = if let Some(alias_pkg) = pkg.as_alias() {
-                                if alias_pkg.get_pretty_version()
-                                    == VersionParser::DEFAULT_BRANCH_ALIAS
-                                {
-                                    alias_pkg.get_alias_of().into()
-                                } else {
-                                    pkg.clone()
-                                }
+            if let Some(per_name) = package_identical_definition_lookup.get(&package.id())
+                && let Some(package_group_pointers) = per_name.get(&name)
+            {
+                let package_group = identical_definitions_per_package
+                    .get(&name)
+                    .and_then(|m| m.get(&package_group_pointers.group_hash))
+                    .and_then(|m| m.get(&package_group_pointers.dependency_hash));
+                if let Some(package_group) = package_group {
+                    for pkg in package_group {
+                        let pkg: BasePackageHandle = if let Some(alias_pkg) = pkg.as_alias() {
+                            if alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS
+                            {
+                                alias_pkg.get_alias_of().into()
                             } else {
                                 pkg.clone()
-                            };
-                            self.removed_versions_by_package
-                                .entry(package.ptr_id().to_string())
-                                .or_insert_with(IndexMap::new)
-                                .insert(
-                                    pkg.get_version().to_string(),
-                                    pkg.get_pretty_version().to_string(),
-                                );
-                        }
+                            }
+                        } else {
+                            pkg.clone()
+                        };
+                        self.removed_versions_by_package
+                            .entry(package.ptr_id().to_string())
+                            .or_default()
+                            .insert(
+                                pkg.get_version().to_string(),
+                                pkg.get_pretty_version().to_string(),
+                            );
                     }
                 }
             }
@@ -504,34 +503,33 @@ impl PoolOptimizer {
 
             // record all the versions of the package group so we can list them later in Problem output
             for name in alias_names {
-                if let Some(per_name) = package_identical_definition_lookup.get(&alias_id) {
-                    if let Some(package_group_pointers) = per_name.get(&name) {
-                        let package_group = identical_definitions_per_package
-                            .get(&name)
-                            .and_then(|m| m.get(&package_group_pointers.group_hash))
-                            .and_then(|m| m.get(&package_group_pointers.dependency_hash));
-                        if let Some(package_group) = package_group {
-                            for pkg in package_group {
-                                let pkg: BasePackageHandle = if let Some(alias_pkg) = pkg.as_alias()
+                if let Some(per_name) = package_identical_definition_lookup.get(&alias_id)
+                    && let Some(package_group_pointers) = per_name.get(&name)
+                {
+                    let package_group = identical_definitions_per_package
+                        .get(&name)
+                        .and_then(|m| m.get(&package_group_pointers.group_hash))
+                        .and_then(|m| m.get(&package_group_pointers.dependency_hash));
+                    if let Some(package_group) = package_group {
+                        for pkg in package_group {
+                            let pkg: BasePackageHandle = if let Some(alias_pkg) = pkg.as_alias() {
+                                if alias_pkg.get_pretty_version()
+                                    == VersionParser::DEFAULT_BRANCH_ALIAS
                                 {
-                                    if alias_pkg.get_pretty_version()
-                                        == VersionParser::DEFAULT_BRANCH_ALIAS
-                                    {
-                                        alias_pkg.get_alias_of().into()
-                                    } else {
-                                        pkg.clone()
-                                    }
+                                    alias_pkg.get_alias_of().into()
                                 } else {
                                     pkg.clone()
-                                };
-                                self.removed_versions_by_package
-                                    .entry(format!("alias-{}", alias_id))
-                                    .or_insert_with(IndexMap::new)
-                                    .insert(
-                                        pkg.get_version().to_string(),
-                                        pkg.get_pretty_version().to_string(),
-                                    );
-                            }
+                                }
+                            } else {
+                                pkg.clone()
+                            };
+                            self.removed_versions_by_package
+                                .entry(format!("alias-{}", alias_id))
+                                .or_default()
+                                .insert(
+                                    pkg.get_version().to_string(),
+                                    pkg.get_pretty_version().to_string(),
+                                );
                         }
                     }
                 }
@@ -543,7 +541,7 @@ impl PoolOptimizer {
     /// This will reduce packages with significant numbers of historical versions to a smaller number
     /// and reduce the resulting rule set that is generated
     fn optimize_impossible_packages_away(&mut self, request: &Request, pool: &Pool) {
-        if request.get_locked_packages().len() == 0 {
+        if request.get_locked_packages().is_empty() {
             return;
         }
 
@@ -569,7 +567,7 @@ impl PoolOptimizer {
 
             package_index
                 .entry(package.get_name())
-                .or_insert_with(IndexMap::new)
+                .or_default()
                 .insert(package.id(), package.clone());
         }
 
@@ -607,18 +605,16 @@ impl PoolOptimizer {
                         .get(require)
                         .and_then(|m| m.get(&id))
                         .map(|p| p.get_version().to_string());
-                    if let Some(version_str) = version_str {
-                        if false
-                            == CompilingMatcher::r#match(
-                                link_constraint,
-                                SimpleConstraint::OP_EQ,
-                                version_str,
-                            )
-                        {
-                            self.mark_package_for_removal(id);
-                            if let Some(map) = package_index.get_mut(require) {
-                                map.shift_remove(&id);
-                            }
+                    if let Some(version_str) = version_str
+                        && !CompilingMatcher::r#match(
+                            link_constraint,
+                            SimpleConstraint::OP_EQ,
+                            version_str,
+                        )
+                    {
+                        self.mark_package_for_removal(id);
+                        if let Some(map) = package_index.get_mut(require) {
+                            map.shift_remove(&id);
                         }
                     }
                 }
@@ -639,7 +635,7 @@ impl PoolOptimizer {
         for expanded in self.expand_disjunctive_multi_constraints(constraint) {
             self.require_constraints_per_package
                 .entry(package.to_string())
-                .or_insert_with(IndexMap::new)
+                .or_default()
                 .insert(expanded.to_string(), expanded);
         }
     }
@@ -657,7 +653,7 @@ impl PoolOptimizer {
         for expanded in self.expand_disjunctive_multi_constraints(constraint) {
             self.conflict_constraints_per_package
                 .entry(package.to_string())
-                .or_insert_with(IndexMap::new)
+                .or_default()
                 .insert(expanded.to_string(), expanded);
         }
     }
@@ -669,12 +665,12 @@ impl PoolOptimizer {
     ) -> Vec<AnyConstraint> {
         let constraint = Intervals::compact_constraint(&constraint).unwrap_or(constraint);
 
-        if let Some(multi) = constraint.as_multi_constraint() {
-            if multi.is_disjunctive_mc() {
-                // No need to call ourselves recursively here because Intervals::compactConstraint() ensures that there
-                // are no nested disjunctive MultiConstraint instances possible
-                return multi.get_constraints().iter().map(|c| c.clone()).collect();
-            }
+        if let Some(multi) = constraint.as_multi_constraint()
+            && multi.is_disjunctive_mc()
+        {
+            // No need to call ourselves recursively here because Intervals::compactConstraint() ensures that there
+            // are no nested disjunctive MultiConstraint instances possible
+            return multi.get_constraints().to_vec();
         }
 
         // Regular constraints and conjunctive MultiConstraints
diff --git a/crates/shirabe/src/dependency_resolver/problem.rs b/crates/shirabe/src/dependency_resolver/problem.rs
index 93d82be..0075b5e 100644
--- a/crates/shirabe/src/dependency_resolver/problem.rs
+++ b/crates/shirabe/src/dependency_resolver/problem.rs
@@ -41,6 +41,12 @@ pub struct Problem {
     pub(crate) section: i64,
 }
 
+impl Default for Problem {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Problem {
     pub fn new() -> Self {
         Self {
@@ -101,7 +107,7 @@ impl Problem {
             };
 
             let packages = pool.compute_what_provides(&package_name, constraint);
-            if packages.len() == 0 {
+            if packages.is_empty() {
                 let missing = Self::get_missing_package_reason(
                     repository_set,
                     request,
@@ -193,7 +199,7 @@ impl Problem {
         }
     }
 
-    /// @internal
+    #[allow(clippy::too_many_arguments, reason = "to keep PHP signature")]
     pub fn format_deduplicated_rules(
         rules: &Vec<std::rc::Rc<std::cell::RefCell<Rule>>>,
         indent: &str,
@@ -208,8 +214,7 @@ impl Problem {
         let mut templates: IndexMap<String, IndexMap<String, IndexMap<String, String>>> =
             IndexMap::new();
         let parser = VersionParser::new();
-        let deduplicatable_rule_types =
-            vec![rule::RULE_PACKAGE_REQUIRES, rule::RULE_PACKAGE_CONFLICT];
+        let deduplicatable_rule_types = [rule::RULE_PACKAGE_REQUIRES, rule::RULE_PACKAGE_CONFLICT];
         for rule in rules {
             let rule_ref = rule.borrow();
             let mut message = rule_ref.get_pretty_string(
@@ -248,9 +253,9 @@ impl Problem {
                 let version_key = parser.normalize(&m2, Some("")).unwrap_or_default();
                 templates
                     .entry(template.clone())
-                    .or_insert_with(IndexMap::new)
+                    .or_default()
                     .entry(pkg_key.clone())
-                    .or_insert_with(IndexMap::new)
+                    .or_default()
                     .insert(version_key, m2.clone());
                 let source_package = rule_ref.get_source_package(pool).unwrap();
                 for (version, pretty_version) in
@@ -263,7 +268,7 @@ impl Problem {
                         .unwrap()
                         .insert(version, pretty_version);
                 }
-            } else if message != "" {
+            } else if !message.is_empty() {
                 messages.push(message);
             }
         }
@@ -367,10 +372,7 @@ impl Problem {
 
         if !self.reason_seen.contains_key(&id) {
             self.reason_seen.insert(id, true);
-            self.reasons
-                .entry(self.section)
-                .or_insert_with(Vec::new)
-                .push(reason);
+            self.reasons.entry(self.section).or_default().push(reason);
         }
     }
 
@@ -403,7 +405,8 @@ impl Problem {
                 );
 
                 if defined("HHVM_VERSION")
-                    || (package_name == "hhvm" && pool.what_provides(package_name, None).len() > 0)
+                    || (package_name == "hhvm"
+                        && !pool.what_provides(package_name, None).is_empty())
                 {
                     return Ok((
                         msg,
@@ -562,64 +565,61 @@ impl Problem {
             }
         }
 
-        if let Some(c) = constraint {
-            if c.is_constraint()
-                && c.get_operator() == SimpleConstraint::STR_OP_EQ
-                && Preg::is_match3(r"{^dev-.*#.*}", &c.get_pretty_string(), None)
-            {
-                let new_constraint =
-                    Preg::replace(r"{ +as +([^,\s|]+)$}", "", &c.get_pretty_string());
-                let packages = repository_set.find_packages(
-                    package_name,
-                    Some(
-                        MultiConstraint::new(
-                            vec![
-                                AnyConstraint::Simple(SimpleConstraint::new(
-                                    SimpleConstraint::STR_OP_EQ.to_string(),
-                                    new_constraint.clone(),
-                                    None,
-                                )),
-                                AnyConstraint::Simple(SimpleConstraint::new(
-                                    SimpleConstraint::STR_OP_EQ.to_string(),
-                                    str_replace("#", "+", &new_constraint),
-                                    None,
-                                )),
-                            ],
-                            false,
-                            None,
-                        )
-                        .into(),
+        if let Some(c) = constraint
+            && c.is_constraint()
+            && c.get_operator() == SimpleConstraint::STR_OP_EQ
+            && Preg::is_match3(r"{^dev-.*#.*}", &c.get_pretty_string(), None)
+        {
+            let new_constraint = Preg::replace(r"{ +as +([^,\s|]+)$}", "", &c.get_pretty_string());
+            let packages = repository_set.find_packages(
+                package_name,
+                Some(
+                    MultiConstraint::new(
+                        vec![
+                            AnyConstraint::Simple(SimpleConstraint::new(
+                                SimpleConstraint::STR_OP_EQ.to_string(),
+                                new_constraint.clone(),
+                                None,
+                            )),
+                            AnyConstraint::Simple(SimpleConstraint::new(
+                                SimpleConstraint::STR_OP_EQ.to_string(),
+                                str_replace("#", "+", &new_constraint),
+                                None,
+                            )),
+                        ],
+                        false,
+                        None,
+                    )
+                    .into(),
+                ),
+                0,
+            )?;
+            if !packages.is_empty() {
+                return Ok((
+                    format!(
+                        "- Root composer.json requires {}{}, ",
+                        package_name,
+                        Self::constraint_to_text(constraint)
                     ),
-                    0,
-                )?;
-                if packages.len() > 0 {
-                    return Ok((
-                        format!(
-                            "- Root composer.json requires {}{}, ",
-                            package_name,
-                            Self::constraint_to_text(constraint)
-                        ),
-                        format!(
-                            "found {}. The # character in branch names is replaced by a + character. Make sure to require it as \"{}\".",
-                            Self::get_package_list(
-                                &packages,
-                                is_verbose,
-                                Some(pool),
-                                constraint,
-                                false
-                            ),
-                            str_replace("#", "+", &c.get_pretty_string())
+                    format!(
+                        "found {}. The # character in branch names is replaced by a + character. Make sure to require it as \"{}\".",
+                        Self::get_package_list(
+                            &packages,
+                            is_verbose,
+                            Some(pool),
+                            constraint,
+                            false
                         ),
-                    ));
-                }
+                        str_replace("#", "+", &c.get_pretty_string())
+                    ),
+                ));
             }
         }
 
         // first check if the actual requested package is found in normal conditions
         // if so it must mean it is rejected by another constraint than the one given here
-        let packages =
-            repository_set.find_packages(package_name, constraint.map(|c| c.clone()), 0)?;
-        if packages.len() > 0 {
+        let packages = repository_set.find_packages(package_name, constraint.cloned(), 0)?;
+        if !packages.is_empty() {
             let root_reqs = repository_set.get_root_requires();
             if root_reqs.contains_key(package_name) {
                 let filtered: Vec<&BasePackageHandle> = packages
@@ -635,7 +635,7 @@ impl Problem {
                         )
                     })
                     .collect();
-                if filtered.len() == 0 {
+                if filtered.is_empty() {
                     return Ok((
                         format!(
                             "- Root composer.json requires {}{}, ",
@@ -679,7 +679,7 @@ impl Problem {
                             )
                         })
                         .collect();
-                    if filtered.len() == 0 {
+                    if filtered.is_empty() {
                         return Ok((
                             format!(
                                 "- Root composer.json requires {}{}, ",
@@ -727,7 +727,7 @@ impl Problem {
                         )
                     })
                     .collect();
-                if filtered.len() == 0 {
+                if filtered.is_empty() {
                     return Ok((
                         format!(
                             "- Root composer.json requires {}{}, ",
@@ -753,11 +753,11 @@ impl Problem {
                 .iter()
                 .filter(|p| {
                     !p.get_repository()
-                        .map_or(false, |r| r.is::<LockArrayRepository>())
+                        .is_some_and(|r| r.is::<LockArrayRepository>())
                 })
                 .collect();
 
-            if non_locked_packages.len() == 0 {
+            if non_locked_packages.is_empty() {
                 return Ok((
                     format!(
                         "- Root composer.json requires {}{}, ",
@@ -863,17 +863,17 @@ impl Problem {
         // check if the package is found when bypassing stability checks
         let packages = repository_set.find_packages(
             package_name,
-            constraint.map(|c| c.clone()),
+            constraint.cloned(),
             RepositorySet::ALLOW_UNACCEPTABLE_STABILITIES,
         )?;
-        if packages.len() > 0 {
+        if !packages.is_empty() {
             // we must first verify if a valid package would be found in a lower priority repository
             let all_repos_packages = repository_set.find_packages(
                 package_name,
-                constraint.map(|c| c.clone()),
+                constraint.cloned(),
                 RepositorySet::ALLOW_SHADOWED_REPOSITORIES,
             )?;
-            if all_repos_packages.len() > 0 {
+            if !all_repos_packages.is_empty() {
                 return Ok(Self::compute_check_for_lower_prio_repo(
                     pool,
                     is_verbose,
@@ -909,14 +909,14 @@ impl Problem {
             None,
             RepositorySet::ALLOW_UNACCEPTABLE_STABILITIES,
         )?;
-        if packages.len() > 0 {
+        if !packages.is_empty() {
             // we must first verify if a valid package would be found in a lower priority repository
             let all_repos_packages = repository_set.find_packages(
                 package_name,
-                constraint.map(|c| c.clone()),
+                constraint.cloned(),
                 RepositorySet::ALLOW_SHADOWED_REPOSITORIES,
             )?;
-            if all_repos_packages.len() > 0 {
+            if !all_repos_packages.is_empty() {
                 return Ok(Self::compute_check_for_lower_prio_repo(
                     pool,
                     is_verbose,
@@ -929,23 +929,24 @@ impl Problem {
             }
 
             let mut suffix = String::new();
-            if let Some(c) = constraint {
-                if c.is_constraint() && c.get_version() == "dev-master" {
-                    for candidate in &packages {
-                        if in_array(
-                            PhpMixed::String(candidate.get_version().to_string()),
-                            &PhpMixed::List(vec![
-                                Box::new(PhpMixed::String("dev-default".to_string())),
-                                Box::new(PhpMixed::String("dev-main".to_string())),
-                            ]),
-                            true,
-                        ) {
-                            suffix = format!(
-                                " Perhaps dev-master was renamed to {}?",
-                                candidate.get_pretty_version()
-                            );
-                            break;
-                        }
+            if let Some(c) = constraint
+                && c.is_constraint()
+                && c.get_version() == "dev-master"
+            {
+                for candidate in &packages {
+                    if in_array(
+                        PhpMixed::String(candidate.get_version().to_string()),
+                        &PhpMixed::List(vec![
+                            Box::new(PhpMixed::String("dev-default".to_string())),
+                            Box::new(PhpMixed::String("dev-main".to_string())),
+                        ]),
+                        true,
+                    ) {
+                        suffix = format!(
+                            " Perhaps dev-master was renamed to {}?",
+                            candidate.get_pretty_version()
+                        );
+                        break;
                     }
                 }
             }
@@ -953,11 +954,11 @@ impl Problem {
             // check if the root package is a name match and hint the dependencies on root troubleshooting article
             let all_repos_packages = &packages;
             let top_package = all_repos_packages.first();
-            if let Some(tp) = top_package {
-                if tp.as_root().is_some() {
-                    suffix = " See https://getcomposer.org/dep-on-root for details and assistance."
-                        .to_string();
-                }
+            if let Some(tp) = top_package
+                && tp.as_root().is_some()
+            {
+                suffix = " See https://getcomposer.org/dep-on-root for details and assistance."
+                    .to_string();
             }
 
             return Ok((
@@ -1045,18 +1046,18 @@ impl Problem {
                 package.get_version().to_string(),
                 format!("{}{}", package.get_pretty_version(), alias_suffix),
             );
-            if pool.is_some() && constraint.is_some() {
-                for (version, pretty_version) in pool
-                    .unwrap()
-                    .get_removed_versions(&pkg_name, constraint.unwrap())
-                {
+            if let Some(pool) = pool
+                && let Some(constraint) = constraint
+            {
+                for (version, pretty_version) in pool.get_removed_versions(&pkg_name, constraint) {
                     entry.versions.insert(version, pretty_version);
                 }
             }
-            if pool.is_some() && use_removed_version_group {
-                for (version, pretty_version) in pool
-                    .unwrap()
-                    .get_removed_versions_by_package(&package.ptr_id().to_string())
+            if let Some(pool) = pool
+                && use_removed_version_group
+            {
+                for (version, pretty_version) in
+                    pool.get_removed_versions_by_package(&package.ptr_id().to_string())
                 {
                     entry.versions.insert(version, pretty_version);
                 }
@@ -1120,12 +1121,12 @@ impl Problem {
     ) -> Option<String> {
         let available = pool.what_provides(package_name, None);
 
-        if available.len() > 0 {
+        if !available.is_empty() {
             let mut selected: Option<&BasePackageHandle> = None;
             for pkg in &available {
                 if pkg
                     .get_repository()
-                    .map_or(false, |r| r.is::<PlatformRepository>())
+                    .is_some_and(|r| r.is::<PlatformRepository>())
                 {
                     selected = Some(pkg);
                     break;
@@ -1188,14 +1189,11 @@ impl Problem {
             if stripos(version, "dev-") == Some(0) {
                 by_major
                     .entry("dev".to_string())
-                    .or_insert_with(Vec::new)
+                    .or_default()
                     .push(pretty.clone());
             } else {
                 let key = Preg::replace(r"{^(\d+)\..*}", "$1", version);
-                by_major
-                    .entry(key)
-                    .or_insert_with(Vec::new)
-                    .push(pretty.clone());
+                by_major.entry(key).or_default().push(pretty.clone());
             }
         }
         for (major_version, versions_for_major) in by_major {
@@ -1255,7 +1253,7 @@ impl Problem {
         }
         let next_repo = next_repo.expect("next_repo must be set");
 
-        if higher_repo_packages.len() > 0 {
+        if !higher_repo_packages.is_empty() {
             let top_package = higher_repo_packages.first().unwrap();
             if top_package.as_root().is_some() {
                 return (
@@ -1366,45 +1364,38 @@ impl Problem {
 
     /// Turns a constraint into text usable in a sentence describing a request
     pub(crate) fn constraint_to_text(constraint: Option<&AnyConstraint>) -> String {
-        if let Some(c) = constraint {
-            if c.is_constraint()
-                && c.get_operator() == SimpleConstraint::STR_OP_EQ
-                && !str_starts_with(&c.get_version(), "dev-")
-            {
-                if !Preg::is_match3(r"{^\d+(?:\.\d+)*$}", &c.get_pretty_string(), None) {
-                    return format!(" {} (exact version match)", c.get_pretty_string());
-                }
-
-                let mut versions = vec![c.get_pretty_string()];
-                let mut i = 3 - substr_count(&versions[0], ".");
-                while i > 0 {
-                    let last = versions.last().unwrap().clone();
-                    versions.push(format!("{}.0", last));
-                    i -= 1;
-                }
+        if let Some(c) = constraint
+            && c.is_constraint()
+            && c.get_operator() == SimpleConstraint::STR_OP_EQ
+            && !str_starts_with(c.get_version(), "dev-")
+        {
+            if !Preg::is_match3(r"{^\d+(?:\.\d+)*$}", &c.get_pretty_string(), None) {
+                return format!(" {} (exact version match)", c.get_pretty_string());
+            }
 
+            let mut versions = vec![c.get_pretty_string()];
+            let mut i = 3 - substr_count(&versions[0], ".");
+            while i > 0 {
                 let last = versions.last().unwrap().clone();
-                let detail = if versions.len() > 1 {
-                    format!(
-                        "{} or {}",
-                        implode(
-                            ", ",
-                            &versions[..versions.len() - 1]
-                                .iter()
-                                .cloned()
-                                .collect::<Vec<_>>()
-                        ),
-                        last
-                    )
-                } else {
-                    versions[0].clone()
-                };
-                return format!(
-                    " {} (exact version match: {})",
-                    c.get_pretty_string(),
-                    detail
-                );
+                versions.push(format!("{}.0", last));
+                i -= 1;
             }
+
+            let last = versions.last().unwrap().clone();
+            let detail = if versions.len() > 1 {
+                format!(
+                    "{} or {}",
+                    implode(", ", &versions[..versions.len() - 1]),
+                    last
+                )
+            } else {
+                versions[0].clone()
+            };
+            return format!(
+                " {} (exact version match: {})",
+                c.get_pretty_string(),
+                detail
+            );
         }
 
         match constraint {
@@ -1419,7 +1410,7 @@ impl Problem {
         max_providers: i64,
     ) -> anyhow::Result<Option<String>> {
         let providers = repository_set.get_providers(package_name)?;
-        if providers.len() > 0 {
+        if !providers.is_empty() {
             let provider_count = providers.len() as i64;
             let slice: Vec<crate::repository::ProviderInfo> = if provider_count > max_providers + 1
             {
diff --git a/crates/shirabe/src/dependency_resolver/rule.rs b/crates/shirabe/src/dependency_resolver/rule.rs
index e62bb7b..30fa079 100644
--- a/crates/shirabe/src/dependency_resolver/rule.rs
+++ b/crates/shirabe/src/dependency_resolver/rule.rs
@@ -208,77 +208,76 @@ impl Rule {
         request: &Request,
         pool: &Pool,
     ) -> bool {
-        if self.get_reason() == RULE_PACKAGE_REQUIRES {
-            if let ReasonData::Link(link) = self.get_reason_data() {
-                if PlatformRepository::is_platform_package(link.get_target()) {
-                    return false;
-                }
-                // TODO(phase-c): request.get_locked_repository() exists, but its get_packages()
-                // returns Result while is_caused_by_lock returns bool; resolving needs the bool
-                // chain (also via Problem/SolverProblemsException, itself phase-c) to carry Result.
-                let locked_repo: Option<()> = todo!("request.get_locked_repository()");
-                if let Some(_locked_repo) = locked_repo {
-                    let packages: Vec<BasePackageHandle> = todo!("locked_repo.get_packages()");
-                    for package in packages {
-                        let p = package.clone();
-                        if p.get_name() == link.get_target() {
-                            if pool.is_unacceptable_fixed_or_locked_package(p.clone()) {
-                                return true;
-                            }
-                            if !link.get_constraint().matches(
-                                &SimpleConstraint::new(
-                                    "=".to_string(),
-                                    p.get_version().to_string(),
-                                    None,
-                                )
-                                .into(),
-                            ) {
-                                return true;
-                            }
-                            // required package was locked but has been unlocked and still matches
-                            if !request.is_locked_package(p) {
-                                return true;
-                            }
-                            break;
+        if self.get_reason() == RULE_PACKAGE_REQUIRES
+            && let ReasonData::Link(link) = self.get_reason_data()
+        {
+            if PlatformRepository::is_platform_package(link.get_target()) {
+                return false;
+            }
+            // TODO(phase-c): request.get_locked_repository() exists, but its get_packages()
+            // returns Result while is_caused_by_lock returns bool; resolving needs the bool
+            // chain (also via Problem/SolverProblemsException, itself phase-c) to carry Result.
+            let locked_repo: Option<()> = todo!("request.get_locked_repository()");
+            if let Some(_locked_repo) = locked_repo {
+                let packages: Vec<BasePackageHandle> = todo!("locked_repo.get_packages()");
+                for package in packages {
+                    let p = package.clone();
+                    if p.get_name() == link.get_target() {
+                        if pool.is_unacceptable_fixed_or_locked_package(p.clone()) {
+                            return true;
+                        }
+                        if !link.get_constraint().matches(
+                            &SimpleConstraint::new(
+                                "=".to_string(),
+                                p.get_version().to_string(),
+                                None,
+                            )
+                            .into(),
+                        ) {
+                            return true;
                         }
+                        // required package was locked but has been unlocked and still matches
+                        if !request.is_locked_package(p) {
+                            return true;
+                        }
+                        break;
                     }
                 }
             }
         }
 
-        if self.get_reason() == RULE_ROOT_REQUIRE {
-            if let ReasonData::RootRequire {
+        if self.get_reason() == RULE_ROOT_REQUIRE
+            && let ReasonData::RootRequire {
                 package_name,
                 constraint,
             } = self.get_reason_data()
-            {
-                if PlatformRepository::is_platform_package(package_name) {
-                    return false;
-                }
-                // TODO(phase-c): request.get_locked_repository() exists, but its get_packages()
-                // returns Result while is_caused_by_lock returns bool; resolving needs the bool
-                // chain (also via Problem/SolverProblemsException, itself phase-c) to carry Result.
-                let locked_repo: Option<()> = todo!("request.get_locked_repository()");
-                if let Some(_locked_repo) = locked_repo {
-                    let packages: Vec<BasePackageHandle> = todo!("locked_repo.get_packages()");
-                    for package in packages {
-                        let p = package.clone();
-                        if p.get_name() == *package_name {
-                            if pool.is_unacceptable_fixed_or_locked_package(p.clone()) {
-                                return true;
-                            }
-                            if !constraint.matches(
-                                &SimpleConstraint::new(
-                                    "=".to_string(),
-                                    p.get_version().to_string(),
-                                    None,
-                                )
-                                .into(),
-                            ) {
-                                return true;
-                            }
-                            break;
+        {
+            if PlatformRepository::is_platform_package(package_name) {
+                return false;
+            }
+            // TODO(phase-c): request.get_locked_repository() exists, but its get_packages()
+            // returns Result while is_caused_by_lock returns bool; resolving needs the bool
+            // chain (also via Problem/SolverProblemsException, itself phase-c) to carry Result.
+            let locked_repo: Option<()> = todo!("request.get_locked_repository()");
+            if let Some(_locked_repo) = locked_repo {
+                let packages: Vec<BasePackageHandle> = todo!("locked_repo.get_packages()");
+                for package in packages {
+                    let p = package.clone();
+                    if p.get_name() == *package_name {
+                        if pool.is_unacceptable_fixed_or_locked_package(p.clone()) {
+                            return true;
                         }
+                        if !constraint.matches(
+                            &SimpleConstraint::new(
+                                "=".to_string(),
+                                p.get_version().to_string(),
+                                None,
+                            )
+                            .into(),
+                        ) {
+                            return true;
+                        }
+                        break;
                     }
                 }
             }
@@ -300,10 +299,10 @@ impl Rule {
 
                 let reason_data = self.get_reason_data();
                 // swap literals if they are not in the right order with package2 being the conflicter
-                if let ReasonData::Link(link) = reason_data {
-                    if link.get_source() == package1.get_name() {
-                        std::mem::swap(&mut package1, &mut package2);
-                    }
+                if let ReasonData::Link(link) = reason_data
+                    && link.get_source() == package1.get_name()
+                {
+                    std::mem::swap(&mut package1, &mut package2);
                 }
 
                 Ok(package2)
@@ -350,7 +349,7 @@ impl Rule {
                 };
 
                 let packages = pool.what_provides(package_name, Some(constraint));
-                if 0 == packages.len() {
+                if packages.is_empty() {
                     return Ok(format!(
                         "No package found to satisfy root composer.json require {} {}",
                         package_name,
@@ -361,7 +360,7 @@ impl Rule {
                 let packages_non_alias: Vec<BasePackageHandle> = packages
                     .iter()
                     .filter(|p| p.as_alias().is_none())
-                    .map(|p| p.clone())
+                    .cloned()
                     .collect();
                 if packages_non_alias.len() == 1 {
                     let package = &packages_non_alias[0];
@@ -380,7 +379,7 @@ impl Rule {
                     constraint.get_pretty_string(),
                     self.format_packages_unique_from_packages(
                         pool,
-                        packages.iter().map(|p| p.clone()).collect(),
+                        packages.to_vec(),
                         is_verbose,
                         Some(constraint),
                         false
@@ -473,7 +472,7 @@ impl Rule {
             }
 
             r if r == RULE_PACKAGE_REQUIRES => {
-                assert!(literals.len() > 0);
+                assert!(!literals.is_empty());
                 let source_literal = array_shift(&mut literals).unwrap();
                 let source_package =
                     self.deduplicate_default_branch_alias(pool.literal_to_package(source_literal));
@@ -489,7 +488,7 @@ impl Rule {
                 }
 
                 let text = link.get_pretty_string(source_package.clone());
-                if requires.len() > 0 {
+                if !requires.is_empty() {
                     format!(
                         "{} -> satisfiable by {}.",
                         text,
@@ -562,7 +561,7 @@ impl Rule {
                         }
                     }
 
-                    if installed_packages.len() > 0 && removable_packages.len() > 0 {
+                    if !installed_packages.is_empty() && !removable_packages.is_empty() {
                         return Ok(format!(
                             "{} cannot be installed as that would require removing {}. {}",
                             self.format_packages_unique_from_packages(
@@ -605,7 +604,7 @@ impl Rule {
                 let learned_string = " (conflict analysis result)";
 
                 let rule_text = if literals.len() == 1 {
-                    pool.literal_to_pretty_string(literals[0], &installed_map)
+                    pool.literal_to_pretty_string(literals[0], installed_map)
                 } else {
                     let mut groups: IndexMap<String, Vec<BasePackageHandle>> = IndexMap::new();
                     for literal in &literals {
@@ -622,7 +621,7 @@ impl Rule {
 
                         groups
                             .entry(group.to_string())
-                            .or_insert_with(Vec::new)
+                            .or_default()
                             .push(self.deduplicate_default_branch_alias(package.clone()));
                     }
                     let mut rule_texts: Vec<String> = vec![];
@@ -633,7 +632,7 @@ impl Rule {
                             if packages.len() > 1 { " one of" } else { "" },
                             self.format_packages_unique_from_packages(
                                 pool,
-                                packages.iter().map(|p| p.clone()).collect(),
+                                packages.to_vec(),
                                 is_verbose,
                                 None,
                                 false,
@@ -685,7 +684,7 @@ impl Rule {
                     if i != 0 {
                         rule_text.push('|');
                     }
-                    rule_text.push_str(&pool.literal_to_pretty_string(*literal, &installed_map));
+                    rule_text.push_str(&pool.literal_to_pretty_string(*literal, installed_map));
                 }
 
                 format!("({})", rule_text)
@@ -734,10 +733,10 @@ impl Rule {
     }
 
     fn deduplicate_default_branch_alias(&self, package: BasePackageHandle) -> BasePackageHandle {
-        if let Some(alias_pkg) = package.as_alias() {
-            if alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS {
-                return alias_pkg.get_alias_of().into();
-            }
+        if let Some(alias_pkg) = package.as_alias()
+            && alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS
+        {
+            return alias_pkg.get_alias_of().into();
         }
 
         package
diff --git a/crates/shirabe/src/dependency_resolver/rule_set.rs b/crates/shirabe/src/dependency_resolver/rule_set.rs
index 195f498..2d1cb78 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set.rs
@@ -21,6 +21,12 @@ pub struct RuleSet {
     pub(crate) rules_by_hash: IndexMap<String, Vec<Rc<RefCell<Rule>>>>,
 }
 
+impl Default for RuleSet {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl RuleSet {
     pub const TYPE_PACKAGE: i64 = 0;
     pub const TYPE_REQUEST: i64 = 1;
@@ -74,19 +80,13 @@ impl RuleSet {
 
         // The same rule instance is referenced from `rules`, `rule_by_id`, and
         // `rules_by_hash` (PHP shares one object across all three).
-        self.rules
-            .entry(r#type)
-            .or_insert_with(Vec::new)
-            .push(rule.clone());
+        self.rules.entry(r#type).or_default().push(rule.clone());
         self.rule_by_id.insert(self.next_rule_id, rule.clone());
         rule.borrow_mut().set_type(r#type);
 
         self.next_rule_id += 1;
 
-        self.rules_by_hash
-            .entry(hash)
-            .or_insert_with(Vec::new)
-            .push(rule);
+        self.rules_by_hash.entry(hash).or_default().push(rule);
 
         Ok(())
     }
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
index f2e7b75..d9452a3 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
@@ -208,7 +208,6 @@ impl RuleSetGenerator {
                     .borrow_mut()
                     .what_provides(link.get_target(), Some(&constraint))
                     .into_iter()
-                    .map(|p| p.into())
                     .collect();
 
                 let rule = self.create_require_rule(
@@ -257,7 +256,6 @@ impl RuleSetGenerator {
                     .borrow_mut()
                     .what_provides(link.get_target(), Some(&constraint))
                     .into_iter()
-                    .map(|p| p.into())
                     .collect();
 
                 for conflict in &conflicts {
@@ -282,7 +280,7 @@ impl RuleSetGenerator {
         let names_packages: Vec<(String, Vec<PackageInterfaceHandle>)> = self
             .added_packages_by_names
             .iter()
-            .map(|(k, v)| (k.clone(), v.iter().cloned().collect()))
+            .map(|(k, v)| (k.clone(), v.to_vec()))
             .collect();
 
         for (name, packages) in names_packages {
@@ -324,13 +322,13 @@ impl RuleSetGenerator {
                 }));
             }
 
-            self.add_rules_for_package(package.clone().into(), platform_requirement_filter);
+            self.add_rules_for_package(package.clone(), platform_requirement_filter);
 
             let rule = self.create_install_one_of_rule(
-                &[package.clone().into()],
+                &[package.clone()],
                 rule::RULE_FIXED,
                 rule::ReasonData::Fixed {
-                    package: package.clone().into(),
+                    package: package.clone(),
                 },
             );
             self.add_rule(RuleSet::TYPE_REQUEST, Some(Rule::Generic(rule)));
@@ -355,7 +353,6 @@ impl RuleSetGenerator {
                 .borrow_mut()
                 .what_provides(package_name, Some(&constraint))
                 .into_iter()
-                .map(|p| p.into())
                 .collect();
             if !packages.is_empty() {
                 for package in &packages {
@@ -382,29 +379,21 @@ impl RuleSetGenerator {
         &mut self,
         platform_requirement_filter: &dyn PlatformRequirementFilterInterface,
     ) {
-        let packages: Vec<PackageInterfaceHandle> = self
-            .pool
-            .borrow()
-            .get_packages()
-            .iter()
-            .map(|p| p.clone().into())
-            .collect();
+        let packages: Vec<PackageInterfaceHandle> = self.pool.borrow().get_packages().to_vec();
         for package in &packages {
             // ensure that rules for root alias packages and aliases of packages which were loaded are also loaded
             // even if the alias itself isn't required, otherwise a package could be installed without its alias which
             // leads to unexpected behavior
             let is_not_added = !self.added_map.contains_key(&package.get_id());
             let as_alias = package.as_alias();
-            if is_not_added {
-                if let Some(alias_pkg) = as_alias {
-                    if alias_pkg.is_root_package_alias()
-                        || self
-                            .added_map
-                            .contains_key(&alias_pkg.get_alias_of().get_id())
-                    {
-                        self.add_rules_for_package(package.clone(), platform_requirement_filter);
-                    }
-                }
+            if is_not_added
+                && let Some(alias_pkg) = as_alias
+                && (alias_pkg.is_root_package_alias()
+                    || self
+                        .added_map
+                        .contains_key(&alias_pkg.get_alias_of().get_id()))
+            {
+                self.add_rules_for_package(package.clone(), platform_requirement_filter);
             }
         }
     }
@@ -427,7 +416,7 @@ impl RuleSetGenerator {
         self.added_map = IndexMap::new();
         self.added_packages_by_names = IndexMap::new();
 
-        let rules = std::mem::replace(&mut self.rules, RuleSet::new());
+        let rules = std::mem::take(&mut self.rules);
 
         Ok(rules)
     }
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
index c1b8657..91cfff2 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
@@ -59,7 +59,7 @@ impl RuleSetIterator {
 
                 self.current_type = self.types[self.current_type_offset as usize];
 
-                if self.rules[&self.current_type].len() != 0 {
+                if !self.rules[&self.current_type].is_empty() {
                     break;
                 }
             }
@@ -81,7 +81,7 @@ impl RuleSetIterator {
 
             self.current_type = self.types[self.current_type_offset as usize];
 
-            if self.rules[&self.current_type].len() != 0 {
+            if !self.rules[&self.current_type].is_empty() {
                 break;
             }
         }
diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_chain.rs b/crates/shirabe/src/dependency_resolver/rule_watch_chain.rs
index aa2d7f7..a29ff30 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_chain.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_chain.rs
@@ -9,6 +9,12 @@ pub struct RuleWatchChain {
     current_offset: usize,
 }
 
+impl Default for RuleWatchChain {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl RuleWatchChain {
     pub fn new() -> Self {
         Self {
diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
index f5f66df..370d553 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
@@ -15,6 +15,12 @@ pub struct RuleWatchGraph {
     pub(crate) watch_chains: IndexMap<i64, RuleWatchChain>,
 }
 
+impl Default for RuleWatchGraph {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl RuleWatchGraph {
     pub fn new() -> Self {
         Self {
diff --git a/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs b/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs
index 80769bb..933e1d0 100644
--- a/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs
+++ b/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs
@@ -92,14 +92,13 @@ impl SecurityAdvisoryPoolFilter {
             IndexMap::new();
         for package in pool.get_packages() {
             if self.audit_config.block_abandoned
-                && self
+                && !self
                     .auditor
                     .filter_abandoned_packages(
-                        &[package.clone()],
+                        std::slice::from_ref(package),
                         &self.audit_config.ignore_abandoned_for_blocking,
                     )?
-                    .len()
-                    != 0
+                    .is_empty()
             {
                 for package_name in package.get_names(false) {
                     abandoned_removed_versions
@@ -114,7 +113,7 @@ impl SecurityAdvisoryPoolFilter {
             }
 
             let matching_advisories = self.get_matching_advisories(package.clone(), &advisory_map);
-            if matching_advisories.len() > 0 {
+            if !matching_advisories.is_empty() {
                 for package_name in package.get_names(false) {
                     security_removed_versions
                         .entry(package_name)
diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index 1278970..d6654a9 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -271,7 +271,7 @@ impl Solver {
             crate::io::VERBOSE,
         );
 
-        if self.problems.len() > 0 {
+        if !self.problems.is_empty() {
             // TODO(phase-c): SolverProblemsException stores `Rc<RefCell<Rule>>` which is not
             // `Send + Sync`, so it cannot satisfy `anyhow::Error`'s bounds. Returning a
             // placeholder error preserves control flow until the solver error path is reworked to
@@ -285,18 +285,10 @@ impl Solver {
 
         // LockTransaction stores PackageInterfaceHandle maps; widen the request's BasePackageHandle
         // maps into them.
-        let present_map = request
-            .get_present_map(false)?
-            .into_iter()
-            .map(|(k, v)| (k, v.into()))
-            .collect();
-        let unlockable_map = request
-            .get_fixed_packages_map()
-            .into_iter()
-            .map(|(k, v)| (k, v.into()))
-            .collect();
+        let present_map = request.get_present_map(false)?.into_iter().collect();
+        let unlockable_map = request.get_fixed_packages_map().into_iter().collect();
         Ok(LockTransaction::new(
-            &*self.pool.borrow(),
+            &self.pool.borrow(),
             present_map,
             unlockable_map,
             &self.decisions,
@@ -430,7 +422,7 @@ impl Solver {
     ) -> anyhow::Result<i64> {
         // choose best package to install from decisionQueue
         let mut literals = self.policy.select_preferred_packages(
-            &*self.pool.borrow(),
+            &self.pool.borrow(),
             decision_queue,
             rule.borrow().get_required_package(),
         );
@@ -439,7 +431,7 @@ impl Solver {
             .expect("select_preferred_packages returned an empty literal list");
 
         // if there are multiple candidates, then branch
-        if literals.len() > 0 {
+        if !literals.is_empty() {
             self.branches.push((literals, level));
         }
 
@@ -519,8 +511,8 @@ impl Solver {
                         return Err(anyhow::anyhow!(SolverBugException::new(format!(
                             "Reached invalid decision id {} while looking through {} for a literal present in the analyzed rule {}.",
                             decision_id,
-                            rule.borrow().to_string(),
-                            analyzed_rule.borrow().to_string()
+                            rule.borrow(),
+                            analyzed_rule.borrow()
                         ))));
                     }
 
@@ -600,7 +592,7 @@ impl Solver {
             None => {
                 return Err(anyhow::anyhow!(SolverBugException::new(format!(
                     "Did not find a learnable literal in analyzed rule {}.",
-                    analyzed_rule.borrow().to_string()
+                    analyzed_rule.borrow()
                 ))));
             }
         };
@@ -731,7 +723,7 @@ impl Solver {
                             }
                         }
 
-                        if none_satisfied && decision_queue.len() > 0 {
+                        if none_satisfied && !decision_queue.is_empty() {
                             // if any of the options in the decision queue are fixed, only use those
                             let mut pruned_queue: Vec<i64> = Vec::new();
                             for literal in &decision_queue {
@@ -739,12 +731,12 @@ impl Solver {
                                     pruned_queue.push(*literal);
                                 }
                             }
-                            if pruned_queue.len() > 0 {
+                            if !pruned_queue.is_empty() {
                                 decision_queue = pruned_queue;
                             }
                         }
 
-                        if none_satisfied && decision_queue.len() > 0 {
+                        if none_satisfied && !decision_queue.is_empty() {
                             let o_level = level;
                             level = self.select_and_install(level, decision_queue, rule)?;
 
@@ -875,7 +867,7 @@ impl Solver {
             }
 
             // minimization step
-            if self.branches.len() > 0 {
+            if !self.branches.is_empty() {
                 let mut last_literal: Option<i64> = None;
                 let mut last_level: Option<i64> = None;
                 let mut last_branch_index = 0_usize;
diff --git a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
index 513d4d9..d5f5560 100644
--- a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
+++ b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
@@ -128,7 +128,7 @@ impl SolverProblemsException {
     fn create_extension_hint(&self, missing_extensions: &[String]) -> String {
         let mut paths = IniHelper::get_all();
 
-        if paths.first().map_or(false, |s| s.is_empty()) {
+        if paths.first().is_some_and(|s| s.is_empty()) {
             if paths.len() == 1 {
                 return String::new();
             }
@@ -162,10 +162,10 @@ impl SolverProblemsException {
         for reason_set in reason_sets.values() {
             for rule in reason_set {
                 let required = rule.borrow().get_required_package();
-                if let Some(req) = required {
-                    if req.starts_with("ext-") {
-                        missing_extensions.insert(req.to_string(), 1);
-                    }
+                if let Some(req) = required
+                    && req.starts_with("ext-")
+                {
+                    missing_extensions.insert(req.to_string(), 1);
                 }
             }
         }
diff --git a/crates/shirabe/src/dependency_resolver/transaction.rs b/crates/shirabe/src/dependency_resolver/transaction.rs
index d20659c..9e0a709 100644
--- a/crates/shirabe/src/dependency_resolver/transaction.rs
+++ b/crates/shirabe/src/dependency_resolver/transaction.rs
@@ -92,7 +92,7 @@ impl Transaction {
             for name in package.get_names(true) {
                 self.result_packages_by_name
                     .entry(name)
-                    .or_insert_with(Vec::new)
+                    .or_default()
                     .push(package.clone());
             }
             self.result_package_map
@@ -266,7 +266,7 @@ impl Transaction {
             return vec![];
         };
 
-        packages.iter().cloned().collect()
+        packages.to_vec()
     }
 
     /// Workaround: if your packages depend on plugins, we must be sure
@@ -315,8 +315,8 @@ impl Transaction {
 
             // is this a downloads modifying plugin or a dependency of one?
             if is_downloads_modifying_plugin
-                || array_intersect(&package.get_names(true), &dl_modifying_plugin_requires).len()
-                    > 0
+                || !array_intersect(&package.get_names(true), &dl_modifying_plugin_requires)
+                    .is_empty()
             {
                 // get the package's requires, but filter out any platform requirements
                 let requires: Vec<String> = array_filter(
@@ -344,7 +344,8 @@ impl Transaction {
                 || package.get_type() == "composer-installer";
 
             // is this a plugin or a dependency of a plugin?
-            if is_plugin || array_intersect(&package.get_names(true), &plugin_requires).len() > 0 {
+            if is_plugin || !array_intersect(&package.get_names(true), &plugin_requires).is_empty()
+            {
                 // get the package's requires, but filter out any platform requirements
                 let requires: Vec<String> = array_filter(
                     &array_keys(&package.get_requires()),