diff options
Diffstat (limited to 'crates/shirabe/src/dependency_resolver')
10 files changed, 68 insertions, 70 deletions
diff --git a/crates/shirabe/src/dependency_resolver/default_policy.rs b/crates/shirabe/src/dependency_resolver/default_policy.rs index d56a96c5..e7d02e24 100644 --- a/crates/shirabe/src/dependency_resolver/default_policy.rs +++ b/crates/shirabe/src/dependency_resolver/default_policy.rs @@ -8,7 +8,6 @@ use crate::util::Platform; use indexmap::IndexMap; use shirabe_semver::CompilingMatcher; use shirabe_semver::constraint::SimpleConstraint; -use std::cell::RefCell; #[derive(Debug)] pub struct DefaultPolicy { @@ -16,8 +15,9 @@ pub struct DefaultPolicy { prefer_lowest: bool, prefer_dev_over_prerelease: bool, preferred_versions: Option<IndexMap<String, String>>, - preferred_package_result_cache_per_pool: RefCell<IndexMap<i64, IndexMap<String, Vec<i64>>>>, - sorting_cache_per_pool: RefCell<IndexMap<i64, IndexMap<String, i64>>>, + preferred_package_result_cache_per_pool: + std::cell::RefCell<IndexMap<i64, IndexMap<String, Vec<i64>>>>, + sorting_cache_per_pool: std::cell::RefCell<IndexMap<i64, IndexMap<String, i64>>>, } impl DefaultPolicy { @@ -33,8 +33,8 @@ impl DefaultPolicy { prefer_dev_over_prerelease: Platform::get_env("COMPOSER_PREFER_DEV_OVER_PRERELEASE") .map(|v| !v.is_empty()) .unwrap_or(false), - preferred_package_result_cache_per_pool: RefCell::new(IndexMap::new()), - sorting_cache_per_pool: RefCell::new(IndexMap::new()), + preferred_package_result_cache_per_pool: std::cell::RefCell::new(IndexMap::new()), + sorting_cache_per_pool: std::cell::RefCell::new(IndexMap::new()), } } diff --git a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs index 6238ddbe..789d0aed 100644 --- a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs +++ b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs @@ -12,13 +12,12 @@ use shirabe_semver::Intervals; use shirabe_semver::constraint::AnyConstraint; use shirabe_semver::constraint::MultiConstraint; use shirabe_semver::constraint::SimpleConstraint; -use std::rc::Rc; /// Optimizes a given pool #[derive(Debug)] pub struct PoolOptimizer { /// @var PolicyInterface - policy: Rc<dyn PolicyInterface>, + policy: std::rc::Rc<dyn PolicyInterface>, /// @var array<int, true> irremovable_packages: IndexMap<i64, bool>, @@ -46,7 +45,7 @@ struct IdenticalDefinitionPointers { } impl PoolOptimizer { - pub fn new(policy: Rc<dyn PolicyInterface>) -> Self { + pub fn new(policy: std::rc::Rc<dyn PolicyInterface>) -> Self { Self { policy, irremovable_packages: IndexMap::new(), diff --git a/crates/shirabe/src/dependency_resolver/rule.rs b/crates/shirabe/src/dependency_resolver/rule.rs index ab4eeb0c..e1572b0b 100644 --- a/crates/shirabe/src/dependency_resolver/rule.rs +++ b/crates/shirabe/src/dependency_resolver/rule.rs @@ -18,8 +18,6 @@ use shirabe_php_shim::{ }; use shirabe_semver::constraint::AnyConstraint; use shirabe_semver::constraint::SimpleConstraint; -use std::cell::RefCell; -use std::rc::Rc; #[derive(Debug)] pub enum ReasonData { @@ -323,7 +321,7 @@ impl Rule { pool: &mut Pool, is_verbose: bool, installed_map: &IndexMap<String, BasePackageHandle>, - _learned_pool: &Vec<Vec<Rc<RefCell<Rule>>>>, + _learned_pool: &Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, ) -> anyhow::Result<String> { let mut literals = self.get_literals(); diff --git a/crates/shirabe/src/dependency_resolver/rule_set.rs b/crates/shirabe/src/dependency_resolver/rule_set.rs index cde4ebca..f7300d93 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set.rs @@ -7,15 +7,13 @@ use crate::dependency_resolver::RuleSetIterator; use crate::repository::RepositorySet; use indexmap::IndexMap; use shirabe_php_shim::OutOfBoundsException; -use std::cell::RefCell; -use std::rc::Rc; #[derive(Debug)] pub struct RuleSet { - pub rule_by_id: IndexMap<i64, Rc<RefCell<Rule>>>, - pub(crate) rules: IndexMap<i64, Vec<Rc<RefCell<Rule>>>>, + pub rule_by_id: IndexMap<i64, std::rc::Rc<std::cell::RefCell<Rule>>>, + pub(crate) rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, pub(crate) next_rule_id: i64, - pub(crate) rules_by_hash: IndexMap<String, Vec<Rc<RefCell<Rule>>>>, + pub(crate) rules_by_hash: IndexMap<String, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, } impl Default for RuleSet { @@ -54,7 +52,11 @@ impl RuleSet { Self::types().into_keys().collect() } - pub fn add(&mut self, rule: Rc<RefCell<Rule>>, r#type: i64) -> anyhow::Result<()> { + pub fn add( + &mut self, + rule: std::rc::Rc<std::cell::RefCell<Rule>>, + r#type: i64, + ) -> anyhow::Result<()> { let types = Self::types(); if !types.contains_key(&r#type) { return Err(OutOfBoundsException { @@ -92,11 +94,11 @@ impl RuleSet { self.next_rule_id } - pub fn rule_by_id(&self, id: i64) -> Rc<RefCell<Rule>> { + pub fn rule_by_id(&self, id: i64) -> std::rc::Rc<std::cell::RefCell<Rule>> { self.rule_by_id[&id].clone() } - pub fn get_rules(&self) -> &IndexMap<i64, Vec<Rc<RefCell<Rule>>>> { + pub fn get_rules(&self) -> &IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>> { &self.rules } @@ -105,7 +107,7 @@ impl RuleSet { } pub fn get_iterator_for(&self, types: Vec<i64>) -> RuleSetIterator { - let mut rules: IndexMap<i64, Vec<Rc<RefCell<Rule>>>> = IndexMap::new(); + let mut rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>> = IndexMap::new(); for r#type in types { if let Some(rules_for_type) = self.rules.get(&r#type) { rules.insert(r#type, rules_for_type.clone()); @@ -115,7 +117,7 @@ impl RuleSet { } pub fn get_iterator_without(&self, types: Vec<i64>) -> RuleSetIterator { - let mut rules: IndexMap<i64, Vec<Rc<RefCell<Rule>>>> = IndexMap::new(); + let mut rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>> = IndexMap::new(); for (r#type, rules_for_type) in &self.rules { if types.contains(r#type) { continue; diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs index 6c2824e4..2f4837d4 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs @@ -13,13 +13,11 @@ use crate::filter::platform_requirement_filter::PlatformRequirementFilterFactory use crate::filter::platform_requirement_filter::PlatformRequirementFilterInterface; use crate::package::PackageInterfaceHandle; use indexmap::IndexMap; -use std::cell::RefCell; use std::collections::VecDeque; -use std::rc::Rc; #[derive(Debug)] pub struct RuleSetGenerator { - pub(crate) policy: Rc<dyn PolicyInterface>, + pub(crate) policy: std::rc::Rc<dyn PolicyInterface>, pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>, pub(crate) rules: RuleSet, pub(crate) added_map: IndexMap<i64, PackageInterfaceHandle>, @@ -28,7 +26,7 @@ pub struct RuleSetGenerator { impl RuleSetGenerator { pub fn new( - policy: Rc<dyn PolicyInterface>, + policy: std::rc::Rc<dyn PolicyInterface>, pool: std::rc::Rc<std::cell::RefCell<Pool>>, ) -> Self { Self { @@ -128,7 +126,9 @@ impl RuleSetGenerator { /// methods null is allowed which will not insert a rule. fn add_rule(&mut self, r#type: i64, new_rule: Option<Rule>) { if let Some(rule) = new_rule { - self.rules.add(Rc::new(RefCell::new(rule)), r#type).ok(); + self.rules + .add(std::rc::Rc::new(std::cell::RefCell::new(rule)), r#type) + .ok(); } } @@ -397,7 +397,7 @@ impl RuleSetGenerator { pub fn get_rules_for( &mut self, request: &Request, - platform_requirement_filter: Option<Rc<dyn PlatformRequirementFilterInterface>>, + platform_requirement_filter: Option<std::rc::Rc<dyn PlatformRequirementFilterInterface>>, ) -> anyhow::Result<RuleSet> { let platform_requirement_filter = platform_requirement_filter .unwrap_or_else(PlatformRequirementFilterFactory::ignore_nothing); diff --git a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs index 2c4b9a45..b469a193 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs @@ -2,13 +2,11 @@ use crate::dependency_resolver::Rule; use indexmap::IndexMap; -use std::cell::RefCell; -use std::rc::Rc; /// Implements PHP \Iterator over a grouped rule set. #[derive(Debug)] pub struct RuleSetIterator { - pub(crate) rules: IndexMap<i64, Vec<Rc<RefCell<Rule>>>>, + pub(crate) rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, pub(crate) types: Vec<i64>, pub(crate) current_offset: i64, pub(crate) current_type: i64, @@ -16,7 +14,7 @@ pub struct RuleSetIterator { } impl RuleSetIterator { - pub fn new(rules: IndexMap<i64, Vec<Rc<RefCell<Rule>>>>) -> Self { + pub fn new(rules: IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>) -> Self { let mut types: Vec<i64> = rules.keys().copied().collect(); types.sort(); let mut iter = Self { @@ -30,7 +28,7 @@ impl RuleSetIterator { iter } - pub fn current(&self) -> Rc<RefCell<Rule>> { + pub fn current(&self) -> std::rc::Rc<std::cell::RefCell<Rule>> { self.rules[&self.current_type][self.current_offset as usize].clone() } diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs index b746f504..6646490b 100644 --- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs +++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs @@ -5,8 +5,6 @@ use crate::dependency_resolver::Rule; use crate::dependency_resolver::RuleWatchChain; use crate::dependency_resolver::RuleWatchNode; use indexmap::IndexMap; -use std::cell::RefCell; -use std::rc::Rc; #[derive(Debug)] pub struct RuleWatchGraph { @@ -26,7 +24,7 @@ impl RuleWatchGraph { } } - pub fn insert(&mut self, node: Rc<RefCell<RuleWatchNode>>) { + pub fn insert(&mut self, node: std::rc::Rc<std::cell::RefCell<RuleWatchNode>>) { if node.borrow().get_rule().borrow().is_assertion() { return; } @@ -64,7 +62,7 @@ impl RuleWatchGraph { decided_literal: i64, level: i64, decisions: &mut Decisions, - ) -> Option<Rc<RefCell<Rule>>> { + ) -> Option<std::rc::Rc<std::cell::RefCell<Rule>>> { let literal = -decided_literal; if !self.watch_chains.contains_key(&literal) { @@ -127,7 +125,7 @@ impl RuleWatchGraph { &mut self, from_literal: i64, to_literal: i64, - node: Rc<RefCell<RuleWatchNode>>, + node: std::rc::Rc<std::cell::RefCell<RuleWatchNode>>, ) { if !self.watch_chains.contains_key(&to_literal) { self.watch_chains.insert(to_literal, RuleWatchChain::new()); diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs index 92faae72..b11c1771 100644 --- a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs +++ b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs @@ -2,13 +2,11 @@ use crate::dependency_resolver::Decisions; use crate::dependency_resolver::Rule; -use std::cell::RefCell; -use std::rc::Rc; pub struct RuleWatchNode { pub watch1: i64, pub watch2: i64, - pub(crate) rule: Rc<RefCell<Rule>>, + pub(crate) rule: std::rc::Rc<std::cell::RefCell<Rule>>, } impl std::fmt::Debug for RuleWatchNode { @@ -21,7 +19,7 @@ impl std::fmt::Debug for RuleWatchNode { } impl RuleWatchNode { - pub fn new(rule: Rc<RefCell<Rule>>) -> Self { + pub fn new(rule: std::rc::Rc<std::cell::RefCell<Rule>>) -> Self { let literals = rule.borrow().get_literals(); let literal_count = literals.len(); let watch1 = if literal_count > 0 { literals[0] } else { 0 }; @@ -54,7 +52,7 @@ impl RuleWatchNode { } } - pub fn get_rule(&self) -> Rc<RefCell<Rule>> { + pub fn get_rule(&self) -> std::rc::Rc<std::cell::RefCell<Rule>> { self.rule.clone() } diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs index 933f79f5..960cd7a6 100644 --- a/crates/shirabe/src/dependency_resolver/solver.rs +++ b/crates/shirabe/src/dependency_resolver/solver.rs @@ -23,12 +23,10 @@ use crate::package::BasePackageHandle; use indexmap::IndexMap; use shirabe_php_shim::{array_shift, array_unshift, microtime, spl_object_hash}; use shirabe_semver::constraint::AnyConstraint; -use std::cell::RefCell; -use std::rc::Rc; #[derive(Debug)] pub struct Solver { - pub(crate) policy: Rc<dyn PolicyInterface>, + pub(crate) policy: std::rc::Rc<dyn PolicyInterface>, pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>, pub(crate) rules: RuleSet, @@ -41,7 +39,7 @@ pub struct Solver { /// 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<Rc<RefCell<Rule>>>>, + pub(crate) learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, pub(crate) learned_why: IndexMap<String, i64>, pub test_flag_learned_positive_literal: bool, @@ -54,7 +52,7 @@ impl Solver { const BRANCH_LEVEL: usize = 1; pub fn new( - policy: Rc<dyn PolicyInterface>, + policy: std::rc::Rc<dyn PolicyInterface>, pool: std::rc::Rc<std::cell::RefCell<Pool>>, io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>, ) -> Self { @@ -205,14 +203,16 @@ impl Solver { .is_empty() { let mut problem = Problem::new(); - problem.add_rule(Rc::new(RefCell::new(Rule::Generic(GenericRule::new( - Vec::new(), - rule::RULE_ROOT_REQUIRE, - rule::ReasonData::RootRequire { - package_name: package_name.clone(), - constraint: active_constraint.clone(), - }, - ))))); + problem.add_rule(std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic( + GenericRule::new( + Vec::new(), + rule::RULE_ROOT_REQUIRE, + rule::ReasonData::RootRequire { + package_name: package_name.clone(), + constraint: active_constraint.clone(), + }, + ), + )))); self.problems.push(problem); } } @@ -223,7 +223,7 @@ impl Solver { pub fn solve( &mut self, request: &Request, - platform_requirement_filter: Option<Rc<dyn PlatformRequirementFilterInterface>>, + platform_requirement_filter: Option<std::rc::Rc<dyn PlatformRequirementFilterInterface>>, ) -> anyhow::Result<Result<LockTransaction, SolverProblemsException>> { let platform_requirement_filter = platform_requirement_filter .unwrap_or_else(|| PlatformRequirementFilterFactory::ignore_nothing()); @@ -244,7 +244,9 @@ impl Solver { while iterator.valid() { let rule = iterator.current(); self.watch_graph - .insert(Rc::new(RefCell::new(RuleWatchNode::new(rule)))); + .insert(std::rc::Rc::new(std::cell::RefCell::new( + RuleWatchNode::new(rule), + ))); iterator.next(); } @@ -293,7 +295,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<Rc<RefCell<Rule>>> { + fn propagate(&mut self, level: i64) -> Option<std::rc::Rc<std::cell::RefCell<Rule>>> { while self.decisions.valid_offset(self.propagate_index) { let decision = self .decisions @@ -354,7 +356,7 @@ impl Solver { &mut self, level: i64, literal: i64, - rule: Rc<RefCell<Rule>>, + rule: std::rc::Rc<std::cell::RefCell<Rule>>, ) -> anyhow::Result<i64> { let mut level = level + 1; @@ -390,13 +392,15 @@ impl Solver { // The same learned rule instance is shared between RuleSet, // RuleWatchGraph, and Decisions (PHP shares one object). - let new_rule = Rc::new(RefCell::new(Rule::Generic(new_rule))); + let new_rule = std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(new_rule))); self.rules.add(new_rule.clone(), RuleSet::TYPE_LEARNED)?; self.learned_why .insert(spl_object_hash(&*new_rule.borrow()), why); - let rule_node = Rc::new(RefCell::new(RuleWatchNode::new(new_rule.clone()))); + let rule_node = std::rc::Rc::new(std::cell::RefCell::new(RuleWatchNode::new( + new_rule.clone(), + ))); rule_node.borrow_mut().watch2_on_highest(&self.decisions); self.watch_graph.insert(rule_node); @@ -410,7 +414,7 @@ impl Solver { &mut self, level: i64, decision_queue: Vec<i64>, - rule: Rc<RefCell<Rule>>, + rule: std::rc::Rc<std::cell::RefCell<Rule>>, ) -> anyhow::Result<i64> { // choose best package to install from decisionQueue let mut literals = self.policy.select_preferred_packages( @@ -433,7 +437,7 @@ impl Solver { fn analyze( &mut self, level: i64, - rule: Rc<RefCell<Rule>>, + rule: std::rc::Rc<std::cell::RefCell<Rule>>, ) -> anyhow::Result<(i64, i64, GenericRule, i64)> { let analyzed_rule = rule.clone(); let mut rule = rule; @@ -602,7 +606,7 @@ impl Solver { fn analyze_unsolvable_rule( &self, problem: &mut Problem, - conflict_rule: Rc<RefCell<Rule>>, + conflict_rule: std::rc::Rc<std::cell::RefCell<Rule>>, rule_seen: &mut IndexMap<String, bool>, ) { let why = spl_object_hash(&*conflict_rule.borrow()); @@ -630,7 +634,7 @@ impl Solver { problem.add_rule(conflict_rule); } - fn analyze_unsolvable(&mut self, conflict_rule: Rc<RefCell<Rule>>) { + fn analyze_unsolvable(&mut self, conflict_rule: std::rc::Rc<std::cell::RefCell<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 b0016d07..48fe76b3 100644 --- a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs +++ b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs @@ -7,14 +7,12 @@ use crate::dependency_resolver::Rule; use crate::repository::RepositorySet; use crate::util::IniHelper; use shirabe_php_shim::RuntimeException; -use std::cell::RefCell; -use std::rc::Rc; #[derive(Debug)] pub struct SolverProblemsException { inner: RuntimeException, pub(crate) problems: Vec<Problem>, - pub(crate) learned_pool: Vec<Vec<Rc<RefCell<Rule>>>>, + pub(crate) learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, } impl SolverProblemsException { @@ -28,7 +26,10 @@ impl SolverProblemsException { &self.inner.message } - pub fn new(problems: Vec<Problem>, learned_pool: Vec<Vec<Rc<RefCell<Rule>>>>) -> Self { + pub fn new( + problems: Vec<Problem>, + learned_pool: Vec<Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, + ) -> Self { let message = format!( "Failed resolving dependencies with {} problems, call getPrettyString to get formatted details", problems.len() @@ -154,7 +155,7 @@ impl SolverProblemsException { fn get_extension_problems( &self, - reason_sets: &indexmap::IndexMap<i64, Vec<Rc<RefCell<Rule>>>>, + reason_sets: &indexmap::IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>, ) -> Vec<String> { let mut missing_extensions: indexmap::IndexMap<String, i64> = indexmap::IndexMap::new(); for reason_set in reason_sets.values() { |