chore: use fully-qualified name for Rc/RefCell

5 files changed, 51 insertions, 48 deletions

diff --git a/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs b/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
index 548cb0dc..e6897ff7 100644
--- a/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/pool_builder_test.rs
@@ -22,9 +22,7 @@ use shirabe::repository::repository_set::{RepositorySet, RootAliasInput};
 use shirabe_external_packages::composer::pcre::preg::Preg;
 use shirabe_php_shim::PREG_SPLIT_DELIM_CAPTURE;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
 use std::path::PathBuf;
-use std::rc::Rc;
 
 /// Maps the PHP `$loadPackage` closure: pops the optional `id` from the data, loads the
 /// package and records it in `package_ids` keyed by that id (erroring on duplicates).
@@ -451,8 +449,9 @@ fn run_test_pool_builder(
         IndexMap::new(),
         IndexMap::new(),
     );
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
     let mut rm = RepositoryFactory::manager(io.clone(), &config, None, None, None).unwrap();
 
     // PHP: foreach ($packageRepos as $packages)
@@ -605,7 +604,8 @@ fn run_test_pool_builder(
         message
     );
 
-    let mut optimizer = PoolOptimizer::new(Rc::new(DefaultPolicy::new(false, false, None)));
+    let mut optimizer =
+        PoolOptimizer::new(std::rc::Rc::new(DefaultPolicy::new(false, false, None)));
     let optimized = optimizer.optimize(&request, &pool);
     let mut result = get_package_result_set(&optimized, &package_ids);
     let mut expect_optimized = expect_optimized.as_list().unwrap().clone();
diff --git a/crates/shirabe/tests/dependency_resolver/pool_optimizer_test.rs b/crates/shirabe/tests/dependency_resolver/pool_optimizer_test.rs
index 3c4952e7..08d5f989 100644
--- a/crates/shirabe/tests/dependency_resolver/pool_optimizer_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/pool_optimizer_test.rs
@@ -15,7 +15,6 @@ use shirabe_external_packages::composer::pcre::preg::Preg;
 use shirabe_php_shim::PREG_SPLIT_DELIM_CAPTURE;
 use shirabe_php_shim::PhpMixed;
 use std::path::PathBuf;
-use std::rc::Rc;
 
 fn load_package(package_data: &PhpMixed) -> BasePackageHandle {
     let loader = ArrayLoader::new(None, false);
@@ -237,7 +236,7 @@ fn run_test_pool_optimizer(
         IndexMap::new(),
         IndexMap::new(),
     );
-    let mut pool_optimizer = PoolOptimizer::new(Rc::new(DefaultPolicy::new(
+    let mut pool_optimizer = PoolOptimizer::new(std::rc::Rc::new(DefaultPolicy::new(
         prefer_stable,
         prefer_lowest,
         None,
diff --git a/crates/shirabe/tests/dependency_resolver/rule_set_iterator_test.rs b/crates/shirabe/tests/dependency_resolver/rule_set_iterator_test.rs
index 9c9f85bd..93e25962 100644
--- a/crates/shirabe/tests/dependency_resolver/rule_set_iterator_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/rule_set_iterator_test.rs
@@ -7,13 +7,11 @@ use shirabe::dependency_resolver::rule::{RULE_LEARNED, RULE_ROOT_REQUIRE, Reason
 use shirabe::dependency_resolver::rule_set::RuleSet;
 use shirabe::dependency_resolver::rule_set_iterator::RuleSetIterator;
 use shirabe_semver::constraint::MatchAllConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
-type Rules = IndexMap<i64, Vec<Rc<RefCell<Rule>>>>;
+type Rules = IndexMap<i64, Vec<std::rc::Rc<std::cell::RefCell<Rule>>>>;
 
-fn root_require_rule() -> Rc<RefCell<Rule>> {
-    Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
+fn root_require_rule() -> std::rc::Rc<std::cell::RefCell<Rule>> {
+    std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(GenericRule::new(
         vec![],
         RULE_ROOT_REQUIRE,
         ReasonData::RootRequire {
@@ -40,11 +38,9 @@ fn set_up() -> (Pool, Rules) {
     );
     rules.insert(
         RuleSet::TYPE_LEARNED,
-        vec![Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
-            vec![],
-            RULE_LEARNED,
-            ReasonData::Int(1),
-        ))))],
+        vec![std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(
+            GenericRule::new(vec![], RULE_LEARNED, ReasonData::Int(1)),
+        )))],
     );
     rules.insert(RuleSet::TYPE_PACKAGE, vec![]);
 
@@ -56,7 +52,7 @@ fn test_foreach() {
     let (_pool, rules) = set_up();
     let mut rule_set_iterator = RuleSetIterator::new(rules.clone());
 
-    let mut result: Vec<Rc<RefCell<Rule>>> = Vec::new();
+    let mut result: Vec<std::rc::Rc<std::cell::RefCell<Rule>>> = Vec::new();
     while rule_set_iterator.valid() {
         result.push(rule_set_iterator.current());
         rule_set_iterator.next();
@@ -70,7 +66,7 @@ fn test_foreach() {
 
     assert_eq!(expected.len(), result.len());
     for (e, r) in expected.iter().zip(result.iter()) {
-        assert!(Rc::ptr_eq(e, r));
+        assert!(std::rc::Rc::ptr_eq(e, r));
     }
 }
 
diff --git a/crates/shirabe/tests/dependency_resolver/rule_set_test.rs b/crates/shirabe/tests/dependency_resolver/rule_set_test.rs
index 3ed974e6..0a9582dc 100644
--- a/crates/shirabe/tests/dependency_resolver/rule_set_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/rule_set_test.rs
@@ -7,8 +7,6 @@ use shirabe::dependency_resolver::{
 };
 use shirabe::repository::RepositorySet;
 use shirabe_semver::constraint::{MatchAllConstraint, MatchNoneConstraint};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn root_require_reason() -> ReasonData {
     ReasonData::RootRequire {
@@ -17,16 +15,16 @@ fn root_require_reason() -> ReasonData {
     }
 }
 
-fn rule(literals: Vec<i64>) -> Rc<RefCell<Rule>> {
-    Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
+fn rule(literals: Vec<i64>) -> std::rc::Rc<std::cell::RefCell<Rule>> {
+    std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(GenericRule::new(
         literals,
         RULE_ROOT_REQUIRE,
         root_require_reason(),
     ))))
 }
 
-fn learned_rule() -> Rc<RefCell<Rule>> {
-    Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
+fn learned_rule() -> std::rc::Rc<std::cell::RefCell<Rule>> {
+    std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(GenericRule::new(
         vec![],
         RULE_LEARNED,
         ReasonData::Int(1),
@@ -67,11 +65,11 @@ fn test_add() {
     );
     let request = &rules[&RuleSet::TYPE_REQUEST];
     assert_eq!(2, request.len());
-    assert!(Rc::ptr_eq(&request[0], &request0));
-    assert!(Rc::ptr_eq(&request[1], &request1));
+    assert!(std::rc::Rc::ptr_eq(&request[0], &request0));
+    assert!(std::rc::Rc::ptr_eq(&request[1], &request1));
     let learned = &rules[&RuleSet::TYPE_LEARNED];
     assert_eq!(1, learned.len());
-    assert!(Rc::ptr_eq(&learned[0], &learned0));
+    assert!(std::rc::Rc::ptr_eq(&learned[0], &learned0));
 }
 
 #[test]
@@ -110,7 +108,7 @@ fn test_rule_by_id() {
     let rule = rule(vec![]);
     rule_set.add(rule.clone(), RuleSet::TYPE_REQUEST).unwrap();
 
-    assert!(Rc::ptr_eq(&rule_set.rule_by_id[&0], &rule));
+    assert!(std::rc::Rc::ptr_eq(&rule_set.rule_by_id[&0], &rule));
 }
 
 #[test]
@@ -122,9 +120,9 @@ fn test_get_iterator() {
     rule_set.add(rule2.clone(), RuleSet::TYPE_LEARNED).unwrap();
 
     let mut iterator = rule_set.get_iterator();
-    assert!(Rc::ptr_eq(&iterator.current(), &rule1));
+    assert!(std::rc::Rc::ptr_eq(&iterator.current(), &rule1));
     iterator.next();
-    assert!(Rc::ptr_eq(&iterator.current(), &rule2));
+    assert!(std::rc::Rc::ptr_eq(&iterator.current(), &rule2));
 }
 
 #[test]
@@ -136,7 +134,7 @@ fn test_get_iterator_for() {
     rule_set.add(rule2.clone(), RuleSet::TYPE_LEARNED).unwrap();
 
     let iterator = rule_set.get_iterator_for(vec![RuleSet::TYPE_LEARNED]);
-    assert!(Rc::ptr_eq(&iterator.current(), &rule2));
+    assert!(std::rc::Rc::ptr_eq(&iterator.current(), &rule2));
 }
 
 #[test]
@@ -148,7 +146,7 @@ fn test_get_iterator_without() {
     rule_set.add(rule2.clone(), RuleSet::TYPE_LEARNED).unwrap();
 
     let iterator = rule_set.get_iterator_without(vec![RuleSet::TYPE_REQUEST]);
-    assert!(Rc::ptr_eq(&iterator.current(), &rule2));
+    assert!(std::rc::Rc::ptr_eq(&iterator.current(), &rule2));
 }
 
 // The constraint is MatchNoneConstraint, so what_provides returns no packages and the
@@ -178,7 +176,7 @@ fn test_pretty_string() {
 
     let mut rule_set = RuleSet::new();
     let literal = p.get_id();
-    let rule = Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
+    let rule = std::rc::Rc::new(std::cell::RefCell::new(Rule::Generic(GenericRule::new(
         vec![literal],
         RULE_ROOT_REQUIRE,
         ReasonData::RootRequire {
diff --git a/crates/shirabe/tests/dependency_resolver/solver_test.rs b/crates/shirabe/tests/dependency_resolver/solver_test.rs
index c20fd4c5..b8be2287 100644
--- a/crates/shirabe/tests/dependency_resolver/solver_test.rs
+++ b/crates/shirabe/tests/dependency_resolver/solver_test.rs
@@ -16,8 +16,6 @@ use shirabe::repository::handle::{LockArrayRepositoryHandle, RepositoryInterface
 use shirabe::repository::lock_array_repository::LockArrayRepository;
 use shirabe::repository::repository_set::RepositorySet;
 use shirabe_semver::constraint::{AnyConstraint, MatchAllConstraint, MultiConstraint};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[allow(dead_code)]
 struct Fixtures {
@@ -122,13 +120,18 @@ fn check_solver_result_repo_set(
     expected: Vec<ExpectedJob>,
 ) {
     // createSolver()
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
     let pool = repo_set
         .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
         .unwrap();
-    let policy: Rc<dyn PolicyInterface> = Rc::new(DefaultPolicy::new(false, false, None));
-    let mut solver =
-        shirabe::dependency_resolver::solver::Solver::new(policy, Rc::new(RefCell::new(pool)), io);
+    let policy: std::rc::Rc<dyn PolicyInterface> =
+        std::rc::Rc::new(DefaultPolicy::new(false, false, None));
+    let mut solver = shirabe::dependency_resolver::solver::Solver::new(
+        policy,
+        std::rc::Rc::new(std::cell::RefCell::new(pool)),
+        io,
+    );
 
     let transaction = solver.solve(&request, None).unwrap().unwrap();
 
@@ -197,7 +200,7 @@ struct SolveError {
     exception: SolverProblemsException,
     repo_set: RepositorySet,
     request: Request,
-    pool: Rc<RefCell<Pool>>,
+    pool: std::rc::Rc<std::cell::RefCell<Pool>>,
 }
 
 /// ref: SolverTest::createSolver + solve, returning the caught SolverProblemsException.
@@ -212,13 +215,15 @@ fn solve_expecting_problems(
         .unwrap();
     repo_set.add_repository(repo_locked.into()).unwrap();
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let pool = Rc::new(RefCell::new(
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let pool = std::rc::Rc::new(std::cell::RefCell::new(
         repo_set
             .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
             .unwrap(),
     ));
-    let policy: Rc<dyn PolicyInterface> = Rc::new(DefaultPolicy::new(false, false, None));
+    let policy: std::rc::Rc<dyn PolicyInterface> =
+        std::rc::Rc::new(DefaultPolicy::new(false, false, None));
     let mut solver = shirabe::dependency_resolver::solver::Solver::new(policy, pool.clone(), io);
 
     let exception = match solver.solve(&request, None).unwrap() {
@@ -2489,13 +2494,18 @@ fn test_learn_positive_literal() {
     let mut request = fixtures.request;
     request.require_name("A", None).unwrap();
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
     let pool = repo_set
         .create_pool(&mut request, io.clone(), None, None, vec![], None, None)
         .unwrap();
-    let policy: Rc<dyn PolicyInterface> = Rc::new(DefaultPolicy::new(false, false, None));
-    let mut solver =
-        shirabe::dependency_resolver::solver::Solver::new(policy, Rc::new(RefCell::new(pool)), io);
+    let policy: std::rc::Rc<dyn PolicyInterface> =
+        std::rc::Rc::new(DefaultPolicy::new(false, false, None));
+    let mut solver = shirabe::dependency_resolver::solver::Solver::new(
+        policy,
+        std::rc::Rc::new(std::cell::RefCell::new(pool)),
+        io,
+    );
 
     // check correct setup for assertion later
     assert!(!solver.test_flag_learned_positive_literal);