fix(compile): add dyn keyword to all trait object usages (E0782)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

12 files changed, 115 insertions, 102 deletions

diff --git a/crates/shirabe/src/dependency_resolver/decisions.rs b/crates/shirabe/src/dependency_resolver/decisions.rs
index 22b6fa4..8ef8b25 100644
--- a/crates/shirabe/src/dependency_resolver/decisions.rs
+++ b/crates/shirabe/src/dependency_resolver/decisions.rs
@@ -11,7 +11,7 @@ use std::fmt;
 pub struct Decisions {
     pub(crate) pool: Pool,
     pub(crate) decision_map: IndexMap<i64, i64>,
-    pub(crate) decision_queue: Vec<(i64, Rule)>,
+    pub(crate) decision_queue: Vec<(i64, Box<dyn Rule>)>,
     iterator_cursor: Option<usize>,
 }
 
@@ -28,7 +28,7 @@ impl Decisions {
         }
     }
 
-    pub fn decide(&mut self, literal: i64, level: i64, why: Rule) {
+    pub fn decide(&mut self, literal: i64, level: i64, why: Box<dyn Rule>) {
         self.add_decision(literal, level);
         self.decision_queue.push((literal, why));
     }
@@ -82,12 +82,12 @@ impl Decisions {
         0
     }
 
-    pub fn decision_rule(&self, literal_or_package_id: i64) -> &Rule {
+    pub fn decision_rule(&self, literal_or_package_id: i64) -> &dyn Rule {
         let package_id = literal_or_package_id.abs();
 
         for decision in &self.decision_queue {
             if package_id == decision.0.abs() {
-                return &decision.1;
+                return &*decision.1;
             }
         }
 
@@ -104,7 +104,7 @@ impl Decisions {
         );
     }
 
-    pub fn at_offset(&self, queue_offset: usize) -> &(i64, Rule) {
+    pub fn at_offset(&self, queue_offset: usize) -> &(i64, Box<dyn Rule>) {
         &self.decision_queue[queue_offset]
     }
 
@@ -112,8 +112,8 @@ impl Decisions {
         queue_offset >= 0 && queue_offset < self.decision_queue.len() as i64
     }
 
-    pub fn last_reason(&self) -> &Rule {
-        &self.decision_queue[self.decision_queue.len() - 1].1
+    pub fn last_reason(&self) -> &dyn Rule {
+        &*self.decision_queue[self.decision_queue.len() - 1].1
     }
 
     pub fn last_literal(&self) -> i64 {
@@ -151,7 +151,7 @@ impl Decisions {
         }
     }
 
-    pub fn current(&self) -> Option<&(i64, Rule)> {
+    pub fn current(&self) -> Option<&(i64, Box<dyn Rule>)> {
         self.iterator_cursor
             .and_then(|cursor| self.decision_queue.get(cursor))
     }
diff --git a/crates/shirabe/src/dependency_resolver/default_policy.rs b/crates/shirabe/src/dependency_resolver/default_policy.rs
index f647327..378d0f8 100644
--- a/crates/shirabe/src/dependency_resolver/default_policy.rs
+++ b/crates/shirabe/src/dependency_resolver/default_policy.rs
@@ -45,8 +45,8 @@ impl DefaultPolicy {
     pub fn compare_by_priority(
         &self,
         pool: &Pool,
-        a: &BasePackage,
-        b: &BasePackage,
+        a: &dyn BasePackage,
+        b: &dyn BasePackage,
         required_package: Option<String>,
         ignore_replace: bool,
     ) -> i64 {
@@ -169,7 +169,7 @@ impl DefaultPolicy {
         selected
     }
 
-    pub(crate) fn replaces(&self, source: &BasePackage, target: &BasePackage) -> bool {
+    pub(crate) fn replaces(&self, source: &dyn BasePackage, target: &dyn BasePackage) -> bool {
         for link in source.get_replaces().values() {
             if link.get_target() == target.get_name() {
                 return true;
diff --git a/crates/shirabe/src/dependency_resolver/pool.rs b/crates/shirabe/src/dependency_resolver/pool.rs
index e86e4c2..5a028a1 100644
--- a/crates/shirabe/src/dependency_resolver/pool.rs
+++ b/crates/shirabe/src/dependency_resolver/pool.rs
@@ -16,15 +16,15 @@ use crate::package::version::version_parser::VersionParser;
 #[derive(Debug)]
 pub struct Pool {
     /// @var BasePackage[]
-    pub(crate) packages: Vec<Box<BasePackage>>,
+    pub(crate) packages: Vec<Box<dyn BasePackage>>,
     /// @var array<string, BasePackage[]>
-    pub(crate) package_by_name: IndexMap<String, Vec<Box<BasePackage>>>,
+    pub(crate) package_by_name: IndexMap<String, Vec<Box<dyn BasePackage>>>,
     /// @var VersionParser
     pub(crate) version_parser: VersionParser,
     /// @var array<string, array<string, BasePackage[]>>
-    pub(crate) provider_cache: IndexMap<String, IndexMap<String, Vec<Box<BasePackage>>>>,
+    pub(crate) provider_cache: IndexMap<String, IndexMap<String, Vec<Box<dyn BasePackage>>>>,
     /// @var BasePackage[]
-    pub(crate) unacceptable_fixed_or_locked_packages: Vec<Box<BasePackage>>,
+    pub(crate) unacceptable_fixed_or_locked_packages: Vec<Box<dyn BasePackage>>,
     /// @var array<string, array<string, string>> Map of package name => normalized version => pretty version
     pub(crate) removed_versions: IndexMap<String, IndexMap<String, String>>,
     /// @var array<string, array<string, string>> Map of package object hash => removed normalized versions => removed pretty version
@@ -44,8 +44,8 @@ impl Pool {
     /// @param array<string, array<string, array<SecurityAdvisory|PartialSecurityAdvisory>>> $securityRemovedVersions
     /// @param array<string, array<string, string>> $abandonedRemovedVersions
     pub fn new(
-        packages: Vec<Box<BasePackage>>,
-        unacceptable_fixed_or_locked_packages: Vec<Box<BasePackage>>,
+        packages: Vec<Box<dyn BasePackage>>,
+        unacceptable_fixed_or_locked_packages: Vec<Box<dyn BasePackage>>,
         removed_versions: IndexMap<String, IndexMap<String, String>>,
         removed_versions_by_package: IndexMap<String, IndexMap<String, String>>,
         security_removed_versions: IndexMap<String, IndexMap<String, Vec<PartialSecurityAdvisory>>>,
@@ -189,7 +189,7 @@ impl Pool {
     }
 
     /// @param BasePackage[] $packages
-    fn set_packages(&mut self, packages: Vec<Box<BasePackage>>) {
+    fn set_packages(&mut self, packages: Vec<Box<dyn BasePackage>>) {
         let mut id: i64 = 1;
 
         for mut package in packages {
@@ -208,12 +208,12 @@ impl Pool {
     }
 
     /// @return BasePackage[]
-    pub fn get_packages(&self) -> &Vec<Box<BasePackage>> {
+    pub fn get_packages(&self) -> &Vec<Box<dyn BasePackage>> {
         &self.packages
     }
 
     /// Retrieves the package object for a given package id.
-    pub fn package_by_id(&self, id: i64) -> &BasePackage {
+    pub fn package_by_id(&self, id: i64) -> &dyn BasePackage {
         &self.packages[(id - 1) as usize]
     }
 
@@ -227,7 +227,7 @@ impl Pool {
         &mut self,
         name: &str,
         constraint: Option<&dyn ConstraintInterface>,
-    ) -> Vec<Box<BasePackage>> {
+    ) -> Vec<Box<dyn BasePackage>> {
         // PHP: $key = (string) $constraint;
         let key = match constraint {
             Some(c) => c.to_string(),
@@ -255,12 +255,12 @@ impl Pool {
         &self,
         name: &str,
         constraint: Option<&dyn ConstraintInterface>,
-    ) -> Vec<Box<BasePackage>> {
+    ) -> Vec<Box<dyn BasePackage>> {
         let Some(candidates) = self.package_by_name.get(name) else {
             return vec![];
         };
 
-        let mut matches: Vec<Box<BasePackage>> = vec![];
+        let mut matches: Vec<Box<dyn BasePackage>> = vec![];
 
         for candidate in candidates {
             if self.r#match(candidate, name, constraint) {
@@ -271,7 +271,7 @@ impl Pool {
         matches
     }
 
-    pub fn literal_to_package(&self, literal: i64) -> &BasePackage {
+    pub fn literal_to_package(&self, literal: i64) -> &dyn BasePackage {
         let package_id = abs(literal);
 
         self.package_by_id(package_id)
@@ -281,7 +281,7 @@ impl Pool {
     pub fn literal_to_pretty_string(
         &self,
         literal: i64,
-        installed_map: &IndexMap<i64, Box<BasePackage>>,
+        installed_map: &IndexMap<i64, Box<dyn BasePackage>>,
     ) -> String {
         let package = self.literal_to_package(literal);
 
@@ -304,7 +304,7 @@ impl Pool {
     /// @param  string              $name       Name of the package to be matched
     pub fn r#match(
         &self,
-        candidate: &BasePackage,
+        candidate: &dyn BasePackage,
         name: &str,
         constraint: Option<&dyn ConstraintInterface>,
     ) -> bool {
@@ -362,7 +362,7 @@ impl Pool {
         false
     }
 
-    pub fn is_unacceptable_fixed_or_locked_package(&self, package: &BasePackage) -> bool {
+    pub fn is_unacceptable_fixed_or_locked_package(&self, package: &dyn BasePackage) -> bool {
         // PHP: \in_array($package, $this->unacceptableFixedOrLockedPackages, true)
         // strict comparison checks reference identity for objects
         let target_hash = spl_object_hash(package);
@@ -372,7 +372,7 @@ impl Pool {
     }
 
     /// @return BasePackage[]
-    pub fn get_unacceptable_fixed_or_locked_packages(&self) -> &Vec<Box<BasePackage>> {
+    pub fn get_unacceptable_fixed_or_locked_packages(&self) -> &Vec<Box<dyn BasePackage>> {
         &self.unacceptable_fixed_or_locked_packages
     }
 }
diff --git a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
index b71af14..094bd8d 100644
--- a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
+++ b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs
@@ -39,7 +39,7 @@ pub struct PoolOptimizer {
     packages_to_remove: IndexMap<i64, bool>,
 
     /// @var array<int, BasePackage[]>
-    aliases_per_package: IndexMap<i64, Vec<Box<BasePackage>>>,
+    aliases_per_package: IndexMap<i64, Vec<Box<dyn BasePackage>>>,
 
     /// @var array<string, array<string, string>>
     removed_versions_by_package: IndexMap<String, IndexMap<String, String>>,
@@ -171,7 +171,7 @@ impl PoolOptimizer {
         }
     }
 
-    fn mark_package_irremovable(&mut self, package: &BasePackage) {
+    fn mark_package_irremovable(&mut self, package: &dyn BasePackage) {
         self.irremovable_packages.insert(package.id, true);
         if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() {
             // recursing here so aliasesPerPackage for the aliasOf can be checked
@@ -191,7 +191,7 @@ impl PoolOptimizer {
 
     /// @return Pool Optimized pool
     fn apply_removals_to_pool(&self, pool: &Pool) -> Pool {
-        let mut packages: Vec<Box<BasePackage>> = vec![];
+        let mut packages: Vec<Box<dyn BasePackage>> = vec![];
         let mut removed_versions: IndexMap<String, IndexMap<String, String>> = IndexMap::new();
         for package in pool.get_packages() {
             if !self.packages_to_remove.contains_key(&package.id) {
@@ -225,7 +225,7 @@ impl PoolOptimizer {
     ) -> Result<()> {
         let mut identical_definitions_per_package: IndexMap<
             String,
-            IndexMap<String, IndexMap<String, Vec<Box<BasePackage>>>>,
+            IndexMap<String, IndexMap<String, Vec<Box<dyn BasePackage>>>>,
         > = IndexMap::new();
         let mut package_identical_definition_lookup: IndexMap<
             i64,
@@ -361,7 +361,7 @@ impl PoolOptimizer {
         Ok(())
     }
 
-    fn calculate_dependency_hash(&self, package: &BasePackage) -> String {
+    fn calculate_dependency_hash(&self, package: &dyn BasePackage) -> String {
         let mut hash = String::new();
 
         let hash_relevant_links: Vec<(&str, Vec<crate::package::link::Link>)> = vec![
@@ -425,10 +425,10 @@ impl PoolOptimizer {
     /// @param array<int, array<string, array{groupHash: string, dependencyHash: string}>> $packageIdenticalDefinitionLookup
     fn keep_package(
         &mut self,
-        package: &BasePackage,
+        package: &dyn BasePackage,
         identical_definitions_per_package: &IndexMap<
             String,
-            IndexMap<String, IndexMap<String, Vec<Box<BasePackage>>>>,
+            IndexMap<String, IndexMap<String, Vec<Box<dyn BasePackage>>>>,
         >,
         package_identical_definition_lookup: &IndexMap<
             i64,
@@ -542,7 +542,8 @@ impl PoolOptimizer {
             return;
         }
 
-        let mut package_index: IndexMap<String, IndexMap<i64, Box<BasePackage>>> = IndexMap::new();
+        let mut package_index: IndexMap<String, IndexMap<i64, Box<dyn BasePackage>>> =
+            IndexMap::new();
 
         for package in pool.get_packages() {
             let id = package.id;
diff --git a/crates/shirabe/src/dependency_resolver/problem.rs b/crates/shirabe/src/dependency_resolver/problem.rs
index 50b651d..adc2f43 100644
--- a/crates/shirabe/src/dependency_resolver/problem.rs
+++ b/crates/shirabe/src/dependency_resolver/problem.rs
@@ -35,7 +35,7 @@ pub struct Problem {
     pub(crate) reason_seen: IndexMap<String, bool>,
 
     /// A set of reasons for the problem, each is a rule or a root require and a rule
-    pub(crate) reasons: IndexMap<i64, Vec<Rule>>,
+    pub(crate) reasons: IndexMap<i64, Vec<Box<dyn Rule>>>,
 
     pub(crate) section: i64,
 }
@@ -50,13 +50,13 @@ impl Problem {
     }
 
     /// Add a rule as a reason
-    pub fn add_rule(&mut self, rule: Rule) {
+    pub fn add_rule(&mut self, rule: Box<dyn Rule>) {
         let id = spl_object_hash(&rule);
         self.add_reason(id, rule);
     }
 
     /// Retrieve all reasons for this problem
-    pub fn get_reasons(&self) -> &IndexMap<i64, Vec<Rule>> {
+    pub fn get_reasons(&self) -> &IndexMap<i64, Vec<Box<dyn Rule>>> {
         &self.reasons
     }
 
@@ -67,11 +67,11 @@ impl Problem {
         request: &Request,
         pool: &Pool,
         is_verbose: bool,
-        installed_map: &IndexMap<String, BasePackage>,
-        learned_pool: &Vec<Vec<Rule>>,
+        installed_map: &IndexMap<String, Box<dyn BasePackage>>,
+        learned_pool: &Vec<Vec<Box<dyn Rule>>>,
     ) -> anyhow::Result<String> {
         // TODO doesn't this entirely defeat the purpose of the problem sections? what's the point of sections?
-        let mut reasons: Vec<Rule> = Vec::new();
+        let mut reasons: Vec<Box<dyn Rule>> = Vec::new();
         for section_rules in self.reasons.values().rev() {
             for rule in section_rules {
                 reasons.push(rule.clone());
@@ -132,7 +132,7 @@ impl Problem {
         ))
     }
 
-    fn get_sortable_string(&self, pool: &Pool, rule: &Rule) -> String {
+    fn get_sortable_string(&self, pool: &Pool, rule: &dyn Rule) -> String {
         match rule.get_reason() {
             Rule::RULE_ROOT_REQUIRE => rule.get_reason_data().as_array().unwrap()["packageName"]
                 .as_string()
@@ -170,7 +170,7 @@ impl Problem {
         }
     }
 
-    fn get_rule_priority(&self, rule: &Rule) -> i64 {
+    fn get_rule_priority(&self, rule: &dyn Rule) -> i64 {
         match rule.get_reason() {
             Rule::RULE_FIXED => 3,
             Rule::RULE_ROOT_REQUIRE => 2,
@@ -188,14 +188,14 @@ impl Problem {
 
     /// @internal
     pub fn format_deduplicated_rules(
-        rules: &Vec<Rule>,
+        rules: &Vec<Box<dyn Rule>>,
         indent: &str,
         repository_set: &RepositorySet,
         request: &Request,
         pool: &Pool,
         is_verbose: bool,
-        installed_map: &IndexMap<String, BasePackage>,
-        learned_pool: &Vec<Vec<Rule>>,
+        installed_map: &IndexMap<String, Box<dyn BasePackage>>,
+        learned_pool: &Vec<Vec<Box<dyn Rule>>>,
     ) -> String {
         let mut messages: Vec<String> = Vec::new();
         let mut templates: IndexMap<String, IndexMap<String, IndexMap<String, String>>> =
@@ -350,7 +350,7 @@ impl Problem {
     }
 
     /// Store a reason descriptor but ignore duplicates
-    pub(crate) fn add_reason(&mut self, id: String, reason: Rule) {
+    pub(crate) fn add_reason(&mut self, id: String, reason: Box<dyn Rule>) {
         // TODO: if a rule is part of a problem description in two sections, isn't this going to remove a message
         // that is important to understand the issue?
 
diff --git a/crates/shirabe/src/dependency_resolver/request.rs b/crates/shirabe/src/dependency_resolver/request.rs
index e1f8c1e..0d11296 100644
--- a/crates/shirabe/src/dependency_resolver/request.rs
+++ b/crates/shirabe/src/dependency_resolver/request.rs
@@ -35,9 +35,9 @@ pub enum UpdateAllowTransitiveDeps {
 pub struct Request {
     pub(crate) locked_repository: Option<LockArrayRepository>,
     pub(crate) requires: IndexMap<String, Box<dyn ConstraintInterface>>,
-    pub(crate) fixed_packages: IndexMap<String, BasePackage>,
-    pub(crate) locked_packages: IndexMap<String, BasePackage>,
-    pub(crate) fixed_locked_packages: IndexMap<String, BasePackage>,
+    pub(crate) fixed_packages: IndexMap<String, Box<dyn BasePackage>>,
+    pub(crate) locked_packages: IndexMap<String, Box<dyn BasePackage>>,
+    pub(crate) fixed_locked_packages: IndexMap<String, Box<dyn BasePackage>>,
     pub(crate) update_allow_list: Vec<String>,
     pub(crate) update_allow_transitive_dependencies: UpdateAllowTransitiveDeps,
     restrict_packages: Option<Vec<String>>,
@@ -85,7 +85,7 @@ impl Request {
     /// This is used for platform packages which cannot be modified by Composer. A rule enforcing
     /// their installation is generated for dependency resolution. Partial updates with dependencies
     /// cannot in any way modify these packages.
-    pub fn fix_package(&mut self, package: BasePackage) {
+    pub fn fix_package(&mut self, package: Box<dyn BasePackage>) {
         let hash = spl_object_hash(&package);
         self.fixed_packages.insert(hash, package);
     }
@@ -100,7 +100,7 @@ impl Request {
     /// for the solver, so if nothing requires these packages they will be removed. Additionally in
     /// a partial update these packages can be unlocked, meaning other versions can be installed if
     /// explicitly requested as part of the update.
-    pub fn lock_package(&mut self, package: BasePackage) {
+    pub fn lock_package(&mut self, package: Box<dyn BasePackage>) {
         let hash = spl_object_hash(&package);
         self.locked_packages.insert(hash, package);
     }
@@ -111,13 +111,13 @@ impl Request {
     /// should not allow removal of any packages. At the same time lock packages there cannot simply
     /// be marked fixed, as error reporting would then report them as platform packages, so this
     /// still marks them as locked packages at the same time.
-    pub fn fix_locked_package(&mut self, package: BasePackage) {
+    pub fn fix_locked_package(&mut self, package: Box<dyn BasePackage>) {
         let hash = spl_object_hash(&package);
         self.fixed_packages.insert(hash.clone(), package.clone());
         self.fixed_locked_packages.insert(hash, package);
     }
 
-    pub fn unlock_package(&mut self, package: &BasePackage) {
+    pub fn unlock_package(&mut self, package: &dyn BasePackage) {
         self.locked_packages.remove(&spl_object_hash(package));
     }
 
@@ -149,15 +149,15 @@ impl Request {
         &self.requires
     }
 
-    pub fn get_fixed_packages(&self) -> &IndexMap<String, BasePackage> {
+    pub fn get_fixed_packages(&self) -> &IndexMap<String, Box<dyn BasePackage>> {
         &self.fixed_packages
     }
 
-    pub fn is_fixed_package(&self, package: &BasePackage) -> bool {
+    pub fn is_fixed_package(&self, package: &dyn BasePackage) -> bool {
         self.fixed_packages.contains_key(&spl_object_hash(package))
     }
 
-    pub fn get_locked_packages(&self) -> &IndexMap<String, BasePackage> {
+    pub fn get_locked_packages(&self) -> &IndexMap<String, Box<dyn BasePackage>> {
         &self.locked_packages
     }
 
@@ -166,7 +166,7 @@ impl Request {
         self.locked_packages.contains_key(&hash) || self.fixed_locked_packages.contains_key(&hash)
     }
 
-    pub fn get_fixed_or_locked_packages(&self) -> IndexMap<String, BasePackage> {
+    pub fn get_fixed_or_locked_packages(&self) -> IndexMap<String, Box<dyn BasePackage>> {
         let mut result = self.fixed_packages.clone();
         result.extend(self.locked_packages.clone());
         result
@@ -176,8 +176,8 @@ impl Request {
     ///       is for the installed map in the solver problems.
     ///       Some locked packages may not be in the pool,
     ///       so they have a package->id of -1
-    pub fn get_present_map(&self, package_ids: bool) -> IndexMap<String, BasePackage> {
-        let mut present_map: IndexMap<String, BasePackage> = IndexMap::new();
+    pub fn get_present_map(&self, package_ids: bool) -> IndexMap<String, Box<dyn BasePackage>> {
+        let mut present_map: IndexMap<String, Box<dyn BasePackage>> = IndexMap::new();
 
         if let Some(ref locked_repository) = self.locked_repository {
             for package in locked_repository.get_packages() {
@@ -202,8 +202,8 @@ impl Request {
         present_map
     }
 
-    pub fn get_fixed_packages_map(&self) -> IndexMap<i64, BasePackage> {
-        let mut fixed_packages_map: IndexMap<i64, BasePackage> = IndexMap::new();
+    pub fn get_fixed_packages_map(&self) -> IndexMap<i64, Box<dyn BasePackage>> {
+        let mut fixed_packages_map: IndexMap<i64, Box<dyn BasePackage>> = IndexMap::new();
         for (_, package) in &self.fixed_packages {
             fixed_packages_map.insert(package.get_id(), package.clone());
         }
diff --git a/crates/shirabe/src/dependency_resolver/rule.rs b/crates/shirabe/src/dependency_resolver/rule.rs
index 654be92..eb8d2a0 100644
--- a/crates/shirabe/src/dependency_resolver/rule.rs
+++ b/crates/shirabe/src/dependency_resolver/rule.rs
@@ -27,7 +27,7 @@ use crate::repository::repository_set::RepositorySet;
 #[derive(Debug)]
 pub enum ReasonData {
     Link(Link),
-    BasePackage(Box<BasePackage>),
+    BasePackage(Box<dyn BasePackage>),
     String(String),
     Int(i64),
     RootRequire {
@@ -35,7 +35,7 @@ pub enum ReasonData {
         constraint: Box<dyn ConstraintInterface>,
     },
     Fixed {
-        package: Box<BasePackage>,
+        package: Box<dyn BasePackage>,
     },
 }
 
@@ -151,7 +151,7 @@ pub trait Rule: std::fmt::Display {
                 // TODO(phase-b): Request::get_locked_repository() signature
                 if let Some(locked_repo) = todo!("request.get_locked_repository()") {
                     for package in todo!("locked_repo.get_packages()") {
-                        let p: &BasePackage = todo!("package as BasePackage reference");
+                        let p: &dyn BasePackage = todo!("package as BasePackage reference");
                         if p.get_name() == link.get_target() {
                             if pool.is_unacceptable_fixed_or_locked_package(p) {
                                 return true;
@@ -186,7 +186,7 @@ pub trait Rule: std::fmt::Display {
                 // TODO(phase-b): Request::get_locked_repository() signature
                 if let Some(locked_repo) = todo!("request.get_locked_repository()") {
                     for package in todo!("locked_repo.get_packages()") {
-                        let p: &BasePackage = todo!("package as BasePackage reference");
+                        let p: &dyn BasePackage = todo!("package as BasePackage reference");
                         if p.get_name() == package_name {
                             if pool.is_unacceptable_fixed_or_locked_package(p) {
                                 return true;
@@ -205,7 +205,7 @@ pub trait Rule: std::fmt::Display {
     }
 
     /// @internal
-    fn get_source_package(&self, pool: &Pool) -> Result<Box<BasePackage>> {
+    fn get_source_package(&self, pool: &Pool) -> Result<Box<dyn BasePackage>> {
         let literals = self.get_literals();
 
         match self.get_reason() {
@@ -250,7 +250,7 @@ pub trait Rule: std::fmt::Display {
         request: &Request,
         pool: &mut Pool,
         is_verbose: bool,
-        installed_map: IndexMap<i64, Box<BasePackage>>,
+        installed_map: IndexMap<i64, Box<dyn BasePackage>>,
         _learned_pool: IndexMap<i64, Vec<Box<dyn Rule>>>,
     ) -> String {
         let mut literals = self.get_literals();
@@ -277,7 +277,7 @@ pub trait Rule: std::fmt::Display {
                 }
 
                 // PHP: array_values(array_filter($packages, fn ($p) => !($p instanceof AliasPackage)))
-                let packages_non_alias: Vec<Box<BasePackage>> = packages
+                let packages_non_alias: Vec<Box<dyn BasePackage>> = packages
                     .iter()
                     .filter(|p| {
                         (p.as_any() as &dyn Any)
@@ -409,7 +409,7 @@ pub trait Rule: std::fmt::Display {
                     _ => return String::new(),
                 };
 
-                let mut requires: Vec<Box<BasePackage>> = vec![];
+                let mut requires: Vec<Box<dyn BasePackage>> = vec![];
                 for literal in &literals {
                     requires.push(pool.literal_to_package(*literal));
                 }
@@ -479,8 +479,8 @@ pub trait Rule: std::fmt::Display {
                         reason_str
                     };
 
-                    let mut installed_packages: Vec<Box<BasePackage>> = vec![];
-                    let mut removable_packages: Vec<Box<BasePackage>> = vec![];
+                    let mut installed_packages: Vec<Box<dyn BasePackage>> = vec![];
+                    let mut removable_packages: Vec<Box<dyn BasePackage>> = vec![];
                     for literal in &literals {
                         if installed_map.contains_key(&abs(*literal)) {
                             installed_packages.push(pool.literal_to_package(*literal));
@@ -534,7 +534,7 @@ pub trait Rule: std::fmt::Display {
                 let rule_text = if literals.len() == 1 {
                     pool.literal_to_pretty_string(literals[0], &installed_map)
                 } else {
-                    let mut groups: IndexMap<String, Vec<Box<BasePackage>>> = IndexMap::new();
+                    let mut groups: IndexMap<String, Vec<Box<dyn BasePackage>>> = IndexMap::new();
                     for literal in &literals {
                         let package = pool.literal_to_package(*literal);
                         let group = if installed_map.contains_key(&package.id) {
@@ -624,12 +624,12 @@ pub trait Rule: std::fmt::Display {
     fn format_packages_unique(
         &self,
         pool: &Pool,
-        literals_or_packages: Vec<Box<BasePackage>>,
+        literals_or_packages: Vec<Box<dyn BasePackage>>,
         is_verbose: bool,
         constraint: Option<&dyn ConstraintInterface>,
         use_removed_version_group: bool,
     ) -> String {
-        let mut packages: Vec<Box<BasePackage>> = vec![];
+        let mut packages: Vec<Box<dyn BasePackage>> = vec![];
         for package in literals_or_packages {
             // PHP: \is_object($package) ? $package : $pool->literalToPackage($package);
             // In Rust we already have BasePackage, so no conversion needed.
@@ -654,7 +654,7 @@ pub trait Rule: std::fmt::Display {
         constraint: Option<&dyn ConstraintInterface>,
         use_removed_version_group: bool,
     ) -> String {
-        let mut packages: Vec<Box<BasePackage>> = vec![];
+        let mut packages: Vec<Box<dyn BasePackage>> = vec![];
         for literal in literals {
             packages.push(pool.literal_to_package(*literal).clone_box());
         }
@@ -667,7 +667,10 @@ pub trait Rule: std::fmt::Display {
         )
     }
 
-    fn deduplicate_default_branch_alias(&self, package: Box<BasePackage>) -> Box<BasePackage> {
+    fn deduplicate_default_branch_alias(
+        &self,
+        package: Box<dyn BasePackage>,
+    ) -> Box<dyn BasePackage> {
         if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() {
             if alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS {
                 return alias_pkg.get_alias_of().clone_box();
diff --git a/crates/shirabe/src/dependency_resolver/rule_set.rs b/crates/shirabe/src/dependency_resolver/rule_set.rs
index 4fc7928..8d33abf 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set.rs
@@ -11,10 +11,10 @@ use crate::repository::repository_set::RepositorySet;
 
 #[derive(Debug)]
 pub struct RuleSet {
-    pub rule_by_id: IndexMap<i64, Rule>,
-    pub(crate) rules: IndexMap<i64, Vec<Rule>>,
+    pub rule_by_id: IndexMap<i64, Box<dyn Rule>>,
+    pub(crate) rules: IndexMap<i64, Vec<Box<dyn Rule>>>,
     pub(crate) next_rule_id: i64,
-    pub(crate) rules_by_hash: IndexMap<String, Vec<Rule>>,
+    pub(crate) rules_by_hash: IndexMap<String, Vec<Box<dyn Rule>>>,
 }
 
 impl RuleSet {
@@ -47,7 +47,7 @@ impl RuleSet {
         Self::types().into_keys().collect()
     }
 
-    pub fn add(&mut self, rule: Rule, r#type: i64) -> anyhow::Result<()> {
+    pub fn add(&mut self, rule: Box<dyn Rule>, r#type: i64) -> anyhow::Result<()> {
         let types = Self::types();
         if !types.contains_key(&r#type) {
             return Err(OutOfBoundsException {
@@ -88,11 +88,11 @@ impl RuleSet {
         self.next_rule_id
     }
 
-    pub fn rule_by_id(&self, id: i64) -> &Rule {
-        &self.rule_by_id[&id]
+    pub fn rule_by_id(&self, id: i64) -> &dyn Rule {
+        &*self.rule_by_id[&id]
     }
 
-    pub fn get_rules(&self) -> &IndexMap<i64, Vec<Rule>> {
+    pub fn get_rules(&self) -> &IndexMap<i64, Vec<Box<dyn Rule>>> {
         &self.rules
     }
 
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
index 9c803d6..fb74a70 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
@@ -118,7 +118,7 @@ impl RuleSetGenerator {
         packages: &[Box<dyn PackageInterface>],
         reason: i64,
         reason_data: PhpMixed,
-    ) -> Rule {
+    ) -> Box<dyn Rule> {
         let literals: Vec<i64> = packages.iter().map(|p| -p.get_id()).collect();
 
         if literals.len() == 2 {
@@ -140,7 +140,7 @@ impl RuleSetGenerator {
     ///
     /// To be able to directly pass in the result of one of the rule creation
     /// methods null is allowed which will not insert a rule.
-    fn add_rule(&mut self, r#type: i64, new_rule: Option<Rule>) {
+    fn add_rule(&mut self, r#type: i64, new_rule: Option<Box<dyn Rule>>) {
         if let Some(rule) = new_rule {
             self.rules.add(rule, r#type).ok();
         }
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
index f66a277..259b510 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs
@@ -6,7 +6,7 @@ use indexmap::IndexMap;
 /// Implements PHP \Iterator over a grouped rule set.
 #[derive(Debug)]
 pub struct RuleSetIterator {
-    pub(crate) rules: IndexMap<i64, Vec<Rule>>,
+    pub(crate) rules: IndexMap<i64, Vec<Box<dyn Rule>>>,
     pub(crate) types: Vec<i64>,
     pub(crate) current_offset: i64,
     pub(crate) current_type: i64,
@@ -14,7 +14,7 @@ pub struct RuleSetIterator {
 }
 
 impl RuleSetIterator {
-    pub fn new(rules: IndexMap<i64, Vec<Rule>>) -> Self {
+    pub fn new(rules: IndexMap<i64, Vec<Box<dyn Rule>>>) -> Self {
         let mut types: Vec<i64> = rules.keys().copied().collect();
         types.sort();
         let mut iter = Self {
@@ -28,8 +28,8 @@ impl RuleSetIterator {
         iter
     }
 
-    pub fn current(&self) -> &Rule {
-        &self.rules[&self.current_type][self.current_offset as usize]
+    pub fn current(&self) -> &dyn Rule {
+        &*self.rules[&self.current_type][self.current_offset as usize]
     }
 
     pub fn key(&self) -> i64 {
diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index 388cccd..d5f4ccd 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -37,13 +37,13 @@ pub struct Solver {
 
     pub(crate) watch_graph: RuleWatchGraph,
     pub(crate) decisions: Decisions,
-    pub(crate) fixed_map: IndexMap<i64, Box<BasePackage>>,
+    pub(crate) fixed_map: IndexMap<i64, Box<dyn BasePackage>>,
 
     pub(crate) propagate_index: i64,
     /// Pairs of `(literals, level)` — PHP indexes into these with the BRANCH_* constants.
     pub(crate) branches: Vec<(Vec<i64>, i64)>,
     pub(crate) problems: Vec<Problem>,
-    pub(crate) learned_pool: Vec<Vec<Rule>>,
+    pub(crate) learned_pool: Vec<Vec<Box<dyn Rule>>>,
     pub(crate) learned_why: IndexMap<String, i64>,
 
     pub test_flag_learned_positive_literal: bool,
@@ -292,7 +292,7 @@ impl Solver {
     /// If we find unit rules we make new decisions based on them
     ///
     /// Returns a `Rule` on conflict, otherwise `None`.
-    fn propagate(&mut self, level: i64) -> Option<Rule> {
+    fn propagate(&mut self, level: i64) -> Option<Box<dyn Rule>> {
         while self.decisions.valid_offset(self.propagate_index) {
             let decision = self
                 .decisions
@@ -349,7 +349,12 @@ impl Solver {
     /// rule (always unit) and re-propagate.
     ///
     /// returns the new solver level or 0 if unsolvable
-    fn set_propagate_learn(&mut self, level: i64, literal: i64, rule: Rule) -> anyhow::Result<i64> {
+    fn set_propagate_learn(
+        &mut self,
+        level: i64,
+        literal: i64,
+        rule: Box<dyn Rule>,
+    ) -> anyhow::Result<i64> {
         let mut level = level + 1;
 
         self.decisions.decide(literal, level, rule);
@@ -401,7 +406,7 @@ impl Solver {
         &mut self,
         level: i64,
         decision_queue: Vec<i64>,
-        rule: Rule,
+        rule: Box<dyn Rule>,
     ) -> anyhow::Result<i64> {
         // choose best package to install from decisionQueue
         let mut literals = self.policy.select_preferred_packages(
@@ -420,7 +425,11 @@ impl Solver {
         self.set_propagate_learn(level, selected_literal, rule)
     }
 
-    fn analyze(&mut self, level: i64, rule: Rule) -> anyhow::Result<(i64, i64, GenericRule, i64)> {
+    fn analyze(
+        &mut self,
+        level: i64,
+        rule: Box<dyn Rule>,
+    ) -> anyhow::Result<(i64, i64, GenericRule, i64)> {
         let analyzed_rule = rule.clone();
         let mut rule = rule;
         let mut rule_level = 1_i64;
@@ -591,7 +600,7 @@ impl Solver {
     fn analyze_unsolvable_rule(
         &self,
         problem: &mut Problem,
-        conflict_rule: &Rule,
+        conflict_rule: &dyn Rule,
         rule_seen: &mut IndexMap<String, bool>,
     ) {
         let why = spl_object_hash(conflict_rule);
@@ -619,7 +628,7 @@ impl Solver {
         problem.add_rule(conflict_rule.clone());
     }
 
-    fn analyze_unsolvable(&mut self, conflict_rule: &Rule) {
+    fn analyze_unsolvable(&mut self, conflict_rule: &dyn Rule) {
         let mut problem = Problem::new();
         problem.add_rule(conflict_rule.clone());
 
diff --git a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
index ddc8746..d739991 100644
--- a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
+++ b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs
@@ -13,13 +13,13 @@ use crate::util::ini_helper::IniHelper;
 pub struct SolverProblemsException {
     inner: RuntimeException,
     pub(crate) problems: Vec<Problem>,
-    pub(crate) learned_pool: Vec<Vec<Rule>>,
+    pub(crate) learned_pool: Vec<Vec<Box<dyn Rule>>>,
 }
 
 impl SolverProblemsException {
     pub const ERROR_DEPENDENCY_RESOLUTION_FAILED: i64 = 2;
 
-    pub fn new(problems: Vec<Problem>, learned_pool: Vec<Vec<Rule>>) -> Self {
+    pub fn new(problems: Vec<Problem>, learned_pool: Vec<Vec<Box<dyn Rule>>>) -> Self {
         let message = format!(
             "Failed resolving dependencies with {} problems, call getPrettyString to get formatted details",
             problems.len()
@@ -143,7 +143,7 @@ impl SolverProblemsException {
         text
     }
 
-    fn get_extension_problems(&self, reason_sets: Vec<Vec<Rule>>) -> Vec<String> {
+    fn get_extension_problems(&self, reason_sets: Vec<Vec<Box<dyn Rule>>>) -> Vec<String> {
         let mut missing_extensions: indexmap::IndexMap<String, i64> = indexmap::IndexMap::new();
         for reason_set in reason_sets {
             for rule in reason_set {