chore: use fully-qualified name for Rc/RefCell

132 files changed, 1372 insertions, 1240 deletions

diff --git a/crates/shirabe/src/advisory/auditor.rs b/crates/shirabe/src/advisory/auditor.rs
index 402483c7..32e34380 100644
--- a/crates/shirabe/src/advisory/auditor.rs
+++ b/crates/shirabe/src/advisory/auditor.rs
@@ -18,8 +18,6 @@ use shirabe_php_shim::{
     DATE_ATOM, InvalidArgumentException, PhpMixed, array_all, array_any, array_key_exists,
     array_keys, array_reduce, get_class, sprintf, str_starts_with,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// Shape of the `--format=json` audit output.
 #[derive(serde::Serialize)]
@@ -115,7 +113,7 @@ impl Auditor {
     #[allow(clippy::too_many_arguments, reason = "to keep PHP signature")]
     pub fn audit(
         &self,
-        io: &Rc<RefCell<dyn IOInterface>>,
+        io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         repo_set: &RepositorySet,
         packages: Vec<PackageInterfaceHandle>,
         format: &str,
@@ -428,7 +426,7 @@ impl Auditor {
     /// @param self::FORMAT_* $format The format that will be used to output audit results.
     fn output_advisories(
         &self,
-        io: &Rc<RefCell<dyn IOInterface>>,
+        io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         advisories: &IndexMap<String, Vec<AnySecurityAdvisory>>,
         format: &str,
     ) -> anyhow::Result<()> {
@@ -528,7 +526,7 @@ impl Auditor {
     /// @param array<string, array<SecurityAdvisory>> $advisories
     fn output_advisories_plain(
         &self,
-        io: &Rc<RefCell<dyn IOInterface>>,
+        io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         advisories: &IndexMap<String, Vec<AnySecurityAdvisory>>,
     ) -> anyhow::Result<()> {
         let mut error: Vec<String> = vec![];
@@ -575,7 +573,7 @@ impl Auditor {
     /// @param self::FORMAT_PLAIN|self::FORMAT_TABLE $format
     fn output_abandoned_packages(
         &self,
-        io: &Rc<RefCell<dyn IOInterface>>,
+        io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         packages: &[CompletePackageInterfaceHandle],
         format: &str,
     ) -> anyhow::Result<()> {
diff --git a/crates/shirabe/src/command/about_command.rs b/crates/shirabe/src/command/about_command.rs
index 7983a580..386beebb 100644
--- a/crates/shirabe/src/command/about_command.rs
+++ b/crates/shirabe/src/command/about_command.rs
@@ -7,8 +7,6 @@ use crate::composer;
 use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct AboutCommand {
@@ -43,8 +41,8 @@ impl Command for AboutCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer_version = composer::get_version();
         let _ = (input, output);
@@ -60,8 +58,8 @@ impl Command for AboutCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/archive_command.rs b/crates/shirabe/src/command/archive_command.rs
index 741847a7..2a099c89 100644
--- a/crates/shirabe/src/command/archive_command.rs
+++ b/crates/shirabe/src/command/archive_command.rs
@@ -28,14 +28,12 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{LogicException, get_debug_type};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ArchiveCommand {
     base_command_data: BaseCommandData,
     /// For testing only: partial-mock seam mirroring PHPUnit `onlyMethods(['initialize', 'archive'])`.
-    test_hooks: RefCell<ArchiveCommandTestHooks>,
+    test_hooks: std::cell::RefCell<ArchiveCommandTestHooks>,
 }
 
 /// For testing only: records and stubs for the `ArchiveCommand` partial-mock seam.
@@ -70,7 +68,7 @@ impl ArchiveCommand {
     pub fn new() -> Self {
         let command = ArchiveCommand {
             base_command_data: BaseCommandData::new(None),
-            test_hooks: RefCell::new(ArchiveCommandTestHooks::default()),
+            test_hooks: std::cell::RefCell::new(ArchiveCommandTestHooks::default()),
         };
         command
             .configure()
@@ -104,8 +102,8 @@ impl Command for ArchiveCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.try_composer(None, None);
 
@@ -206,8 +204,8 @@ impl Command for ArchiveCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         if self.test_hooks.borrow().skip_initialize {
             return Ok(());
diff --git a/crates/shirabe/src/command/audit_command.rs b/crates/shirabe/src/command/audit_command.rs
index 236ecdc0..fb56169e 100644
--- a/crates/shirabe/src/command/audit_command.rs
+++ b/crates/shirabe/src/command/audit_command.rs
@@ -19,8 +19,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{
     InvalidArgumentException, PhpMixed, UnexpectedValueException, implode, in_array,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct AuditCommand {
@@ -116,8 +114,8 @@ impl Command for AuditCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let packages = self.get_packages(&composer, input.clone())?;
@@ -220,8 +218,8 @@ impl Command for AuditCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/base_command.rs b/crates/shirabe/src/command/base_command.rs
index 33864964..b80cb2b4 100644
--- a/crates/shirabe/src/command/base_command.rs
+++ b/crates/shirabe/src/command/base_command.rs
@@ -30,8 +30,6 @@ use shirabe_php_shim::{
     InvalidArgumentException, LogicException, PhpMixed, RuntimeException, UnexpectedValueException,
     count, explode, in_array, is_string,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 pub const SUCCESS: i64 = 0;
 pub const FAILURE: i64 = 1;
@@ -42,16 +40,16 @@ pub const INVALID: i64 = 2;
 #[derive(Debug)]
 pub struct BaseCommandData {
     inner: CommandData,
-    pub(crate) composer: RefCell<Option<PartialComposerHandle>>,
-    pub(crate) io: RefCell<Option<Rc<RefCell<dyn IOInterface>>>>,
+    pub(crate) composer: std::cell::RefCell<Option<PartialComposerHandle>>,
+    pub(crate) io: std::cell::RefCell<Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>>,
 }
 
 impl BaseCommandData {
     pub fn new(name: Option<String>) -> Self {
         BaseCommandData {
             inner: CommandData::new(name),
-            composer: RefCell::new(None),
-            io: RefCell::new(None),
+            composer: std::cell::RefCell::new(None),
+            io: std::cell::RefCell::new(None),
         }
     }
 
@@ -152,15 +150,15 @@ pub trait BaseCommand: Command {
     /// Removes the cached composer instance
     fn reset_composer(&self) -> anyhow::Result<()>;
 
-    fn get_io(&self) -> Rc<RefCell<dyn IOInterface>>;
+    fn get_io(&self) -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>>;
 
-    fn set_io(&self, io: Rc<RefCell<dyn IOInterface>>);
+    fn set_io(&self, io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>);
 
     /// Calls {@see Factory::create()} with the given arguments, taking into account flags and default states for disabling scripts and plugins
     fn create_composer_instance(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        io: Rc<RefCell<dyn IOInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         config: Option<IndexMap<String, PhpMixed>>,
         disable_plugins: bool,
         disable_scripts: Option<bool>,
@@ -170,14 +168,14 @@ pub trait BaseCommand: Command {
     fn get_preferred_install_options(
         &self,
         config: &Config,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
         keep_vcs_requires_prefer_source: bool,
     ) -> anyhow::Result<(bool, bool)>;
 
     fn get_platform_requirement_filter(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-    ) -> anyhow::Result<Rc<dyn PlatformRequirementFilterInterface>>;
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+    ) -> anyhow::Result<std::rc::Rc<dyn PlatformRequirementFilterInterface>>;
 
     /// @param array<string> $requirements
     ///
@@ -196,7 +194,11 @@ pub trait BaseCommand: Command {
     ) -> anyhow::Result<Vec<IndexMap<String, String>>>;
 
     /// @param array<TableSeparator|mixed[]> $table
-    fn render_table(&self, table: Vec<PhpMixed>, output: Rc<RefCell<dyn OutputInterface>>);
+    fn render_table(
+        &self,
+        table: Vec<PhpMixed>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
+    );
 
     fn get_terminal_width(&self) -> i64;
 
@@ -205,7 +207,7 @@ pub trait BaseCommand: Command {
     /// @return Auditor::FORMAT_*
     fn get_audit_format(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
         opt_name: &str,
     ) -> anyhow::Result<String>;
 
@@ -213,7 +215,7 @@ pub trait BaseCommand: Command {
     fn create_audit_config(
         &self,
         config: &mut Config,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
     ) -> anyhow::Result<AuditConfig>;
 }
 
@@ -327,7 +329,7 @@ impl BaseCommand for BaseCommandData {
         Ok(())
     }
 
-    fn get_io(&self) -> Rc<RefCell<dyn IOInterface>> {
+    fn get_io(&self) -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
         if self.io.borrow().is_none() {
             match self.get_application() {
                 Some(application) => {
@@ -343,7 +345,8 @@ impl BaseCommand for BaseCommandData {
                     *self.io.borrow_mut() = Some(io);
                 }
                 None => {
-                    *self.io.borrow_mut() = Some(Rc::new(RefCell::new(NullIO::new())));
+                    *self.io.borrow_mut() =
+                        Some(std::rc::Rc::new(std::cell::RefCell::new(NullIO::new())));
                 }
             }
         }
@@ -351,14 +354,14 @@ impl BaseCommand for BaseCommandData {
         self.io.borrow().clone().unwrap()
     }
 
-    fn set_io(&self, io: Rc<RefCell<dyn IOInterface>>) {
+    fn set_io(&self, io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>) {
         *self.io.borrow_mut() = Some(io);
     }
 
     fn create_composer_instance(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        io: Rc<RefCell<dyn IOInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
         config: Option<IndexMap<String, PhpMixed>>,
         disable_plugins: bool,
         disable_scripts: Option<bool>,
@@ -387,7 +390,7 @@ impl BaseCommand for BaseCommandData {
     fn get_preferred_install_options(
         &self,
         config: &Config,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
         keep_vcs_requires_prefer_source: bool,
     ) -> anyhow::Result<(bool, bool)> {
         let mut prefer_source = false;
@@ -510,8 +513,8 @@ impl BaseCommand for BaseCommandData {
 
     fn get_platform_requirement_filter(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-    ) -> anyhow::Result<Rc<dyn PlatformRequirementFilterInterface>> {
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+    ) -> anyhow::Result<std::rc::Rc<dyn PlatformRequirementFilterInterface>> {
         if !input.borrow().has_option("ignore-platform-reqs")
             || !input.borrow().has_option("ignore-platform-req")
         {
@@ -577,7 +580,11 @@ impl BaseCommand for BaseCommandData {
         parser.parse_name_version_pairs(requirements)
     }
 
-    fn render_table(&self, table: Vec<PhpMixed>, output: Rc<RefCell<dyn OutputInterface>>) {
+    fn render_table(
+        &self,
+        table: Vec<PhpMixed>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
+    ) {
         let mut renderer = Table::new(output);
         renderer
             .set_style("compact".into())
@@ -604,7 +611,7 @@ impl BaseCommand for BaseCommandData {
 
     fn get_audit_format(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
         opt_name: &str,
     ) -> anyhow::Result<String> {
         if !input.borrow().has_option(opt_name) {
@@ -641,7 +648,7 @@ impl BaseCommand for BaseCommandData {
     fn create_audit_config(
         &self,
         config: &mut Config,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
     ) -> anyhow::Result<AuditConfig> {
         // Handle both --audit and --no-audit flags
         let audit = if input.borrow().has_option("audit") {
@@ -700,7 +707,11 @@ impl BaseCommand for BaseCommandData {
 /// (same for `getDisableScriptsByDefault()`), ORed into the caller's flags.
 fn apply_application_defaults(
     application: Option<
-        Rc<RefCell<dyn shirabe_external_packages::symfony::console::application::Application>>,
+        std::rc::Rc<
+            std::cell::RefCell<
+                dyn shirabe_external_packages::symfony::console::application::Application,
+            >,
+        >,
     >,
     mut disable_plugins: bool,
     mut disable_scripts: bool,
@@ -725,8 +736,8 @@ fn apply_application_defaults(
 /// future overrides) bind correctly.
 pub fn base_command_initialize(
     cmd: &dyn BaseCommand,
-    input: Rc<RefCell<dyn InputInterface>>,
-    _output: Rc<RefCell<dyn OutputInterface>>,
+    input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+    _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
 ) -> anyhow::Result<()> {
     // initialize a plugin-enabled Composer instance, either local or global
     let disable_plugins = input
diff --git a/crates/shirabe/src/command/bump_command.rs b/crates/shirabe/src/command/bump_command.rs
index e3dac8a2..e6c565c1 100644
--- a/crates/shirabe/src/command/bump_command.rs
+++ b/crates/shirabe/src/command/bump_command.rs
@@ -20,8 +20,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{PhpMixed, file_get_contents, file_put_contents, is_writable, strtolower};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct BumpCommand {
@@ -388,8 +386,8 @@ impl Command for BumpCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let packages_filter: Vec<String> = input
             .borrow()
@@ -430,8 +428,8 @@ impl Command for BumpCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/check_platform_reqs_command.rs b/crates/shirabe/src/command/check_platform_reqs_command.rs
index 4f53e79a..0f310ea4 100644
--- a/crates/shirabe/src/command/check_platform_reqs_command.rs
+++ b/crates/shirabe/src/command/check_platform_reqs_command.rs
@@ -17,8 +17,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{PhpMixed, array_merge_map, strip_tags};
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_semver::constraint::SimpleConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 struct CheckResult {
     platform_package: String,
@@ -189,8 +187,8 @@ impl Command for CheckPlatformReqsCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let composer = crate::composer::composer_full(&composer);
@@ -394,8 +392,8 @@ impl Command for CheckPlatformReqsCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/clear_cache_command.rs b/crates/shirabe/src/command/clear_cache_command.rs
index 2e414125..054ea8b1 100644
--- a/crates/shirabe/src/command/clear_cache_command.rs
+++ b/crates/shirabe/src/command/clear_cache_command.rs
@@ -12,8 +12,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::realpath;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ClearCacheCommand {
@@ -62,8 +60,8 @@ impl Command for ClearCacheCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.try_composer(None, None);
         // composer.getConfig() yields an Rc<RefCell<Config>>; Factory::createConfig() an owned
@@ -180,8 +178,8 @@ impl Command for ClearCacheCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/create_project_command.rs b/crates/shirabe/src/command/create_project_command.rs
index 755590f6..4544cb63 100644
--- a/crates/shirabe/src/command/create_project_command.rs
+++ b/crates/shirabe/src/command/create_project_command.rs
@@ -44,9 +44,7 @@ use shirabe_php_shim::{
     UnexpectedValueException, array_pop, chdir, explode_with_limit, file_exists, getcwd, implode,
     is_dir, is_file, mkdir, realpath, rtrim, strtolower, unlink,
 };
-use std::cell::RefCell;
 use std::path::PathBuf;
-use std::rc::Rc;
 
 /// Install a package as new project into new directory.
 #[derive(Debug)]
@@ -257,8 +255,8 @@ impl Command for CreateProjectCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/depends_command.rs b/crates/shirabe/src/command/depends_command.rs
index 00b5abcb..4c6f85b5 100644
--- a/crates/shirabe/src/command/depends_command.rs
+++ b/crates/shirabe/src/command/depends_command.rs
@@ -9,8 +9,6 @@ use crate::console::input::InputOption;
 use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct DependsCommand {
@@ -101,16 +99,16 @@ impl Command for DependsCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         self.do_execute(input, output, false)
     }
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/diagnose_command.rs b/crates/shirabe/src/command/diagnose_command.rs
index 0c50d695..e7fb9c74 100644
--- a/crates/shirabe/src/command/diagnose_command.rs
+++ b/crates/shirabe/src/command/diagnose_command.rs
@@ -47,8 +47,6 @@ use shirabe_php_shim::{
     is_array, is_string, ob_get_clean, ob_start, phpinfo, rtrim, str_contains, str_replace,
     str_starts_with, strpos, strstr, strtolower, trim, version_compare,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct DiagnoseCommand {
@@ -441,8 +439,8 @@ impl Command for DiagnoseCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/dump_autoload_command.rs b/crates/shirabe/src/command/dump_autoload_command.rs
index de917b5d..906185b0 100644
--- a/crates/shirabe/src/command/dump_autoload_command.rs
+++ b/crates/shirabe/src/command/dump_autoload_command.rs
@@ -11,8 +11,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{InvalidArgumentException, PhpMixed, file_exists};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct DumpAutoloadCommand {
@@ -64,8 +62,8 @@ impl Command for DumpAutoloadCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let composer = crate::composer::composer_full(&composer);
@@ -313,8 +311,8 @@ impl Command for DumpAutoloadCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/exec_command.rs b/crates/shirabe/src/command/exec_command.rs
index 659b8f75..3eaee5a9 100644
--- a/crates/shirabe/src/command/exec_command.rs
+++ b/crates/shirabe/src/command/exec_command.rs
@@ -11,8 +11,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{PhpMixed, RuntimeException, basename, chdir, getcwd, glob};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ExecCommand {
@@ -98,8 +96,8 @@ impl Command for ExecCommand {
 
     fn interact(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) {
         let _ = (|| -> anyhow::Result<()> {
             let binaries = self.get_binaries(false)?;
@@ -140,8 +138,8 @@ impl Command for ExecCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
 
@@ -236,8 +234,8 @@ impl Command for ExecCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/fund_command.rs b/crates/shirabe/src/command/fund_command.rs
index 5c980314..65ae2c94 100644
--- a/crates/shirabe/src/command/fund_command.rs
+++ b/crates/shirabe/src/command/fund_command.rs
@@ -17,8 +17,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_semver::constraint::MatchAllConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct FundCommand {
@@ -97,8 +95,8 @@ impl Command for FundCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let composer = crate::composer::composer_full(&composer);
@@ -217,8 +215,8 @@ impl Command for FundCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/global_command.rs b/crates/shirabe/src/command/global_command.rs
index b0a3542d..a1f5f72e 100644
--- a/crates/shirabe/src/command/global_command.rs
+++ b/crates/shirabe/src/command/global_command.rs
@@ -16,9 +16,7 @@ use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::input::StringInput;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{LogicException, RuntimeException, chdir};
-use std::cell::RefCell;
 use std::path::Path;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct GlobalCommand {
@@ -67,7 +65,7 @@ impl GlobalCommand {
 
     fn prepare_subcommand_input(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
         quiet: bool,
     ) -> anyhow::Result<StringInput> {
         if Platform::get_env("COMPOSER").is_some() {
@@ -152,8 +150,8 @@ impl Command for GlobalCommand {
 
     fn run(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let tokens = Preg::split(r"{\s+}", &Self::input_to_string(&*input.borrow())?);
         let mut args: Vec<String> = vec![];
@@ -171,7 +169,8 @@ impl Command for GlobalCommand {
         }
 
         let sub_input = self.prepare_subcommand_input(input, false)?;
-        let sub_input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(sub_input));
+        let sub_input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(sub_input));
 
         let application = {
             let application = self
@@ -190,8 +189,8 @@ impl Command for GlobalCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/home_command.rs b/crates/shirabe/src/command/home_command.rs
index 8ff43f39..5a823d8b 100644
--- a/crates/shirabe/src/command/home_command.rs
+++ b/crates/shirabe/src/command/home_command.rs
@@ -16,8 +16,6 @@ use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
 use shirabe_php_shim::filter_var_url;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct HomeCommand {
@@ -178,8 +176,8 @@ impl Command for HomeCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let repos = self.initialize_repos()?;
         let io = self.get_io().clone();
@@ -256,8 +254,8 @@ impl Command for HomeCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/init_command.rs b/crates/shirabe/src/command/init_command.rs
index 4a2e9a3d..f0f07a56 100644
--- a/crates/shirabe/src/command/init_command.rs
+++ b/crates/shirabe/src/command/init_command.rs
@@ -31,8 +31,6 @@ use shirabe_php_shim::{
     is_string, preg_quote, realpath, str_replace, strpos, strtolower, trim, ucwords,
 };
 use shirabe_spdx_licenses::SpdxLicenses;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct InitCommand {
@@ -116,8 +114,8 @@ impl Command for InitCommand {
     /// @throws \Seld\JsonLint\ParsingException
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let io = self.get_io();
 
@@ -402,8 +400,8 @@ impl Command for InitCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input.clone(), output.clone())?;
 
@@ -430,8 +428,8 @@ impl Command for InitCommand {
 
     fn interact(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) {
         let _ = (|| -> anyhow::Result<()> {
             let io = self.get_io();
diff --git a/crates/shirabe/src/command/install_command.rs b/crates/shirabe/src/command/install_command.rs
index 11929689..635c1461 100644
--- a/crates/shirabe/src/command/install_command.rs
+++ b/crates/shirabe/src/command/install_command.rs
@@ -15,8 +15,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct InstallCommand {
@@ -84,8 +82,8 @@ impl Command for InstallCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let io = self.get_io().clone();
 
@@ -265,8 +263,8 @@ impl Command for InstallCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/licenses_command.rs b/crates/shirabe/src/command/licenses_command.rs
index 52f7d2fa..be467a13 100644
--- a/crates/shirabe/src/command/licenses_command.rs
+++ b/crates/shirabe/src/command/licenses_command.rs
@@ -20,8 +20,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_external_packages::symfony::console::style::StyleInterface;
 use shirabe_external_packages::symfony::console::style::SymfonyStyle;
 use shirabe_php_shim::{PhpMixed, RuntimeException, UnexpectedValueException};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct LicensesCommand {
@@ -91,8 +89,8 @@ impl Command for LicensesCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer_handle = self.require_composer(None, None)?;
 
@@ -330,8 +328,8 @@ impl Command for LicensesCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/outdated_command.rs b/crates/shirabe/src/command/outdated_command.rs
index 73f191d2..e0892692 100644
--- a/crates/shirabe/src/command/outdated_command.rs
+++ b/crates/shirabe/src/command/outdated_command.rs
@@ -11,8 +11,6 @@ use shirabe_external_packages::symfony::console::input::ArrayInput;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct OutdatedCommand {
@@ -74,8 +72,8 @@ impl Command for OutdatedCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let mut args: IndexMap<String, PhpMixed> = IndexMap::new();
         args.insert("command".to_string(), PhpMixed::String("show".to_string()));
@@ -206,7 +204,8 @@ impl Command for OutdatedCommand {
             None,
         )?;
 
-        let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(input));
+        let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(input));
 
         let application = {
             let application = self
@@ -225,8 +224,8 @@ impl Command for OutdatedCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/prohibits_command.rs b/crates/shirabe/src/command/prohibits_command.rs
index 9f9b0eea..49c8a19b 100644
--- a/crates/shirabe/src/command/prohibits_command.rs
+++ b/crates/shirabe/src/command/prohibits_command.rs
@@ -8,8 +8,6 @@ use crate::console::input::InputOption;
 use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ProhibitsCommand {
@@ -108,16 +106,16 @@ impl Command for ProhibitsCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         self.do_execute(input, output, true)
     }
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/reinstall_command.rs b/crates/shirabe/src/command/reinstall_command.rs
index b28f6168..c2c3ab18 100644
--- a/crates/shirabe/src/command/reinstall_command.rs
+++ b/crates/shirabe/src/command/reinstall_command.rs
@@ -20,8 +20,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::InvalidArgumentException;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ReinstallCommand {
@@ -79,8 +77,8 @@ impl Command for ReinstallCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let composer = crate::composer::composer_full(&composer);
@@ -243,9 +241,9 @@ impl Command for ReinstallCommand {
             indexmap::IndexMap::new(),
         );
 
-        let uninstall_operations: Vec<Rc<dyn OperationInterface>> = uninstall_operations
+        let uninstall_operations: Vec<std::rc::Rc<dyn OperationInterface>> = uninstall_operations
             .into_iter()
-            .map(|op| Rc::new(op) as Rc<dyn OperationInterface>)
+            .map(|op| std::rc::Rc::new(op) as std::rc::Rc<dyn OperationInterface>)
             .collect();
         {
             let mut local_repo_ref = local_repo.borrow_mut();
@@ -356,8 +354,8 @@ impl Command for ReinstallCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/remove_command.rs b/crates/shirabe/src/command/remove_command.rs
index aa8f7723..e7686efd 100644
--- a/crates/shirabe/src/command/remove_command.rs
+++ b/crates/shirabe/src/command/remove_command.rs
@@ -21,8 +21,6 @@ use shirabe_external_packages::symfony::console::exception::InvalidArgumentExcep
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{PhpMixed, UnexpectedValueException, strtolower};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct RemoveCommand {
@@ -175,8 +173,8 @@ impl Command for RemoveCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         if input
             .borrow()
@@ -713,8 +711,8 @@ impl Command for RemoveCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/repository_command.rs b/crates/shirabe/src/command/repository_command.rs
index 89fb84b4..06ecfb4f 100644
--- a/crates/shirabe/src/command/repository_command.rs
+++ b/crates/shirabe/src/command/repository_command.rs
@@ -17,8 +17,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{
     InvalidArgumentException, PHP_URL_HOST, PhpMixed, RuntimeException, parse_url, strtolower,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct RepositoryCommand {
@@ -494,8 +492,8 @@ impl Command for RepositoryCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         <Self as crate::command::base_config_command::BaseConfigCommand>::initialize(
             self, input, output,
diff --git a/crates/shirabe/src/command/require_command.rs b/crates/shirabe/src/command/require_command.rs
index 952f8d89..219ad3d8 100644
--- a/crates/shirabe/src/command/require_command.rs
+++ b/crates/shirabe/src/command/require_command.rs
@@ -40,8 +40,6 @@ use shirabe_php_shim::{
     array_merge, array_unique, empty, file_exists, file_get_contents, file_put_contents, filesize,
     implode, is_writable, strtolower, unlink,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct RequireCommand {
@@ -633,15 +631,15 @@ impl Command for RequireCommand {
 
     fn interact(
         &self,
-        _input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        _input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) {
     }
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/run_script_command.rs b/crates/shirabe/src/command/run_script_command.rs
index 7fc9703f..c256eea2 100644
--- a/crates/shirabe/src/command/run_script_command.rs
+++ b/crates/shirabe/src/command/run_script_command.rs
@@ -18,8 +18,6 @@ use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
 use shirabe_php_shim::{InvalidArgumentException, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct RunScriptCommand {
@@ -59,7 +57,10 @@ impl RunScriptCommand {
         command
     }
 
-    fn list_scripts(&self, output: Rc<RefCell<dyn OutputInterface>>) -> anyhow::Result<i64> {
+    fn list_scripts(
+        &self,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
+    ) -> anyhow::Result<i64> {
         let scripts = self.get_scripts()?;
         if scripts.is_empty() {
             return Ok(0);
@@ -181,8 +182,8 @@ impl Command for RunScriptCommand {
 
     fn interact(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) {
         let _ = (|| -> anyhow::Result<()> {
             let scripts = self.get_scripts()?;
@@ -223,8 +224,8 @@ impl Command for RunScriptCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         if input
             .borrow()
@@ -323,8 +324,8 @@ impl Command for RunScriptCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/script_alias_command.rs b/crates/shirabe/src/command/script_alias_command.rs
index ff1fd3d2..17629162 100644
--- a/crates/shirabe/src/command/script_alias_command.rs
+++ b/crates/shirabe/src/command/script_alias_command.rs
@@ -11,8 +11,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{InvalidArgumentException, LogicException, PhpMixed, is_string};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ScriptAliasCommand {
@@ -108,8 +106,8 @@ impl Command for ScriptAliasCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let dispatcher = crate::composer::composer_full(&composer)
@@ -164,8 +162,8 @@ impl Command for ScriptAliasCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/search_command.rs b/crates/shirabe/src/command/search_command.rs
index 89abddd7..6709613c 100644
--- a/crates/shirabe/src/command/search_command.rs
+++ b/crates/shirabe/src/command/search_command.rs
@@ -18,8 +18,6 @@ use shirabe_external_packages::symfony::console::formatter::OutputFormatter;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{InvalidArgumentException, PhpMixed, implode, in_array, preg_quote};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct SearchCommand {
@@ -104,8 +102,8 @@ impl Command for SearchCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let platform_repo = PlatformRepository::new4(vec![], IndexMap::new(), None, None)?;
         let io = self.get_io();
@@ -271,8 +269,8 @@ impl Command for SearchCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/self_update_command.rs b/crates/shirabe/src/command/self_update_command.rs
index 35a1374b..87efd4b9 100644
--- a/crates/shirabe/src/command/self_update_command.rs
+++ b/crates/shirabe/src/command/self_update_command.rs
@@ -11,8 +11,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct SelfUpdateCommand {
@@ -72,8 +70,8 @@ impl Command for SelfUpdateCommand {
     /// been published yet. The command is therefore disabled.
     fn execute(
         &self,
-        _input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        _input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let io = self.get_io();
         io.write_error3(
@@ -87,8 +85,8 @@ impl Command for SelfUpdateCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/show_command.rs b/crates/shirabe/src/command/show_command.rs
index 68b42e68..a63e08cf 100644
--- a/crates/shirabe/src/command/show_command.rs
+++ b/crates/shirabe/src/command/show_command.rs
@@ -47,8 +47,6 @@ use shirabe_php_shim::{
 use shirabe_semver::Semver;
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_spdx_licenses::SpdxLicenses;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ShowCommand {
@@ -209,8 +207,8 @@ impl Command for ShowCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         *self.version_parser.borrow_mut() = VersionParser::new();
         if input.borrow().get_option("tree")?.as_bool() == Some(true) {
@@ -1443,8 +1441,8 @@ impl Command for ShowCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/status_command.rs b/crates/shirabe/src/command/status_command.rs
index 3b3445b6..b527d5aa 100644
--- a/crates/shirabe/src/command/status_command.rs
+++ b/crates/shirabe/src/command/status_command.rs
@@ -16,8 +16,6 @@ use indexmap::IndexMap;
 use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct StatusCommand {
@@ -335,8 +333,8 @@ impl Command for StatusCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer_rc = self.require_composer(None, None)?;
         {
@@ -381,8 +379,8 @@ impl Command for StatusCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/suggests_command.rs b/crates/shirabe/src/command/suggests_command.rs
index f7b04142..e42f20ba 100644
--- a/crates/shirabe/src/command/suggests_command.rs
+++ b/crates/shirabe/src/command/suggests_command.rs
@@ -15,8 +15,6 @@ use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_php_shim::{PhpMixed, empty, in_array};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct SuggestsCommand {
@@ -109,8 +107,8 @@ impl Command for SuggestsCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        _output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        _output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let composer = self.require_composer(None, None)?;
         let composer = crate::composer::composer_full(&composer);
@@ -215,8 +213,8 @@ impl Command for SuggestsCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/update_command.rs b/crates/shirabe/src/command/update_command.rs
index 366cf8bb..0163f6bc 100644
--- a/crates/shirabe/src/command/update_command.rs
+++ b/crates/shirabe/src/command/update_command.rs
@@ -35,8 +35,6 @@ use shirabe_php_shim::{
 };
 use shirabe_semver::Intervals;
 use shirabe_semver::constraint::MultiConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct UpdateCommand {
@@ -124,8 +122,8 @@ impl Command for UpdateCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let io = self.get_io().clone();
         if input.borrow().get_option("dev")?.as_bool().unwrap_or(false) {
@@ -572,8 +570,8 @@ impl Command for UpdateCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/command/validate_command.rs b/crates/shirabe/src/command/validate_command.rs
index bceaa991..12e28188 100644
--- a/crates/shirabe/src/command/validate_command.rs
+++ b/crates/shirabe/src/command/validate_command.rs
@@ -16,8 +16,6 @@ use crate::util::Filesystem;
 use shirabe_external_packages::symfony::console::command::command::Command;
 use shirabe_external_packages::symfony::console::input::InputInterface;
 use shirabe_external_packages::symfony::console::output::OutputInterface;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[derive(Debug)]
 pub struct ValidateCommand {
@@ -132,8 +130,8 @@ impl Command for ValidateCommand {
 
     fn execute(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<i64> {
         let file = input
             .borrow()
@@ -303,8 +301,8 @@ impl Command for ValidateCommand {
 
     fn initialize(
         &self,
-        input: Rc<RefCell<dyn InputInterface>>,
-        output: Rc<RefCell<dyn OutputInterface>>,
+        input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>>,
+        output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
     ) -> anyhow::Result<()> {
         base_command_initialize(self, input, output)
     }
diff --git a/crates/shirabe/src/config.rs b/crates/shirabe/src/config.rs
index cac6181e..d1cd4212 100644
--- a/crates/shirabe/src/config.rs
+++ b/crates/shirabe/src/config.rs
@@ -15,7 +15,6 @@ use shirabe_php_shim::{
     is_array, is_string, parse_url, php_to_string, rtrim, strtolower, strtoupper, strtr, substr,
     trigger_error,
 };
-use std::cell::RefCell;
 
 use crate::advisory::Auditor;
 use crate::downloader::TransportException;
@@ -40,7 +39,7 @@ pub struct Config {
     warned_hosts: IndexMap<String, bool>,
     /// @var array<string, true>
     ssl_verify_warned_hosts: IndexMap<String, bool>,
-    source_of_config_value: RefCell<IndexMap<String, String>>,
+    source_of_config_value: std::cell::RefCell<IndexMap<String, String>>,
 }
 
 impl Config {
@@ -229,7 +228,7 @@ impl Config {
             local_auth_config_source: None,
             warned_hosts: IndexMap::new(),
             ssl_verify_warned_hosts: IndexMap::new(),
-            source_of_config_value: RefCell::new(IndexMap::new()),
+            source_of_config_value: std::cell::RefCell::new(IndexMap::new()),
         };
 
         let config_clone = this.config.clone();
diff --git a/crates/shirabe/src/console/application.rs b/crates/shirabe/src/console/application.rs
index 86639444..a2f36cf4 100644
--- a/crates/shirabe/src/console/application.rs
+++ b/crates/shirabe/src/console/application.rs
@@ -833,7 +833,7 @@ impl Application {
             return self
                 .shared()
                 .add(todo!(
-                    "Rc<RefCell<dyn SymfonyCommand>> from command_loader.get(name)"
+                    "std::rc::Rc<std::cell::RefCell<dyn SymfonyCommand>> from command_loader.get(name)"
                 ))
                 .map(|c| c.is_some())
                 .unwrap_or(false);
@@ -1052,7 +1052,7 @@ impl Application {
                     command_list.insert(
                         name_or_alias.clone(),
                         todo!(
-                            "Rc<RefCell<dyn SymfonyCommand>> from command_loader.get(name_or_alias)"
+                            "std::rc::Rc<std::cell::RefCell<dyn SymfonyCommand>> from command_loader.get(name_or_alias)"
                         ),
                     );
                 }
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() {
diff --git a/crates/shirabe/src/filter/platform_requirement_filter/platform_requirement_filter_factory.rs b/crates/shirabe/src/filter/platform_requirement_filter/platform_requirement_filter_factory.rs
index dcfd5191..12c69091 100644
--- a/crates/shirabe/src/filter/platform_requirement_filter/platform_requirement_filter_factory.rs
+++ b/crates/shirabe/src/filter/platform_requirement_filter/platform_requirement_filter_factory.rs
@@ -7,14 +7,13 @@ use crate::filter::platform_requirement_filter::{
     platform_requirement_filter_interface::PlatformRequirementFilterInterface,
 };
 use shirabe_php_shim::{InvalidArgumentException, PhpMixed};
-use std::rc::Rc;
 
 pub struct PlatformRequirementFilterFactory;
 
 impl PlatformRequirementFilterFactory {
     pub fn from_bool_or_list(
         bool_or_list: PhpMixed,
-    ) -> anyhow::Result<Rc<dyn PlatformRequirementFilterInterface>> {
+    ) -> anyhow::Result<std::rc::Rc<dyn PlatformRequirementFilterInterface>> {
         match bool_or_list {
             PhpMixed::Bool(b) => {
                 if b {
@@ -35,7 +34,9 @@ impl PlatformRequirementFilterFactory {
                         .collect(),
                     _ => unreachable!(),
                 };
-                Ok(Rc::new(IgnoreListPlatformRequirementFilter::new(list)?))
+                Ok(std::rc::Rc::new(IgnoreListPlatformRequirementFilter::new(
+                    list,
+                )?))
             }
             other => Err(anyhow::anyhow!(InvalidArgumentException {
                 message: format!(
@@ -47,11 +48,11 @@ impl PlatformRequirementFilterFactory {
         }
     }
 
-    pub fn ignore_all() -> Rc<dyn PlatformRequirementFilterInterface> {
-        Rc::new(IgnoreAllPlatformRequirementFilter)
+    pub fn ignore_all() -> std::rc::Rc<dyn PlatformRequirementFilterInterface> {
+        std::rc::Rc::new(IgnoreAllPlatformRequirementFilter)
     }
 
-    pub fn ignore_nothing() -> Rc<dyn PlatformRequirementFilterInterface> {
-        Rc::new(IgnoreNothingPlatformRequirementFilter)
+    pub fn ignore_nothing() -> std::rc::Rc<dyn PlatformRequirementFilterInterface> {
+        std::rc::Rc::new(IgnoreNothingPlatformRequirementFilter)
     }
 }
diff --git a/crates/shirabe/src/installer/installation_manager.rs b/crates/shirabe/src/installer/installation_manager.rs
index 04bff2a5..a3e429b1 100644
--- a/crates/shirabe/src/installer/installation_manager.rs
+++ b/crates/shirabe/src/installer/installation_manager.rs
@@ -737,7 +737,7 @@ impl InstallationManager {
                 // PHP appends a post-exec step to the promise chain that dispatches the
                 // POST_PACKAGE_* event via the event dispatcher with repo/all_operations/operation.
                 // TODO(phase-c): the callback captures the event dispatcher (&mut) and the operation
-                // and must outlive the loop body; that requires the dispatcher behind Rc<RefCell>
+                // and must outlive the loop body; that requires the dispatcher behind Rc<RefCell<_>>
                 // and the deferred event dispatch to be wired into the promise chain (todo!()).
                 let _ = event_name_post;
                 post_exec_callbacks.push(Box::new(|| {
diff --git a/crates/shirabe/src/io/console_io.rs b/crates/shirabe/src/io/console_io.rs
index eb7ab317..fe796d9e 100644
--- a/crates/shirabe/src/io/console_io.rs
+++ b/crates/shirabe/src/io/console_io.rs
@@ -27,7 +27,6 @@ use shirabe_php_shim::{
     PhpMixed, array_search, function_exists, implode, in_array, is_array, is_string,
     mb_check_encoding, mb_convert_encoding, microtime, str_repeat, strip_tags, strlen,
 };
-use std::cell::RefCell;
 
 /// The Input/Output helper.
 #[derive(Debug)]
@@ -41,10 +40,10 @@ pub struct ConsoleIO {
     /// `$this->helperSet->get('question')` on every ask. The Application class, which constructs
     /// this class, registers a single `QuestionHelper`. So this port holds the `QuestionHelper`
     /// directly instead of a `HelperSet`.
-    question_helper: RefCell<QuestionHelper>,
+    question_helper: std::cell::RefCell<QuestionHelper>,
 
-    pub(crate) last_message: RefCell<String>,
-    pub(crate) last_message_err: RefCell<String>,
+    pub(crate) last_message: std::cell::RefCell<String>,
+    pub(crate) last_message_err: std::cell::RefCell<String>,
 
     start_time: Option<f64>,
     verbosity_map: IndexMap<i64, i64>,
@@ -69,9 +68,9 @@ impl ConsoleIO {
             authentications: indexmap![],
             input,
             output,
-            question_helper: RefCell::new(question_helper),
-            last_message: RefCell::new(String::new()),
-            last_message_err: RefCell::new(String::new()),
+            question_helper: std::cell::RefCell::new(question_helper),
+            last_message: std::cell::RefCell::new(String::new()),
+            last_message_err: std::cell::RefCell::new(String::new()),
             start_time: None,
             verbosity_map,
         }
diff --git a/crates/shirabe/src/io/io_interface.rs b/crates/shirabe/src/io/io_interface.rs
index af3f688a..96bc1980 100644
--- a/crates/shirabe/src/io/io_interface.rs
+++ b/crates/shirabe/src/io/io_interface.rs
@@ -3,8 +3,6 @@
 use crate::config::Config;
 use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 pub const QUIET: i64 = 1;
 pub const NORMAL: i64 = 2;
@@ -167,7 +165,7 @@ pub trait IOInterface: IOInterfaceImmutable + IOInterfaceMutable {
 // `load_configuration`) are reached via `io.borrow_mut()`. Because the handle
 // does not implement `IOInterfaceMutable`, calling those directly on the handle
 // is a compile error rather than a runtime panic.
-impl IOInterfaceImmutable for Rc<RefCell<dyn IOInterface>> {
+impl IOInterfaceImmutable for std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
     fn is_interactive(&self) -> bool {
         self.borrow().is_interactive()
     }
diff --git a/crates/shirabe/src/package/handle.rs b/crates/shirabe/src/package/handle.rs
index c1db49c1..2b23a8c2 100644
--- a/crates/shirabe/src/package/handle.rs
+++ b/crates/shirabe/src/package/handle.rs
@@ -7,8 +7,6 @@ use crate::package::{
     AliasPackage, BasePackage, CompleteAliasPackage, CompletePackage, CompletePackageInterface,
     Package, PackageInterface, RootAliasPackage, RootPackage, RootPackageInterface,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// Any package type.
 #[derive(Debug, Clone)]
@@ -192,7 +190,7 @@ impl AnyPackage {
                 //   parent::__clone();
                 //   $this->aliasOf = clone $this->aliasOf;
                 let new_alias_of_inner = p.alias_of.0.borrow().dup();
-                let new_alias_of_rc = Rc::new(RefCell::new(new_alias_of_inner));
+                let new_alias_of_rc = std::rc::Rc::new(std::cell::RefCell::new(new_alias_of_inner));
                 let new_root = RootPackageHandle(new_alias_of_rc.clone());
                 let new_complete = CompletePackageHandle(new_alias_of_rc.clone());
                 let new_pkg = PackageHandle(new_alias_of_rc);
@@ -1361,7 +1359,7 @@ macro_rules! impl_handle_upcast {
 
 /// Shared reference to any package. Corresponds to PHP `PackageInterface`.
 #[derive(Debug, Clone)]
-pub struct PackageInterfaceHandle(Rc<RefCell<AnyPackage>>);
+pub struct PackageInterfaceHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to any package. Corresponds to PHP `BasePackage`.
 /// It is exactly the same as `PackageInterface` in Shirabe. It is only for mirroing PHP type
@@ -1370,35 +1368,35 @@ pub type BasePackageHandle = PackageInterfaceHandle;
 
 /// Shared reference to a complete package. Corresponds to PHP `CompletePackageInterface`.
 #[derive(Debug, Clone)]
-pub struct CompletePackageInterfaceHandle(Rc<RefCell<AnyPackage>>);
+pub struct CompletePackageInterfaceHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a root package. Corresponds to PHP `RootPackageInterface`.
 #[derive(Debug, Clone)]
-pub struct RootPackageInterfaceHandle(Rc<RefCell<AnyPackage>>);
+pub struct RootPackageInterfaceHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a real (non-alias) package. Corresponds to PHP `Package`.
 #[derive(Debug, Clone)]
-pub struct PackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct PackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a real complete package. Corresponds to PHP `CompletePackage`.
 #[derive(Debug, Clone)]
-pub struct CompletePackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct CompletePackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a real root package. Corresponds to PHP `RootPackage`.
 #[derive(Debug, Clone)]
-pub struct RootPackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct RootPackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to an alias package. Corresponds to PHP `AliasPackage`.
 #[derive(Debug, Clone)]
-pub struct AliasPackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct AliasPackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a complete alias package. Corresponds to PHP `CompleteAliasPackage`.
 #[derive(Debug, Clone)]
-pub struct CompleteAliasPackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct CompleteAliasPackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 /// Shared reference to a root alias package. Corresponds to PHP `RootAliasPackage`.
 #[derive(Debug, Clone)]
-pub struct RootAliasPackageHandle(Rc<RefCell<AnyPackage>>);
+pub struct RootAliasPackageHandle(std::rc::Rc<std::cell::RefCell<AnyPackage>>);
 
 impl_handle_common!(PackageInterfaceHandle);
 impl_handle_common!(CompletePackageInterfaceHandle);
@@ -1552,7 +1550,9 @@ impl PackageInterfaceHandle {
 
 impl PackageHandle {
     pub fn from_package(package: Package) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::Package(package))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::Package(package),
+        )))
     }
 
     pub fn new(name: String, version: String, pretty_version: String) -> Self {
@@ -1562,7 +1562,9 @@ impl PackageHandle {
 
 impl CompletePackageHandle {
     pub fn from_complete_package(package: CompletePackage) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::CompletePackage(package))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::CompletePackage(package),
+        )))
     }
 
     pub fn new(name: String, version: String, pretty_version: String) -> Self {
@@ -1572,7 +1574,9 @@ impl CompletePackageHandle {
 
 impl RootPackageHandle {
     pub fn from_root_package(package: RootPackage) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::RootPackage(package))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::RootPackage(package),
+        )))
     }
 
     pub fn new(name: String, version: String, pretty_version: String) -> Self {
@@ -1589,7 +1593,9 @@ impl RootPackageHandle {
 
 impl AliasPackageHandle {
     pub fn from_alias_package(package: AliasPackage) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::AliasPackage(package))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::AliasPackage(package),
+        )))
     }
 
     pub fn new(alias_of: PackageHandle, version: String, pretty_version: String) -> Self {
@@ -1636,9 +1642,9 @@ impl AliasPackageHandle {
 
 impl CompleteAliasPackageHandle {
     pub fn from_complete_alias_package(package: CompleteAliasPackage) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::CompleteAliasPackage(
-            package,
-        ))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::CompleteAliasPackage(package),
+        )))
     }
 
     pub fn new(alias_of: CompletePackageHandle, version: String, pretty_version: String) -> Self {
@@ -1669,7 +1675,9 @@ impl CompleteAliasPackageHandle {
 
 impl RootAliasPackageHandle {
     pub fn from_root_alias_package(package: RootAliasPackage) -> Self {
-        Self(Rc::new(RefCell::new(AnyPackage::RootAliasPackage(package))))
+        Self(std::rc::Rc::new(std::cell::RefCell::new(
+            AnyPackage::RootAliasPackage(package),
+        )))
     }
 
     pub fn new(alias_of: RootPackageHandle, version: String, pretty_version: String) -> Self {
diff --git a/crates/shirabe/src/package/loader/validating_array_loader.rs b/crates/shirabe/src/package/loader/validating_array_loader.rs
index 3250f011..4d7965f8 100644
--- a/crates/shirabe/src/package/loader/validating_array_loader.rs
+++ b/crates/shirabe/src/package/loader/validating_array_loader.rs
@@ -18,7 +18,6 @@ use shirabe_semver::Intervals;
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_semver::constraint::SimpleConstraint;
 use shirabe_spdx_licenses::SpdxLicenses;
-use std::cell::RefCell;
 
 #[derive(Debug)]
 pub struct ValidatingArrayLoader {
@@ -26,9 +25,9 @@ pub struct ValidatingArrayLoader {
     version_parser: VersionParser,
     // RefCell: `load` implements `LoaderInterface`, whose signature takes `&self`, but PHP's
     // implementation freely mutates these as scratch state for the duration of a single call.
-    errors: RefCell<Vec<String>>,
-    warnings: RefCell<Vec<String>>,
-    config: RefCell<IndexMap<String, PhpMixed>>,
+    errors: std::cell::RefCell<Vec<String>>,
+    warnings: std::cell::RefCell<Vec<String>>,
+    config: std::cell::RefCell<IndexMap<String, PhpMixed>>,
     flags: i64,
 }
 
@@ -55,9 +54,9 @@ impl ValidatingArrayLoader {
         Self {
             loader,
             version_parser,
-            errors: RefCell::new(Vec::new()),
-            warnings: RefCell::new(Vec::new()),
-            config: RefCell::new(IndexMap::new()),
+            errors: std::cell::RefCell::new(Vec::new()),
+            warnings: std::cell::RefCell::new(Vec::new()),
+            config: std::cell::RefCell::new(IndexMap::new()),
             flags,
         }
     }
diff --git a/crates/shirabe/src/package/package.rs b/crates/shirabe/src/package/package.rs
index 6eaf348b..ce22b755 100644
--- a/crates/shirabe/src/package/package.rs
+++ b/crates/shirabe/src/package/package.rs
@@ -12,7 +12,6 @@ use chrono::{DateTime, Utc};
 use indexmap::{IndexMap, IndexSet};
 use shirabe_external_packages::composer::pcre::Preg;
 use shirabe_php_shim::{E_USER_DEPRECATED, LogicException, PhpMixed, strpos, trigger_error};
-use std::rc::Rc;
 
 /// Mirror entry, e.g. `['url' => 'https://...', 'preferred' => true]`.
 #[derive(Debug, Clone)]
@@ -709,7 +708,7 @@ impl PackageInterface for Package {
     }
     fn set_repository(&mut self, repository: RepositoryInterfaceHandle) -> anyhow::Result<()> {
         if let Some(existing) = self.repository.as_ref().and_then(|w| w.upgrade())
-            && !Rc::ptr_eq(&existing, repository.as_rc())
+            && !std::rc::Rc::ptr_eq(&existing, repository.as_rc())
         {
             return Err(LogicException {
                 message: "A package can only be added to one repository".to_string(),
diff --git a/crates/shirabe/src/plugin/plugin_interface.rs b/crates/shirabe/src/plugin/plugin_interface.rs
index 486dbeac..5a92a87a 100644
--- a/crates/shirabe/src/plugin/plugin_interface.rs
+++ b/crates/shirabe/src/plugin/plugin_interface.rs
@@ -3,17 +3,27 @@
 use crate::composer::ComposerHandle;
 use crate::io::IOInterface;
 use crate::plugin::Capable;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 pub const PLUGIN_API_VERSION: &str = "2.9.0";
 
 pub trait PluginInterface: std::fmt::Debug {
-    fn activate(&mut self, composer: &ComposerHandle, io: Rc<RefCell<dyn IOInterface>>);
+    fn activate(
+        &mut self,
+        composer: &ComposerHandle,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    );
 
-    fn deactivate(&mut self, composer: &ComposerHandle, io: Rc<RefCell<dyn IOInterface>>);
+    fn deactivate(
+        &mut self,
+        composer: &ComposerHandle,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    );
 
-    fn uninstall(&mut self, composer: &ComposerHandle, io: Rc<RefCell<dyn IOInterface>>);
+    fn uninstall(
+        &mut self,
+        composer: &ComposerHandle,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    );
 
     // TODO(plugin): PHP-side `instanceof` checks for EventSubscriberInterface / Capable.
     // EventSubscriberInterface is not dyn-compatible (its only method is associated, not
diff --git a/crates/shirabe/src/repository/array_repository.rs b/crates/shirabe/src/repository/array_repository.rs
index dc31baad..6f5e4194 100644
--- a/crates/shirabe/src/repository/array_repository.rs
+++ b/crates/shirabe/src/repository/array_repository.rs
@@ -16,20 +16,19 @@ use shirabe_external_packages::composer::pcre::Preg;
 use shirabe_php_shim::{implode, preg_quote, strtolower};
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_semver::constraint::SimpleConstraint;
-use std::cell::RefCell;
 use std::rc::Weak;
 
 /// A repository implementation that simply stores packages in an array
 #[derive(Debug)]
 pub struct ArrayRepository {
-    pub(crate) packages: RefCell<Option<Vec<BasePackageHandle>>>,
+    pub(crate) packages: std::cell::RefCell<Option<Vec<BasePackageHandle>>>,
 
     /// @var ?array<BasePackage> indexed by package unique name and used to cache hasPackage calls
-    pub(crate) package_map: RefCell<Option<IndexMap<String, BasePackageHandle>>>,
+    pub(crate) package_map: std::cell::RefCell<Option<IndexMap<String, BasePackageHandle>>>,
 
     /// Weak reference to the outermost repository handle wrapping this `ArrayRepository`,
     /// injected via `set_self_handle`. Used to wire package -> repository back-references.
-    self_weak: RefCell<Option<RepositoryInterfaceWeakHandle>>,
+    self_weak: std::cell::RefCell<Option<RepositoryInterfaceWeakHandle>>,
 }
 
 impl ArrayRepository {
@@ -120,9 +119,9 @@ impl ArrayRepository {
     /// @param array<PackageInterface> $packages
     pub fn new(packages: Vec<PackageInterfaceHandle>) -> anyhow::Result<Self> {
         let this = Self {
-            packages: RefCell::new(None),
-            package_map: RefCell::new(None),
-            self_weak: RefCell::new(None),
+            packages: std::cell::RefCell::new(None),
+            package_map: std::cell::RefCell::new(None),
+            self_weak: std::cell::RefCell::new(None),
         };
         for package in packages {
             this.add_package(package)?;
diff --git a/crates/shirabe/src/repository/handle.rs b/crates/shirabe/src/repository/handle.rs
index 64cb5b73..f093f66b 100644
--- a/crates/shirabe/src/repository/handle.rs
+++ b/crates/shirabe/src/repository/handle.rs
@@ -8,35 +8,36 @@ use crate::repository::{
 };
 use indexmap::IndexMap;
 use shirabe_semver::constraint::AnyConstraint;
-use std::cell::{Ref, RefCell, RefMut};
-use std::rc::{Rc, Weak};
+use std::cell::{Ref, RefMut};
+use std::rc::Weak;
 
 /// Shared reference to a repository. Corresponds to PHP `RepositoryInterface`.
 #[derive(Debug, Clone)]
-pub struct RepositoryInterfaceHandle(Rc<RefCell<dyn RepositoryInterface>>);
+pub struct RepositoryInterfaceHandle(std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>>);
 
 /// Weak back-reference held by packages to the repository that owns them.
-pub type RepositoryInterfaceWeakHandle = Weak<RefCell<dyn RepositoryInterface>>;
+pub type RepositoryInterfaceWeakHandle = Weak<std::cell::RefCell<dyn RepositoryInterface>>;
 
 impl RepositoryInterfaceHandle {
     /// Wraps a concrete repository in a shared handle and injects its own weak reference so that
     /// `add_package` can wire package -> repository back-references (PHP `setRepository($this)`).
     pub fn new<T: RepositoryInterface + 'static>(repository: T) -> Self {
-        let rc: Rc<RefCell<dyn RepositoryInterface>> = Rc::new(RefCell::new(repository));
-        rc.borrow().set_self_handle(Rc::downgrade(&rc));
+        let rc: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(repository));
+        rc.borrow().set_self_handle(std::rc::Rc::downgrade(&rc));
         Self(rc)
     }
 
-    pub fn from_rc(rc: Rc<RefCell<dyn RepositoryInterface>>) -> Self {
+    pub fn from_rc(rc: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>>) -> Self {
         Self(rc)
     }
 
-    pub fn as_rc(&self) -> &Rc<RefCell<dyn RepositoryInterface>> {
+    pub fn as_rc(&self) -> &std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> {
         &self.0
     }
 
     pub fn downgrade(&self) -> RepositoryInterfaceWeakHandle {
-        Rc::downgrade(&self.0)
+        std::rc::Rc::downgrade(&self.0)
     }
 
     pub fn borrow(&self) -> Ref<'_, dyn RepositoryInterface> {
@@ -49,12 +50,12 @@ impl RepositoryInterfaceHandle {
 
     /// PHP `===` (reference identity).
     pub fn ptr_eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 
     /// Stable identity usable as a map key (PHP `spl_object_hash`).
     pub fn ptr_id(&self) -> usize {
-        Rc::as_ptr(&self.0) as *const () as usize
+        std::rc::Rc::as_ptr(&self.0) as *const () as usize
     }
 
     /// PHP `instanceof T` for a concrete repository type. Keeps the `RefCell` borrow internal.
@@ -63,13 +64,15 @@ impl RepositoryInterfaceHandle {
     }
 
     /// Downcasts the shared handle to a concrete repository type, preserving shared ownership.
-    pub fn downcast_rc<T: RepositoryInterface + 'static>(&self) -> Option<Rc<RefCell<T>>> {
+    pub fn downcast_rc<T: RepositoryInterface + 'static>(
+        &self,
+    ) -> Option<std::rc::Rc<std::cell::RefCell<T>>> {
         if self.0.borrow().as_any().is::<T>() {
             let rc = self.0.clone();
-            let ptr = Rc::into_raw(rc) as *const RefCell<T>;
+            let ptr = std::rc::Rc::into_raw(rc) as *const std::cell::RefCell<T>;
             // SAFETY: is::<T>() proved the value is `T`, and handles are always allocated as
             // `Rc::new(RefCell::new(concrete))`, so the layout matches `RcBox<RefCell<T>>`.
-            Some(unsafe { Rc::from_raw(ptr) })
+            Some(unsafe { std::rc::Rc::from_raw(ptr) })
         } else {
             None
         }
@@ -191,7 +194,7 @@ impl RepositoryInterfaceHandle {
 
 impl PartialEq for RepositoryInterfaceHandle {
     fn eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 }
 
@@ -205,21 +208,22 @@ impl std::hash::Hash for RepositoryInterfaceHandle {
 
 /// Typed shared handle over `LockArrayRepository`.
 #[derive(Debug, Clone)]
-pub struct LockArrayRepositoryHandle(Rc<RefCell<LockArrayRepository>>);
+pub struct LockArrayRepositoryHandle(std::rc::Rc<std::cell::RefCell<LockArrayRepository>>);
 
 impl LockArrayRepositoryHandle {
     pub fn new(repository: LockArrayRepository) -> Self {
-        let rc: Rc<RefCell<LockArrayRepository>> = Rc::new(RefCell::new(repository));
-        let rc_dyn: Rc<RefCell<dyn RepositoryInterface>> = rc.clone();
-        rc.borrow().set_self_handle(Rc::downgrade(&rc_dyn));
+        let rc: std::rc::Rc<std::cell::RefCell<LockArrayRepository>> =
+            std::rc::Rc::new(std::cell::RefCell::new(repository));
+        let rc_dyn: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> = rc.clone();
+        rc.borrow().set_self_handle(std::rc::Rc::downgrade(&rc_dyn));
         Self(rc)
     }
 
-    pub fn from_rc(rc: Rc<RefCell<LockArrayRepository>>) -> Self {
+    pub fn from_rc(rc: std::rc::Rc<std::cell::RefCell<LockArrayRepository>>) -> Self {
         Self(rc)
     }
 
-    pub fn as_rc(&self) -> &Rc<RefCell<LockArrayRepository>> {
+    pub fn as_rc(&self) -> &std::rc::Rc<std::cell::RefCell<LockArrayRepository>> {
         &self.0
     }
 
@@ -236,24 +240,24 @@ impl LockArrayRepositoryHandle {
     }
 
     pub fn ptr_eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 
     pub fn ptr_id(&self) -> usize {
-        Rc::as_ptr(&self.0) as *const () as usize
+        std::rc::Rc::as_ptr(&self.0) as *const () as usize
     }
 }
 
 impl From<LockArrayRepositoryHandle> for RepositoryInterfaceHandle {
     fn from(h: LockArrayRepositoryHandle) -> Self {
-        let rc: Rc<RefCell<dyn RepositoryInterface>> = h.0;
+        let rc: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> = h.0;
         RepositoryInterfaceHandle::from_rc(rc)
     }
 }
 
 impl PartialEq for LockArrayRepositoryHandle {
     fn eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 }
 
@@ -267,21 +271,22 @@ impl std::hash::Hash for LockArrayRepositoryHandle {
 
 /// Typed shared handle over `PlatformRepository`.
 #[derive(Debug, Clone)]
-pub struct PlatformRepositoryHandle(Rc<RefCell<PlatformRepository>>);
+pub struct PlatformRepositoryHandle(std::rc::Rc<std::cell::RefCell<PlatformRepository>>);
 
 impl PlatformRepositoryHandle {
     pub fn new(repository: PlatformRepository) -> Self {
-        let rc: Rc<RefCell<PlatformRepository>> = Rc::new(RefCell::new(repository));
-        let rc_dyn: Rc<RefCell<dyn RepositoryInterface>> = rc.clone();
-        rc.borrow().set_self_handle(Rc::downgrade(&rc_dyn));
+        let rc: std::rc::Rc<std::cell::RefCell<PlatformRepository>> =
+            std::rc::Rc::new(std::cell::RefCell::new(repository));
+        let rc_dyn: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> = rc.clone();
+        rc.borrow().set_self_handle(std::rc::Rc::downgrade(&rc_dyn));
         Self(rc)
     }
 
-    pub fn from_rc(rc: Rc<RefCell<PlatformRepository>>) -> Self {
+    pub fn from_rc(rc: std::rc::Rc<std::cell::RefCell<PlatformRepository>>) -> Self {
         Self(rc)
     }
 
-    pub fn as_rc(&self) -> &Rc<RefCell<PlatformRepository>> {
+    pub fn as_rc(&self) -> &std::rc::Rc<std::cell::RefCell<PlatformRepository>> {
         &self.0
     }
 
@@ -294,24 +299,24 @@ impl PlatformRepositoryHandle {
     }
 
     pub fn ptr_eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 
     pub fn ptr_id(&self) -> usize {
-        Rc::as_ptr(&self.0) as *const () as usize
+        std::rc::Rc::as_ptr(&self.0) as *const () as usize
     }
 }
 
 impl From<PlatformRepositoryHandle> for RepositoryInterfaceHandle {
     fn from(h: PlatformRepositoryHandle) -> Self {
-        let rc: Rc<RefCell<dyn RepositoryInterface>> = h.0;
+        let rc: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> = h.0;
         RepositoryInterfaceHandle::from_rc(rc)
     }
 }
 
 impl PartialEq for PlatformRepositoryHandle {
     fn eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.0, &other.0)
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
     }
 }
 
diff --git a/crates/shirabe/src/repository/vcs/vcs_driver_interface.rs b/crates/shirabe/src/repository/vcs/vcs_driver_interface.rs
index fb10d0f2..628f78b7 100644
--- a/crates/shirabe/src/repository/vcs/vcs_driver_interface.rs
+++ b/crates/shirabe/src/repository/vcs/vcs_driver_interface.rs
@@ -5,8 +5,6 @@ use crate::io::IOInterface;
 use chrono::{DateTime, FixedOffset};
 use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 pub trait VcsDriverInterface: std::fmt::Debug {
     fn initialize(&mut self) -> anyhow::Result<()>;
@@ -40,8 +38,8 @@ pub trait VcsDriverInterface: std::fmt::Debug {
     fn cleanup(&mut self) -> anyhow::Result<()>;
 
     fn supports(
-        io: Rc<RefCell<dyn IOInterface>>,
-        config: Rc<RefCell<Config>>,
+        io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+        config: std::rc::Rc<std::cell::RefCell<Config>>,
         url: &str,
         deep: bool,
     ) -> anyhow::Result<bool>
diff --git a/crates/shirabe/src/util/error_handler.rs b/crates/shirabe/src/util/error_handler.rs
index 45ad28a8..7a9cf9c2 100644
--- a/crates/shirabe/src/util/error_handler.rs
+++ b/crates/shirabe/src/util/error_handler.rs
@@ -7,14 +7,13 @@ use shirabe_php_shim::{
     STDERR, debug_backtrace, error_reporting, filter_var_boolean, fwrite, ini_get,
     set_error_handler,
 };
-use std::cell::{Cell, RefCell};
-use std::rc::Rc;
+use std::cell::Cell;
 
 // PHP keeps `$io` / `$hasShownDeprecationNotice` as process-global statics. Composer runs
 // single-threaded, so thread-locals on the main thread reproduce that faithfully while letting
 // us hold the same shared (`Rc<RefCell<dyn IOInterface>>`) IO instance the application uses.
 thread_local! {
-    static IO: RefCell<Option<Rc<RefCell<dyn IOInterface>>>> = const { RefCell::new(None) };
+    static IO: std::cell::RefCell<Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>> = const { std::cell::RefCell::new(None) };
     static HAS_SHOWN_DEPRECATION_NOTICE: Cell<i64> = const { Cell::new(0) };
 }
 
@@ -88,7 +87,7 @@ impl ErrorHandler {
         Ok(true)
     }
 
-    pub fn register(io: Option<Rc<RefCell<dyn IOInterface>>>) {
+    pub fn register(io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>) {
         set_error_handler(|level, message, file, line| {
             Self::handle(level, message.to_string(), file.to_string(), line).unwrap_or(true)
         });
diff --git a/crates/shirabe/tests/advisory/auditor_test.rs b/crates/shirabe/tests/advisory/auditor_test.rs
index fa99825d..dd904632 100644
--- a/crates/shirabe/tests/advisory/auditor_test.rs
+++ b/crates/shirabe/tests/advisory/auditor_test.rs
@@ -29,8 +29,6 @@ use shirabe_php_shim::date_create;
 use shirabe_semver::VersionParser;
 use shirabe_semver::constraint::AnyConstraint;
 use shirabe_semver::constraint::SimpleConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn constraint(operator: &str, version: &str) -> shirabe_semver::constraint::AnyConstraint {
     SimpleConstraint::new(operator.to_string(), version.to_string(), None).into()
@@ -594,9 +592,10 @@ Found 2 abandoned packages:
 
     for case in cases {
         let repo_set = get_repo_set();
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-            BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
-        ));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(
+                BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
+            ));
         let auditor = Auditor;
         let result = auditor
             .audit(
@@ -824,7 +823,7 @@ fn test_audit_with_ignore() {
         let repo_set = get_repo_set();
         let (io_mock, _io_guard) = get_io_mock(io_interface::NORMAL).unwrap();
         let auditor = Auditor;
-        let io_dyn: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+        let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
         let result = auditor
             .audit(
                 &io_dyn,
@@ -924,9 +923,10 @@ fn test_audit_with_ignore_unreachable() {
     // Without the ignoreUnreachable flag the TransportException propagates.
     {
         let repo_set = make_repo_set();
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-            BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
-        ));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(
+                BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
+            ));
         let err = auditor
             .audit(
                 &io,
@@ -947,9 +947,10 @@ fn test_audit_with_ignore_unreachable() {
     // With the ignoreUnreachable flag the advisories from reachable repos are reported.
     {
         let repo_set = make_repo_set();
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-            BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
-        ));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(
+                BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
+            ));
         let result = auditor
             .audit(
                 &io,
@@ -983,9 +984,10 @@ fn test_audit_with_ignore_unreachable() {
     // With JSON format the unreachable repositories and advisories are both included.
     {
         let repo_set = make_repo_set();
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-            BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
-        ));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(
+                BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
+            ));
         let result = auditor
             .audit(
                 &io,
@@ -1082,7 +1084,7 @@ fn test_audit_with_ignore_severity() {
         let repo_set = get_repo_set();
         let (io_mock, _io_guard) = get_io_mock(io_interface::NORMAL).unwrap();
         let auditor = Auditor;
-        let io_dyn: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+        let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
         let result = auditor
             .audit(
                 &io_dyn,
diff --git a/crates/shirabe/tests/all_functional_test.rs b/crates/shirabe/tests/all_functional_test.rs
index c6eb683b..b1717d08 100644
--- a/crates/shirabe/tests/all_functional_test.rs
+++ b/crates/shirabe/tests/all_functional_test.rs
@@ -10,7 +10,6 @@ use serial_test::serial;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_external_packages::composer::pcre::preg::Preg;
 use shirabe_php_shim::{CaptureKey, PREG_SPLIT_DELIM_CAPTURE, PhpMixed, intval};
-use std::cell::RefCell;
 use std::path::{Path, PathBuf};
 
 /// ref: AllFunctionalTest's `$oldcwd` / `$testDir` instance state plus its `setUp`/`tearDown`.
@@ -19,7 +18,7 @@ use std::path::{Path, PathBuf};
 /// cwd and removes the unique temp dir created by `testIntegration`. Modelled as an RAII guard.
 struct TearDown {
     old_cwd: PathBuf,
-    test_dir: RefCell<Option<PathBuf>>,
+    test_dir: std::cell::RefCell<Option<PathBuf>>,
 }
 
 impl Drop for TearDown {
@@ -42,7 +41,7 @@ fn set_up() -> TearDown {
     std::env::set_current_dir(fixtures_dir()).unwrap();
     TearDown {
         old_cwd,
-        test_dir: RefCell::new(None),
+        test_dir: std::cell::RefCell::new(None),
     }
 }
 
diff --git a/crates/shirabe/tests/application_test.rs b/crates/shirabe/tests/application_test.rs
index 7ee58e49..df5f6e4f 100644
--- a/crates/shirabe/tests/application_test.rs
+++ b/crates/shirabe/tests/application_test.rs
@@ -21,8 +21,6 @@ use shirabe_external_packages::symfony::console::input::input_interface::InputIn
 use shirabe_external_packages::symfony::console::output::buffered_output::BufferedOutput;
 use shirabe_external_packages::symfony::console::output::output_interface::OutputInterface;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn set_up() {
     Platform::put_env("COMPOSER_DISABLE_XDEBUG_WARN", "1");
@@ -61,18 +59,22 @@ fn test_dev_warning_suppressed_for_self_update() {
     }
 
     let application = ApplicationHandle::new("Composer".to_string(), "".to_string()).unwrap();
-    let command: Rc<RefCell<dyn Command>> = Rc::new(RefCell::new(SelfUpdateCommand::new()));
+    let command: std::rc::Rc<std::cell::RefCell<dyn Command>> =
+        std::rc::Rc::new(std::cell::RefCell::new(SelfUpdateCommand::new()));
     application.add(command).unwrap();
 
-    let output = Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![(PhpMixed::from("command"), PhpMixed::from("self-update"))],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output_trait: Rc<RefCell<dyn OutputInterface>> = output.clone();
+    let output = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
+        None, false, None,
+    )));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![(PhpMixed::from("command"), PhpMixed::from("self-update"))],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output_trait: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = output.clone();
     application.do_run(input, output_trait).unwrap();
 
     assert_eq!(
@@ -88,29 +90,34 @@ fn test_process_isolation_works_multiple_times() {
     set_up();
 
     let application = ApplicationHandle::new("Composer".to_string(), "".to_string()).unwrap();
-    let command: Rc<RefCell<dyn Command>> = Rc::new(RefCell::new(AboutCommand::new()));
+    let command: std::rc::Rc<std::cell::RefCell<dyn Command>> =
+        std::rc::Rc::new(std::cell::RefCell::new(AboutCommand::new()));
     application.add(command).unwrap();
 
-    let input1: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![(PhpMixed::from("command"), PhpMixed::from("about"))],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output1: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input1: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![(PhpMixed::from("command"), PhpMixed::from("about"))],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output1: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
     assert_eq!(0, application.do_run(input1, output1).unwrap());
 
-    let input2: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![(PhpMixed::from("command"), PhpMixed::from("about"))],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output2: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input2: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![(PhpMixed::from("command"), PhpMixed::from("about"))],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output2: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
     assert_eq!(0, application.do_run(input2, output2).unwrap());
 }
 
@@ -143,18 +150,20 @@ fn test_no_plugins_disables_plugins_when_script_commands_exist() {
 
     // Run list command with --no-plugins, this triggers script command registration which previously
     // created a Composer instance with plugins enabled regardless of the --no-plugins flag
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![
-                (PhpMixed::from("command"), PhpMixed::from("list")),
-                (PhpMixed::from("--no-plugins"), PhpMixed::from(true)),
-            ],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![
+                    (PhpMixed::from("command"), PhpMixed::from("list")),
+                    (PhpMixed::from("--no-plugins"), PhpMixed::from(true)),
+                ],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
     application.do_run(input, output).unwrap();
 
     let composer = application.__get_composer(false, None, None).unwrap();
@@ -207,15 +216,18 @@ fn test_script_command_takes_priority_over_abbreviated_builtin_command() {
     let application = ApplicationHandle::new("Composer".to_string(), "".to_string()).unwrap();
     application.set_catch_exceptions(false);
 
-    let app_output = Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![(PhpMixed::from("command"), PhpMixed::from("check"))],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output_trait: Rc<RefCell<dyn OutputInterface>> = app_output.clone();
+    let app_output = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
+        None, false, None,
+    )));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![(PhpMixed::from("command"), PhpMixed::from("check"))],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output_trait: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = app_output.clone();
     let exit_code = application.do_run(input, output_trait).unwrap();
 
     assert_eq!(0, exit_code, "Script command should have run successfully");
diff --git a/crates/shirabe/tests/autoload/autoload_generator_test.rs b/crates/shirabe/tests/autoload/autoload_generator_test.rs
index a79bba0f..d7159c27 100644
--- a/crates/shirabe/tests/autoload/autoload_generator_test.rs
+++ b/crates/shirabe/tests/autoload/autoload_generator_test.rs
@@ -21,8 +21,6 @@ use shirabe_external_packages::symfony::console::output::output_interface;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
 use shirabe_semver::constraint::{AnyConstraint, MatchAllConstraint, SimpleConstraint};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 /// The mock `InstallationManager::getInstallPath` used throughout the test: metapackages return
@@ -128,9 +126,9 @@ struct SetUp {
     vendor_dir: String,
     repository: InstalledArrayRepository,
     im: InstallationManager,
-    io: Rc<RefCell<BufferIO>>,
+    io: std::rc::Rc<std::cell::RefCell<BufferIO>>,
     generator: AutoloadGenerator,
-    event_dispatcher: Rc<RefCell<EventDispatcher>>,
+    event_dispatcher: std::rc::Rc<std::cell::RefCell<EventDispatcher>>,
 }
 
 impl Drop for SetUp {
@@ -148,14 +146,14 @@ fn null_path(s: &str) -> String {
 /// exercised here, so a mock HttpDownloader (no real curl backend) stands in for the loop.
 fn make_installation_manager(
     vendor_dir: &str,
-    io: Rc<RefCell<dyn IOInterface>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
 ) -> InstallationManager {
-    let config_for_downloader = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(
+    let config_for_downloader = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
         io.clone(),
         config_for_downloader,
     )));
-    let loop_ = Rc::new(RefCell::new(Loop::new(http_downloader, None)));
+    let loop_ = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(http_downloader, None)));
 
     let mut im = InstallationManager::new(loop_, io, None);
     im.add_installer(Box::new(InstallPathStubInstaller {
@@ -173,20 +171,21 @@ fn set_up() -> SetUp {
     let prev_cwd = std::env::current_dir().unwrap();
     std::env::set_current_dir(&working_dir).unwrap();
 
-    let io = Rc::new(RefCell::new(
+    let io = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
     ));
 
-    let dispatcher_io: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let dispatcher_io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
     let im = make_installation_manager(&vendor_dir, dispatcher_io.clone());
 
     let repository = InstalledArrayRepository::new().unwrap();
 
     // EventDispatcher constructor is disabled in PHP and dispatch is never called when run-scripts
     // is off (the default), so a real dispatcher over an empty Composer is a faithful no-op stand-in.
-    let composer =
-        ComposerHandle::from_rc_unchecked(Rc::new(RefCell::new(PartialOrFullComposer::new_full())));
-    let event_dispatcher = Rc::new(RefCell::new(EventDispatcher::new(
+    let composer = ComposerHandle::from_rc_unchecked(std::rc::Rc::new(std::cell::RefCell::new(
+        PartialOrFullComposer::new_full(),
+    )));
+    let event_dispatcher = std::rc::Rc::new(std::cell::RefCell::new(EventDispatcher::new(
         composer.upcast().downgrade(),
         dispatcher_io.clone(),
         None,
diff --git a/crates/shirabe/tests/cache_test.rs b/crates/shirabe/tests/cache_test.rs
index b9644dc9..c7c665f8 100644
--- a/crates/shirabe/tests/cache_test.rs
+++ b/crates/shirabe/tests/cache_test.rs
@@ -4,9 +4,7 @@ use shirabe::cache::{Cache, CacheMock, GcFinderMock};
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::util::filesystem::Filesystem;
-use std::cell::RefCell;
 use std::fs;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -28,7 +26,8 @@ fn set_up() -> SetUp {
 
     // PHP mocks Cache::getFinder and keeps the real Filesystem; here the CacheMock finder seam plays
     // that role and the Cache otherwise operates on the real temp directory.
-    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 cache = Cache::new(io, root.path().to_str().unwrap(), None, None, false);
 
     SetUp { root, files, cache }
@@ -113,7 +112,8 @@ fn test_remove_files_when_cache_is_too_large() {
 #[test]
 fn test_clear_cache() {
     let root = TempDir::new().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 mut cache = Cache::new(
         io,
         root.path().to_str().unwrap(),
diff --git a/crates/shirabe/tests/command/archive_command_test.rs b/crates/shirabe/tests/command/archive_command_test.rs
index 991f615a..322894db 100644
--- a/crates/shirabe/tests/command/archive_command_test.rs
+++ b/crates/shirabe/tests/command/archive_command_test.rs
@@ -22,8 +22,6 @@ use shirabe_external_packages::symfony::console::output::OutputInterface;
 use shirabe_external_packages::symfony::console::output::buffered_output::BufferedOutput;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // PHP mocks `Composer\Package\Archiver\ArchiveManager` with
 // getMockBuilder(...)->disableOriginalConstructor().
@@ -108,17 +106,21 @@ fn root_package(name: &str, version: &str) -> RootPackageHandle {
 }
 
 fn full_composer(composer: Composer) -> PartialComposerHandle {
-    PartialComposerHandle::from_rc(Rc::new(RefCell::new(PartialOrFullComposer::Full(composer))))
+    PartialComposerHandle::from_rc(std::rc::Rc::new(std::cell::RefCell::new(
+        PartialOrFullComposer::Full(composer),
+    )))
 }
 
 #[test]
 fn test_uses_config_from_composer_object() {
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
 
-    let config: Rc<RefCell<Config>> = ConfigStubBuilder::new()
+    let config: std::rc::Rc<std::cell::RefCell<Config>> = ConfigStubBuilder::new()
         .with("archive-format", PhpMixed::from("zip"))
         .build_shared();
 
@@ -144,8 +146,10 @@ fn test_uses_config_from_composer_object() {
 
     let mut composer = Composer::new();
     composer.set_config(config);
-    composer.set_archive_manager(Rc::new(RefCell::new(manager)));
-    composer.set_event_dispatcher(Rc::new(RefCell::new(noop_event_dispatcher())));
+    composer.set_archive_manager(std::rc::Rc::new(std::cell::RefCell::new(manager)));
+    composer.set_event_dispatcher(std::rc::Rc::new(std::cell::RefCell::new(
+        noop_event_dispatcher(),
+    )));
     composer.set_package(package.into());
     let composer = full_composer(composer);
 
@@ -158,10 +162,12 @@ fn test_uses_config_from_composer_object() {
 
 #[test]
 fn test_uses_config_from_factory_when_composer_is_not_defined() {
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
 
     // tryComposer() returns null (no Composer set), so execute() builds the Config via the Factory
     // and `archive` is stubbed (PHPUnit overrides initialize/tryComposer/archive).
@@ -188,17 +194,19 @@ fn test_uses_config_from_factory_when_composer_is_not_defined() {
 
 #[test]
 fn test_uses_config_from_composer_object_with_package_name() {
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(
-        ArrayInput::new(
-            vec![(PhpMixed::from("package"), PhpMixed::from("foo/bar"))],
-            None,
-        )
-        .unwrap(),
-    ));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            ArrayInput::new(
+                vec![(PhpMixed::from("package"), PhpMixed::from("foo/bar"))],
+                None,
+            )
+            .unwrap(),
+        ));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
 
-    let config: Rc<RefCell<Config>> = ConfigStubBuilder::new()
+    let config: std::rc::Rc<std::cell::RefCell<Config>> = ConfigStubBuilder::new()
         .with("archive-format", PhpMixed::from("zip"))
         .build_shared();
 
@@ -241,10 +249,14 @@ fn test_uses_config_from_composer_object_with_package_name() {
 
     let mut composer = Composer::new();
     composer.set_config(config);
-    composer.set_archive_manager(Rc::new(RefCell::new(manager)));
-    composer.set_event_dispatcher(Rc::new(RefCell::new(noop_event_dispatcher())));
+    composer.set_archive_manager(std::rc::Rc::new(std::cell::RefCell::new(manager)));
+    composer.set_event_dispatcher(std::rc::Rc::new(std::cell::RefCell::new(
+        noop_event_dispatcher(),
+    )));
     composer.set_package(package.into());
-    composer.set_repository_manager(Rc::new(RefCell::new(repository_manager)));
+    composer.set_repository_manager(std::rc::Rc::new(std::cell::RefCell::new(
+        repository_manager,
+    )));
     let composer = full_composer(composer);
 
     let command = ArchiveCommand::new();
diff --git a/crates/shirabe/tests/common/config_stub.rs b/crates/shirabe/tests/common/config_stub.rs
index bf81462a..656dea60 100644
--- a/crates/shirabe/tests/common/config_stub.rs
+++ b/crates/shirabe/tests/common/config_stub.rs
@@ -11,8 +11,6 @@
 use indexmap::IndexMap;
 use shirabe::config::Config;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 pub struct ConfigStubBuilder {
     use_environment: bool,
@@ -65,8 +63,8 @@ impl ConfigStubBuilder {
         config
     }
 
-    pub fn build_shared(self) -> Rc<RefCell<Config>> {
-        Rc::new(RefCell::new(self.build()))
+    pub fn build_shared(self) -> std::rc::Rc<std::cell::RefCell<Config>> {
+        std::rc::Rc::new(std::cell::RefCell::new(self.build()))
     }
 }
 
diff --git a/crates/shirabe/tests/common/http_downloader_mock.rs b/crates/shirabe/tests/common/http_downloader_mock.rs
index 85d3ec81..59519ca4 100644
--- a/crates/shirabe/tests/common/http_downloader_mock.rs
+++ b/crates/shirabe/tests/common/http_downloader_mock.rs
@@ -9,8 +9,6 @@ use shirabe::util::http_downloader::{
     HttpDownloader, HttpDownloaderMockExpectation, HttpDownloaderMockHandler,
 };
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // A single HTTP request expectation as written in the PHP tests: a `url` plus an
 // optional response (`status`/`body`/`headers`). `options` of `None` matches any
@@ -41,7 +39,7 @@ pub fn expect_full(
     }
 }
 
-pub struct HttpDownloaderMockGuard(Rc<RefCell<HttpDownloader>>);
+pub struct HttpDownloaderMockGuard(std::rc::Rc<std::cell::RefCell<HttpDownloader>>);
 
 impl Drop for HttpDownloaderMockGuard {
     fn drop(&mut self) {
@@ -60,10 +58,16 @@ pub fn get_http_downloader_mock(
     expectations: Vec<HttpDownloaderMockExpectation>,
     strict: bool,
     default_handler: HttpDownloaderMockHandler,
-) -> (Rc<RefCell<HttpDownloader>>, HttpDownloaderMockGuard) {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(io, config)));
+) -> (
+    std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
+    HttpDownloaderMockGuard,
+) {
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
+        io, config,
+    )));
     downloader
         .borrow_mut()
         .__expects(expectations, strict, default_handler);
diff --git a/crates/shirabe/tests/common/io_mock.rs b/crates/shirabe/tests/common/io_mock.rs
index 7b932a87..e54c45b9 100644
--- a/crates/shirabe/tests/common/io_mock.rs
+++ b/crates/shirabe/tests/common/io_mock.rs
@@ -8,9 +8,7 @@ use shirabe::util::platform::Platform;
 use shirabe_external_packages::composer::pcre::Preg;
 use shirabe_external_packages::symfony::console::output::output_interface;
 use shirabe_php_shim::{PHP_EOL, PhpMixed, preg_quote};
-use std::cell::RefCell;
 use std::collections::VecDeque;
-use std::rc::Rc;
 
 // A single entry of the IO expectation list. PHP models these as associative
 // arrays (`{text, regex?}` / `{ask, reply}` / `{auth: [repo, user, pass]}`); the
@@ -344,7 +342,7 @@ fn trim_eol(question: &str) -> &str {
     question.trim_end_matches(['\r', '\n'])
 }
 
-pub struct IOMockGuard(Rc<RefCell<IOMock>>);
+pub struct IOMockGuard(std::rc::Rc<std::cell::RefCell<IOMock>>);
 
 impl Drop for IOMockGuard {
     fn drop(&mut self) {
@@ -358,7 +356,9 @@ impl Drop for IOMockGuard {
 
 // For testing only. Mirrors TestCase::getIOMock: returns a shared IOMock handle
 // plus a guard that runs assert_complete when it drops at the end of the test scope.
-pub fn get_io_mock(verbosity: i64) -> anyhow::Result<(Rc<RefCell<IOMock>>, IOMockGuard)> {
-    let mock = Rc::new(RefCell::new(IOMock::new(verbosity)?));
+pub fn get_io_mock(
+    verbosity: i64,
+) -> anyhow::Result<(std::rc::Rc<std::cell::RefCell<IOMock>>, IOMockGuard)> {
+    let mock = std::rc::Rc::new(std::cell::RefCell::new(IOMock::new(verbosity)?));
     Ok((mock.clone(), IOMockGuard(mock)))
 }
diff --git a/crates/shirabe/tests/common/process_executor_mock.rs b/crates/shirabe/tests/common/process_executor_mock.rs
index 698d8d26..33d9dfba 100644
--- a/crates/shirabe/tests/common/process_executor_mock.rs
+++ b/crates/shirabe/tests/common/process_executor_mock.rs
@@ -2,8 +2,6 @@
 
 use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // A command expectation as written in the PHP tests: either a bare command
 // (`'git command'` / `['git', '--version']`) or the full
@@ -72,7 +70,7 @@ impl<const N: usize> IntoMockCmd for [&str; N] {
     }
 }
 
-pub struct ProcessExecutorMockGuard(Rc<RefCell<ProcessExecutor>>);
+pub struct ProcessExecutorMockGuard(std::rc::Rc<std::cell::RefCell<ProcessExecutor>>);
 
 impl Drop for ProcessExecutorMockGuard {
     fn drop(&mut self) {
@@ -91,8 +89,11 @@ pub fn get_process_executor_mock(
     expectations: Vec<MockExpectation>,
     strict: bool,
     default_handler: MockHandler,
-) -> (Rc<RefCell<ProcessExecutor>>, ProcessExecutorMockGuard) {
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+) -> (
+    std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+    ProcessExecutorMockGuard,
+) {
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
     process
         .borrow_mut()
         .__expects(expectations, strict, default_handler);
diff --git a/crates/shirabe/tests/common/test_case.rs b/crates/shirabe/tests/common/test_case.rs
index 7365f734..5bfc2d0f 100644
--- a/crates/shirabe/tests/common/test_case.rs
+++ b/crates/shirabe/tests/common/test_case.rs
@@ -30,9 +30,7 @@ use shirabe_external_packages::symfony::console::output::stream_output::StreamOu
 use shirabe_php_shim::{PhpMixed, PhpResource};
 use shirabe_semver::VersionParser;
 use shirabe_semver::constraint::{AnyConstraint, SimpleConstraint};
-use std::cell::RefCell;
 use std::path::PathBuf;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 /// ref: TestCase::getPackage (default class CompletePackage)
@@ -170,17 +168,22 @@ pub fn init_temp_composer(
     }
 }
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
 /// ref: FactoryMock::createInstallationManager (the real installers are never created in tests, so a
 /// bare InstallationManager over a mock HttpDownloader suffices).
-fn installation_manager(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<InstallationManager>> {
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(io.clone(), config)));
-    let r#loop = Rc::new(RefCell::new(Loop::new(http_downloader, None)));
-    Rc::new(RefCell::new(InstallationManager::new(
+fn installation_manager(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) -> std::rc::Rc<std::cell::RefCell<InstallationManager>> {
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
+        io.clone(),
+        config,
+    )));
+    let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(http_downloader, None)));
+    std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::new(
         r#loop,
         io.clone(),
         None,
@@ -227,7 +230,9 @@ pub fn create_composer_lock(
     let io = null_io();
     let json_file = JsonFile::new("./composer.lock".to_string(), None, None).unwrap();
     let composer_file_contents = std::fs::read_to_string("./composer.json").unwrap_or_default();
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     let mut locker = Locker::new(
         io.clone(),
         json_file,
@@ -279,7 +284,7 @@ pub struct ApplicationTester {
     application: ApplicationHandle,
     inputs: Vec<String>,
     status_code: Option<i32>,
-    output: Option<Rc<RefCell<dyn OutputInterface>>>,
+    output: Option<std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>>,
     /// Handles retained before injection so `get_display`/`get_error_output` can read the memory
     /// streams without relying on a `get_stream()` accessor across the ConsoleOutput composition gap.
     output_stream: Option<PhpResource>,
@@ -320,7 +325,8 @@ impl ApplicationTester {
 
         self.init_output(&options);
 
-        let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(array_input));
+        let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(array_input));
         let output = self.output.clone().expect("init_output initializes output");
 
         let status_code = self.application.run(Some(input), Some(output))?;
@@ -346,7 +352,7 @@ impl ApplicationTester {
             if let Some(verbosity) = options.verbosity {
                 output.set_verbosity(verbosity);
             }
-            self.output = Some(Rc::new(RefCell::new(output)));
+            self.output = Some(std::rc::Rc::new(std::cell::RefCell::new(output)));
         } else {
             let stdout = shirabe_php_shim::php_fopen_resource("php://memory", "w");
             let stderr = shirabe_php_shim::php_fopen_resource("php://memory", "w");
@@ -363,10 +369,10 @@ impl ApplicationTester {
             error_output.set_verbosity(output.get_verbosity());
             error_output.set_decorated(output.is_decorated());
 
-            output.set_error_output(Rc::new(RefCell::new(error_output)));
+            output.set_error_output(std::rc::Rc::new(std::cell::RefCell::new(error_output)));
             output.__set_stream(stdout);
 
-            self.output = Some(Rc::new(RefCell::new(output)));
+            self.output = Some(std::rc::Rc::new(std::cell::RefCell::new(output)));
         }
     }
 
diff --git a/crates/shirabe/tests/composer_test.rs b/crates/shirabe/tests/composer_test.rs
index c394f1e6..891a47f1 100644
--- a/crates/shirabe/tests/composer_test.rs
+++ b/crates/shirabe/tests/composer_test.rs
@@ -16,16 +16,16 @@ use shirabe::repository::RepositoryManagerInterface;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
 use shirabe::util::process_executor::ProcessExecutor;
-use std::cell::RefCell;
-use std::rc::Rc;
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
-fn http_downloader(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<HttpDownloader>> {
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    Rc::new(RefCell::new(HttpDownloader::new(
+fn http_downloader(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) -> std::rc::Rc<std::cell::RefCell<HttpDownloader>> {
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config,
         IndexMap::new(),
@@ -33,9 +33,14 @@ fn http_downloader(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<HttpDownload
     )))
 }
 
-fn installation_manager(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<InstallationManager>> {
-    let r#loop = Rc::new(RefCell::new(Loop::new(http_downloader(io), None)));
-    Rc::new(RefCell::new(InstallationManager::new(
+fn installation_manager(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) -> std::rc::Rc<std::cell::RefCell<InstallationManager>> {
+    let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
+        http_downloader(io),
+        None,
+    )));
+    std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::new(
         r#loop,
         io.clone(),
         None,
@@ -61,48 +66,67 @@ fn test_set_get_locker() {
     let mut composer = Composer::new();
     let io = null_io();
     let json_file = JsonFile::new("composer.lock".to_string(), None, None).unwrap();
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
-    let locker: Rc<RefCell<dyn LockerInterface>> = Rc::new(RefCell::new(Locker::new(
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
         io.clone(),
-        json_file,
-        installation_manager(&io),
-        "{}",
-        process,
-    )));
+    ))));
+    let locker: std::rc::Rc<std::cell::RefCell<dyn LockerInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(Locker::new(
+            io.clone(),
+            json_file,
+            installation_manager(&io),
+            "{}",
+            process,
+        )));
     composer.set_locker(locker.clone());
 
-    assert!(Rc::ptr_eq(&composer.get_locker(), &locker));
+    assert!(std::rc::Rc::ptr_eq(&composer.get_locker(), &locker));
 }
 
 #[test]
 fn test_set_get_repository_manager() {
     let mut composer = Composer::new();
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let manager: Rc<RefCell<dyn RepositoryManagerInterface>> = Rc::new(RefCell::new(
-        RepositoryManager::new(io.clone(), config, http_downloader(&io), None, None),
-    ));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let manager: std::rc::Rc<std::cell::RefCell<dyn RepositoryManagerInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(RepositoryManager::new(
+            io.clone(),
+            config,
+            http_downloader(&io),
+            None,
+            None,
+        )));
     composer.set_repository_manager(manager.clone());
 
-    assert!(Rc::ptr_eq(&composer.get_repository_manager(), &manager));
+    assert!(std::rc::Rc::ptr_eq(
+        &composer.get_repository_manager(),
+        &manager
+    ));
 }
 
 #[test]
 fn test_set_get_download_manager() {
     let mut composer = Composer::new();
-    let manager: Rc<RefCell<dyn DownloadManagerInterface>> =
-        Rc::new(RefCell::new(DownloadManager::new(null_io(), false, None)));
+    let manager: std::rc::Rc<std::cell::RefCell<dyn DownloadManagerInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(DownloadManager::new(null_io(), false, None)),
+    );
     composer.set_download_manager(manager.clone());
 
-    assert!(Rc::ptr_eq(&composer.get_download_manager(), &manager));
+    assert!(std::rc::Rc::ptr_eq(
+        &composer.get_download_manager(),
+        &manager
+    ));
 }
 
 #[test]
 fn test_set_get_installation_manager() {
     let mut composer = Composer::new();
     let io = null_io();
-    let manager: Rc<RefCell<dyn InstallationManagerInterface>> = installation_manager(&io);
+    let manager: std::rc::Rc<std::cell::RefCell<dyn InstallationManagerInterface>> =
+        installation_manager(&io);
     composer.set_installation_manager(manager.clone());
 
-    assert!(Rc::ptr_eq(&composer.get_installation_manager(), &manager));
+    assert!(std::rc::Rc::ptr_eq(
+        &composer.get_installation_manager(),
+        &manager
+    ));
 }
diff --git a/crates/shirabe/tests/config/json_config_source_test.rs b/crates/shirabe/tests/config/json_config_source_test.rs
index 200a6216..155b83a7 100644
--- a/crates/shirabe/tests/config/json_config_source_test.rs
+++ b/crates/shirabe/tests/config/json_config_source_test.rs
@@ -6,9 +6,7 @@ use shirabe::config::JsonConfigSource;
 use shirabe::json::JsonFile;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
 use std::path::PathBuf;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 fn set_up() -> TearDown {
@@ -58,7 +56,7 @@ fn assert_file_equals(expected: &std::path::Path, actual: &std::path::Path) {
 
 fn json_config_source(config: &std::path::Path) -> JsonConfigSource {
     let json_file = JsonFile::new(config.to_string_lossy().to_string(), None, None).unwrap();
-    JsonConfigSource::new(Rc::new(RefCell::new(json_file)), false)
+    JsonConfigSource::new(std::rc::Rc::new(std::cell::RefCell::new(json_file)), false)
 }
 
 #[test]
diff --git a/crates/shirabe/tests/config_test.rs b/crates/shirabe/tests/config_test.rs
index 61a1575a..e8feafd7 100644
--- a/crates/shirabe/tests/config_test.rs
+++ b/crates/shirabe/tests/config_test.rs
@@ -8,8 +8,6 @@ use shirabe::io::IOInterface;
 use shirabe::io::io_interface;
 use shirabe::util::Platform;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[path = "common/io_mock.rs"]
 #[allow(dead_code)] // io_mock exposes more helpers than this binary uses
@@ -509,7 +507,7 @@ fn test_prohibited_urls_warning_verify_peer() {
         .unwrap();
 
     let mut config = Config::new(false, None);
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let mut repo_options: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_options.insert(
         "ssl".to_string(),
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);
diff --git a/crates/shirabe/tests/documentation_test.rs b/crates/shirabe/tests/documentation_test.rs
index 7dc049cf..7a13ce1d 100644
--- a/crates/shirabe/tests/documentation_test.rs
+++ b/crates/shirabe/tests/documentation_test.rs
@@ -3,10 +3,8 @@
 use shirabe::console::application::ApplicationHandle;
 use shirabe_external_packages::symfony::console::command::Command;
 use shirabe_external_packages::symfony::console::descriptor::application_description::ApplicationDescription;
-use std::cell::RefCell;
-use std::rc::Rc;
 
-fn get_command_name(command: &Rc<RefCell<dyn Command>>) -> String {
+fn get_command_name(command: &std::rc::Rc<std::cell::RefCell<dyn Command>>) -> String {
     let mut name = command.borrow().get_name().unwrap_or_default();
     for alias in command.borrow().get_aliases() {
         name = format!("{} / {}", name, alias);
@@ -15,7 +13,7 @@ fn get_command_name(command: &Rc<RefCell<dyn Command>>) -> String {
     name
 }
 
-fn provide_command_cases() -> Vec<Rc<RefCell<dyn Command>>> {
+fn provide_command_cases() -> Vec<std::rc::Rc<std::cell::RefCell<dyn Command>>> {
     let application = ApplicationHandle::new("Composer".to_string(), "".to_string()).unwrap();
     application.set_catch_exceptions(false);
 
diff --git a/crates/shirabe/tests/downloader/archive_downloader_test.rs b/crates/shirabe/tests/downloader/archive_downloader_test.rs
index fedbae9e..77569e97 100644
--- a/crates/shirabe/tests/downloader/archive_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/archive_downloader_test.rs
@@ -15,8 +15,6 @@ use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
 use shirabe::util::HttpDownloader;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// ref: TestCase::getPackage (default class CompletePackage)
 fn get_package(name: &str, version: &str) -> PackageInterfaceHandle {
@@ -27,7 +25,8 @@ fn get_package(name: &str, version: &str) -> PackageInterfaceHandle {
 /// ref: ArchiveDownloaderTest::getArchiveDownloaderMock (the inherited getFileName/processUrl
 /// live on FileDownloader, so the concrete downloader is built directly).
 fn get_archive_downloader(vendor_dir: Option<&str>) -> FileDownloader {
-    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 mut config = Config::new(false, None);
     if let Some(vendor_dir) = vendor_dir {
@@ -40,9 +39,9 @@ fn get_archive_downloader(vendor_dir: Option<&str>) -> FileDownloader {
         merged.insert("config".to_string(), PhpMixed::Array(config_options));
         config.merge(&merged, "test");
     }
-    let config = Rc::new(RefCell::new(config));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
 
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
diff --git a/crates/shirabe/tests/downloader/download_manager_test.rs b/crates/shirabe/tests/downloader/download_manager_test.rs
index 3b259c86..f596beed 100644
--- a/crates/shirabe/tests/downloader/download_manager_test.rs
+++ b/crates/shirabe/tests/downloader/download_manager_test.rs
@@ -8,8 +8,6 @@ use shirabe::io::IOInterface;
 use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
 use shirabe_php_shim::{PhpMixed, RuntimeException};
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // PHP mocks `Composer\Downloader\DownloaderInterface` with getMockBuilder.
 mockall::mock! {
@@ -91,7 +89,7 @@ fn make_package(name: &str, is_dev: bool) -> PackageInterfaceHandle {
 }
 
 /// ref: DownloadManagerTest::createDownloaderMock
-fn create_downloader_mock() -> Rc<RefCell<dyn DownloaderInterface>> {
+fn create_downloader_mock() -> std::rc::Rc<std::cell::RefCell<dyn DownloaderInterface>> {
     as_dyn(MockDownloader::new())
 }
 
@@ -107,12 +105,14 @@ fn downloader_mock(installation_source: &str) -> MockDownloader {
     downloader
 }
 
-fn as_dyn(downloader: MockDownloader) -> Rc<RefCell<dyn DownloaderInterface>> {
-    Rc::new(RefCell::new(downloader)) as Rc<RefCell<dyn DownloaderInterface>>
+fn as_dyn(downloader: MockDownloader) -> std::rc::Rc<std::cell::RefCell<dyn DownloaderInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(downloader))
+        as std::rc::Rc<std::cell::RefCell<dyn DownloaderInterface>>
 }
 
 fn create_manager() -> DownloadManager {
-    let io = Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>;
+    let io = std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()))
+        as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>;
     DownloadManager::new(io, false, None)
 }
 
@@ -122,7 +122,7 @@ fn test_set_get_downloader() {
     let mut manager = create_manager();
 
     manager.set_downloader("test", downloader.clone());
-    assert!(Rc::ptr_eq(
+    assert!(std::rc::Rc::ptr_eq(
         &downloader,
         &manager.get_downloader("test").unwrap()
     ));
@@ -172,7 +172,7 @@ fn test_get_downloader_for_correctly_installed_dist_package() {
         .get_downloader_for_package(package)
         .unwrap()
         .unwrap();
-    assert!(Rc::ptr_eq(&downloader, &result));
+    assert!(std::rc::Rc::ptr_eq(&downloader, &result));
 }
 
 // The LogicException message uses get_class($downloader); the equivalent
@@ -209,7 +209,7 @@ fn test_get_downloader_for_correctly_installed_source_package() {
         .get_downloader_for_package(package)
         .unwrap()
         .unwrap();
-    assert!(Rc::ptr_eq(&downloader, &result));
+    assert!(std::rc::Rc::ptr_eq(&downloader, &result));
 }
 
 // See test_get_downloader_for_incorrectly_installed_dist_package: the LogicException
diff --git a/crates/shirabe/tests/downloader/file_downloader_test.rs b/crates/shirabe/tests/downloader/file_downloader_test.rs
index ead577e2..2fd7d52e 100644
--- a/crates/shirabe/tests/downloader/file_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/file_downloader_test.rs
@@ -20,8 +20,6 @@ use shirabe_php_shim::{
     InvalidArgumentException, PhpMixed, RuntimeException, UnexpectedValueException,
 };
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 /// ref: TestCase::getPackage (default class CompletePackage)
@@ -38,14 +36,16 @@ fn run<F: std::future::Future>(future: F) -> F::Output {
 }
 
 /// ref: TestCase::getConfig
-fn get_config(config_options: IndexMap<String, PhpMixed>) -> Rc<RefCell<Config>> {
+fn get_config(
+    config_options: IndexMap<String, PhpMixed>,
+) -> std::rc::Rc<std::cell::RefCell<Config>> {
     let mut config = Config::new(false, None);
     if !config_options.is_empty() {
         let mut merged: IndexMap<String, PhpMixed> = IndexMap::new();
         merged.insert("config".to_string(), PhpMixed::Array(config_options));
         config.merge(&merged, "test");
     }
-    Rc::new(RefCell::new(config))
+    std::rc::Rc::new(std::cell::RefCell::new(config))
 }
 
 /// The PHP `getDownloader` builds a HttpDownloader mock whose `addCopy` resolves to a 200 Response
@@ -53,15 +53,16 @@ fn get_config(config_options: IndexMap<String, PhpMixed>) -> Rc<RefCell<Config>>
 /// handler returning a 200/`file~` response for any URL. The mock never writes the destination file,
 /// so the verification step throws "could not be saved to" exactly as in PHP.
 fn get_downloader(
-    io: Option<Rc<RefCell<dyn IOInterface>>>,
-    config: Option<Rc<RefCell<Config>>>,
+    io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>,
+    config: Option<std::rc::Rc<std::cell::RefCell<Config>>>,
 ) -> (
     FileDownloader,
-    Rc<RefCell<HttpDownloader>>,
+    std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
     crate::http_downloader_mock::HttpDownloaderMockGuard,
 ) {
-    let io = io.unwrap_or_else(|| Rc::new(RefCell::new(NullIO::new())));
-    let config = config.unwrap_or_else(|| Rc::new(RefCell::new(Config::new(false, None))));
+    let io = io.unwrap_or_else(|| std::rc::Rc::new(std::cell::RefCell::new(NullIO::new())));
+    let config = config
+        .unwrap_or_else(|| std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None))));
 
     let (http_downloader, guard) = get_http_downloader_mock(
         Vec::new(),
@@ -213,14 +214,15 @@ fn test_cache_garbage_collection_is_called() {
     // The PHP Cache mock forces gcIsNecessary() true and records the single gc() call; the CacheMock
     // seam plays both roles here.
     let tmp_dir = TempDir::new().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 mut cache = Cache::new(io, tmp_dir.path().to_str().unwrap(), None, None, false);
     cache.__set_mock(CacheMock {
         gc_is_necessary: Some(true),
         gc_calls: Some(Vec::new()),
         ..Default::default()
     });
-    let cache = Rc::new(RefCell::new(cache));
+    let cache = std::rc::Rc::new(std::cell::RefCell::new(cache));
 
     let (http_downloader, _guard) = get_http_downloader_mock(
         Vec::new(),
@@ -232,7 +234,8 @@ fn test_cache_garbage_collection_is_called() {
         },
     );
 
-    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 _downloader = FileDownloader::new(
         io,
         config,
@@ -334,7 +337,7 @@ fn test_downgrade_shows_appropriate_message() {
         normalize_path_identity: true,
         ..Default::default()
     });
-    let filesystem = Rc::new(RefCell::new(filesystem));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(filesystem));
 
     let (http_downloader, _guard) = get_http_downloader_mock(
         Vec::new(),
@@ -346,7 +349,7 @@ fn test_downgrade_shows_appropriate_message() {
         },
     );
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let mut downloader = FileDownloader::new(
         io,
         config,
diff --git a/crates/shirabe/tests/downloader/fossil_downloader_test.rs b/crates/shirabe/tests/downloader/fossil_downloader_test.rs
index 912b4b47..eed3d7fb 100644
--- a/crates/shirabe/tests/downloader/fossil_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/fossil_downloader_test.rs
@@ -12,8 +12,6 @@ use shirabe::util::ProcessExecutor;
 use shirabe::util::filesystem::{Filesystem, FilesystemMock};
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
@@ -67,20 +65,23 @@ fn get_package(source_reference: Option<&str>, source_url: Option<&str>) -> Pack
 
 /// ref: FossilDownloaderTest::getDownloaderMock
 fn get_downloader_mock(
-    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>,
     config: Option<Config>,
-    process: Rc<RefCell<ProcessExecutor>>,
-    filesystem: Option<Rc<RefCell<Filesystem>>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+    filesystem: Option<std::rc::Rc<std::cell::RefCell<Filesystem>>>,
 ) -> FossilDownloader {
-    let io =
-        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
+    let io = io.unwrap_or_else(|| {
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()))
+            as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>
+    });
     // ref: getConfig(['secure-http' => false])
-    let config = Rc::new(RefCell::new(config.unwrap_or_else(|| {
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config.unwrap_or_else(|| {
         ConfigStubBuilder::new()
             .with("secure-http", PhpMixed::Bool(false))
             .build()
     })));
-    let fs = filesystem.unwrap_or_else(|| Rc::new(RefCell::new(Filesystem::new(None))));
+    let fs = filesystem
+        .unwrap_or_else(|| std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None))));
     FossilDownloader::new(io, config, process, fs)
 }
 
@@ -232,7 +233,7 @@ fn test_remove() {
         remove_directory_async_result: Some(true),
         ..Default::default()
     });
-    let filesystem = Rc::new(RefCell::new(filesystem));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(filesystem));
 
     let mut downloader = get_downloader_mock(None, None, process, Some(filesystem.clone()));
     run(async {
diff --git a/crates/shirabe/tests/downloader/git_downloader_test.rs b/crates/shirabe/tests/downloader/git_downloader_test.rs
index 7e98cae8..0d8af4e9 100644
--- a/crates/shirabe/tests/downloader/git_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/git_downloader_test.rs
@@ -18,8 +18,6 @@ use shirabe::util::ProcessExecutor;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
@@ -104,14 +102,16 @@ fn setup_config(config: Config) -> Config {
 
 /// ref: GitDownloaderTest::getDownloaderMock (defaults the IO/Config/Filesystem)
 fn get_downloader_mock(
-    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>,
     config: Option<Config>,
-    process: Rc<RefCell<ProcessExecutor>>,
-    filesystem: Option<Rc<RefCell<Filesystem>>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+    filesystem: Option<std::rc::Rc<std::cell::RefCell<Filesystem>>>,
 ) -> GitDownloader {
-    let io =
-        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
-    let config = Rc::new(RefCell::new(setup_config(
+    let io = io.unwrap_or_else(|| {
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()))
+            as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>
+    });
+    let config = std::rc::Rc::new(std::cell::RefCell::new(setup_config(
         config.unwrap_or_else(|| ConfigStubBuilder::new().build()),
     )));
     GitDownloader::new(io, config, Some(process), filesystem)
@@ -804,7 +804,7 @@ fn test_downgrade_shows_appropriate_message() {
         .borrow_mut()
         .expects(vec![Expectation::text_regex("{Downgrading .*}")], false)
         .unwrap();
-    let io = io_mock.clone() as Rc<RefCell<dyn IOInterface>>;
+    let io = io_mock.clone() as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>;
 
     let mut fs = Filesystem::new(None);
     fs.ensure_directory_exists(&format!("{}/.git", working_dir.path().to_string_lossy()))
@@ -882,7 +882,7 @@ fn test_not_using_downgrading_with_references() {
         .borrow_mut()
         .expects(vec![Expectation::text_regex("{Upgrading .*}")], false)
         .unwrap();
-    let io = io_mock.clone() as Rc<RefCell<dyn IOInterface>>;
+    let io = io_mock.clone() as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>;
 
     let mut fs = Filesystem::new(None);
     fs.ensure_directory_exists(&format!("{}/.git", working_dir.path().to_string_lossy()))
diff --git a/crates/shirabe/tests/downloader/hg_downloader_test.rs b/crates/shirabe/tests/downloader/hg_downloader_test.rs
index e68dfc5e..d68812d8 100644
--- a/crates/shirabe/tests/downloader/hg_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/hg_downloader_test.rs
@@ -10,8 +10,6 @@ use shirabe::package::handle::{CompletePackageHandle, PackageInterfaceHandle};
 use shirabe::util::ProcessExecutor;
 use shirabe::util::filesystem::{Filesystem, FilesystemMock};
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
@@ -69,17 +67,20 @@ fn get_package(source_reference: Option<&str>, source_url: Option<&str>) -> Pack
 /// returns null for everything; a default real `Config` resolves the only
 /// relevant key (`secure-http`) compatibly for the https URLs used here.
 fn get_downloader_mock(
-    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>,
     config: Option<Config>,
-    process: Rc<RefCell<ProcessExecutor>>,
-    filesystem: Option<Rc<RefCell<Filesystem>>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+    filesystem: Option<std::rc::Rc<std::cell::RefCell<Filesystem>>>,
 ) -> HgDownloader {
-    let io =
-        io.unwrap_or_else(|| Rc::new(RefCell::new(IOStub::new())) as Rc<RefCell<dyn IOInterface>>);
-    let config = Rc::new(RefCell::new(
+    let io = io.unwrap_or_else(|| {
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()))
+            as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>
+    });
+    let config = std::rc::Rc::new(std::cell::RefCell::new(
         config.unwrap_or_else(|| Config::new(false, None)),
     ));
-    let fs = filesystem.unwrap_or_else(|| Rc::new(RefCell::new(Filesystem::new(None))));
+    let fs = filesystem
+        .unwrap_or_else(|| std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None))));
     HgDownloader::new(io, config, process, fs)
 }
 
@@ -224,7 +225,7 @@ fn test_remove() {
         remove_directory_async_result: Some(true),
         ..Default::default()
     });
-    let filesystem = Rc::new(RefCell::new(filesystem));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(filesystem));
 
     let mut downloader = get_downloader_mock(None, None, process, Some(filesystem.clone()));
     run(async {
diff --git a/crates/shirabe/tests/downloader/perforce_downloader_test.rs b/crates/shirabe/tests/downloader/perforce_downloader_test.rs
index 70f28e10..13a818a6 100644
--- a/crates/shirabe/tests/downloader/perforce_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/perforce_downloader_test.rs
@@ -14,8 +14,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 // A getMockBuilder('Composer\Util\Perforce') stand-in: the seam trait extracted from the
@@ -83,13 +81,14 @@ fn test_init_perforce_instantiates_a_new_perforce_object() {
     // RepositoryInterface), so it cannot be held in a RepositoryInterfaceHandle. The package
     // is therefore built without a repository, yielding an empty repo config.
     let test_path = TempDir::new().unwrap();
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
-    let config = Rc::new(RefCell::new(get_config(test_path.path())));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(get_config(test_path.path())));
     let package = make_package(None);
 
     let (process, _process_guard) =
         get_process_executor_mock(vec![], false, MockHandler::default());
-    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
     let mut downloader = PerforceDownloader::new(io, config, process, fs);
 
     downloader.init_perforce(
@@ -102,11 +101,12 @@ fn test_init_perforce_instantiates_a_new_perforce_object() {
 #[test]
 fn test_init_perforce_does_nothing_if_perforce_already_set() {
     let test_path = TempDir::new().unwrap();
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
-    let config = Rc::new(RefCell::new(get_config(test_path.path())));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(get_config(test_path.path())));
     let (process, _process_guard) =
         get_process_executor_mock(vec![], false, MockHandler::default());
-    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
     let mut downloader = PerforceDownloader::new(io, config, process, fs);
 
     // The already-set perforce only sees initializePath; the repository's getRepoConfig is
@@ -147,11 +147,11 @@ fn do_install_workflow(source_ref: &'static str, expected_label: Option<String>)
             false,
         )
         .unwrap();
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
-    let config = Rc::new(RefCell::new(get_config(test_path.path())));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
+    let config = std::rc::Rc::new(std::cell::RefCell::new(get_config(test_path.path())));
     let (process, _process_guard) =
         get_process_executor_mock(vec![], false, MockHandler::default());
-    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+    let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
     let mut downloader = PerforceDownloader::new(io, config, process, fs);
 
     let mut perforce = MockPerforce::new();
diff --git a/crates/shirabe/tests/downloader/xz_downloader_test.rs b/crates/shirabe/tests/downloader/xz_downloader_test.rs
index 358f8964..6d504313 100644
--- a/crates/shirabe/tests/downloader/xz_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/xz_downloader_test.rs
@@ -14,8 +14,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::r#loop::Loop;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 /// ref: TestCase::getPackage (default class CompletePackage)
@@ -82,21 +80,24 @@ fn test_error_messages() {
     let dist_url = format!("file://{}", file!());
     package.set_dist_url(Some(dist_url));
 
-    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 mut config_options: IndexMap<String, PhpMixed> = IndexMap::new();
     config_options.insert(
         "vendor-dir".to_string(),
         PhpMixed::String(test_dir.to_string_lossy().into_owned()),
     );
-    let config = Rc::new(RefCell::new(get_config(config_options, false)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let config = std::rc::Rc::new(std::cell::RefCell::new(get_config(config_options, false)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
         false,
     )));
-    let filesystem = Rc::new(RefCell::new(Filesystem::new(None)));
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     let mut downloader = XzDownloader::new(
         io,
         config,
diff --git a/crates/shirabe/tests/downloader/zip_downloader_test.rs b/crates/shirabe/tests/downloader/zip_downloader_test.rs
index 43e79160..0c9e7b88 100644
--- a/crates/shirabe/tests/downloader/zip_downloader_test.rs
+++ b/crates/shirabe/tests/downloader/zip_downloader_test.rs
@@ -15,8 +15,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::r#loop::Loop;
 use shirabe_php_shim::{PhpMixed, ZipArchive, ZipArchiveMock};
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
@@ -28,9 +26,9 @@ fn run<F: std::future::Future>(future: F) -> F::Output {
 
 struct SetUp {
     test_dir: TempDir,
-    io: Rc<RefCell<dyn IOInterface>>,
-    config: Rc<RefCell<Config>>,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
     package: PackageInterfaceHandle,
     filename: std::path::PathBuf,
 }
@@ -44,10 +42,11 @@ struct SetUp {
 fn set_up() -> SetUp {
     let test_dir = TempDir::new().unwrap();
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let dl_config = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let dl_config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
         io.clone(),
         dl_config,
     )));
@@ -94,8 +93,10 @@ impl Drop for TearDown {
 }
 
 fn make_downloader(set_up: &SetUp) -> ZipDownloader {
-    let filesystem = Rc::new(RefCell::new(Filesystem::new(None)));
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(set_up.io.clone()))));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        set_up.io.clone(),
+    ))));
     ZipDownloader::new(
         set_up.io.clone(),
         set_up.config.clone(),
@@ -124,7 +125,8 @@ fn test_error_messages() {
     let test_dir = TempDir::new().unwrap();
     let _tear_down = TearDown::new(test_dir.path().to_path_buf());
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     // $this->config->method('get')->with('vendor-dir')->willReturn($this->testDir)
     let mut config = Config::new(false, None);
@@ -136,11 +138,11 @@ fn test_error_messages() {
     let mut merged: IndexMap<String, PhpMixed> = IndexMap::new();
     merged.insert("config".to_string(), PhpMixed::Array(config_options));
     config.merge(&merged, "test");
-    let config = Rc::new(RefCell::new(config));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
 
     // new HttpDownloader($this->io, $dlConfig): a real downloader (not the extract-path mock).
-    let dl_config = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let dl_config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         dl_config,
         IndexMap::new(),
@@ -155,8 +157,10 @@ fn test_error_messages() {
             .into();
     package.set_dist_url(Some(dist_url));
 
-    let filesystem = Rc::new(RefCell::new(Filesystem::new(None)));
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let filesystem = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     let mut downloader = ZipDownloader::new(
         io,
         config,
diff --git a/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs b/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
index cabb6794..67059a7c 100644
--- a/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
+++ b/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
@@ -17,8 +17,6 @@ use shirabe::util::platform::Platform;
 use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_external_packages::symfony::console::output::output_interface;
 use shirabe_php_shim::PHP_EOL;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn tear_down() {
     Platform::clear_env("COMPOSER_SKIP_SCRIPTS");
@@ -40,9 +38,10 @@ impl Drop for TearDown {
 /// here drive only command-line / composer-script listeners, which never touch those collaborators,
 /// so a minimal full Composer carrying a Config and a RootPackage is sufficient.
 fn create_composer_instance() -> ComposerHandle {
-    let composer =
-        ComposerHandle::from_rc_unchecked(Rc::new(RefCell::new(PartialOrFullComposer::new_full())));
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let composer = ComposerHandle::from_rc_unchecked(std::rc::Rc::new(std::cell::RefCell::new(
+        PartialOrFullComposer::new_full(),
+    )));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
     composer.borrow_mut().set_config(config);
     let package: RootPackageInterfaceHandle = RootPackageHandle::new(
         "foo".to_string(),
@@ -54,8 +53,8 @@ fn create_composer_instance() -> ComposerHandle {
     composer
 }
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(shirabe::io::null_io::NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(shirabe::io::null_io::NullIO::new()))
 }
 
 /// Locates a `php` executable on PATH and points `PHP_BINARY` at it.
@@ -83,8 +82,8 @@ fn ensure_php_binary() -> bool {
     false
 }
 
-fn buffer_io_verbose() -> Rc<RefCell<BufferIO>> {
-    Rc::new(RefCell::new(
+fn buffer_io_verbose() -> std::rc::Rc<std::cell::RefCell<BufferIO>> {
+    std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), output_interface::VERBOSITY_VERBOSE, None).unwrap(),
     ))
 }
@@ -93,8 +92,8 @@ fn buffer_io_verbose() -> Rc<RefCell<BufferIO>> {
 /// `getMockBuilder(EventDispatcher)->onlyMethods(['getListeners'])`.
 fn dispatcher_with_listeners(
     composer: &ComposerHandle,
-    io: Rc<RefCell<dyn IOInterface>>,
-    process: Rc<RefCell<ProcessExecutor>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     callback: Box<dyn Fn(&dyn EventInterface) -> Vec<Callable>>,
 ) -> EventDispatcher {
     let mut dispatcher = EventDispatcher::new(composer.upcast().downgrade(), io, Some(process));
@@ -154,7 +153,7 @@ fn test_dispatcher_can_execute_composer_script_groups() {
 
     let composer = create_composer_instance();
     let io = buffer_io_verbose();
-    let io_dyn: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
 
     let callback: Box<dyn Fn(&dyn EventInterface) -> Vec<Callable>> =
         Box::new(|event| match event.get_name() {
@@ -205,7 +204,7 @@ fn test_recursion_in_scripts_names() {
 
     let composer = create_composer_instance();
     let io = buffer_io_verbose();
-    let io_dyn: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
 
     let callback: Box<dyn Fn(&dyn EventInterface) -> Vec<Callable>> =
         Box::new(|event| match event.get_name() {
diff --git a/crates/shirabe/tests/factory_test.rs b/crates/shirabe/tests/factory_test.rs
index 8685861a..be32dac3 100644
--- a/crates/shirabe/tests/factory_test.rs
+++ b/crates/shirabe/tests/factory_test.rs
@@ -7,8 +7,6 @@ use shirabe::io::IOInterface;
 use shirabe::io::io_interface;
 use shirabe::util::platform::Platform;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[path = "common/config_stub.rs"]
 mod config_stub;
@@ -50,7 +48,7 @@ fn test_default_values_are_as_expected() {
         .with("disable-tls", PhpMixed::Bool(true))
         .build_shared();
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     Factory::create_http_downloader(io, &config, IndexMap::new()).unwrap();
 }
 
diff --git a/crates/shirabe/tests/installer/binary_installer_test.rs b/crates/shirabe/tests/installer/binary_installer_test.rs
index 6b3cae5d..8b2d0636 100644
--- a/crates/shirabe/tests/installer/binary_installer_test.rs
+++ b/crates/shirabe/tests/installer/binary_installer_test.rs
@@ -7,9 +7,7 @@ use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::util::Filesystem;
 use shirabe::util::ProcessExecutor;
-use std::cell::RefCell;
 use std::fs;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 /// Mirror of setUp(): builds temp root/vendor/bin dirs plus a mocked IO. PHP uses a
@@ -18,7 +16,7 @@ struct SetUp {
     root: TempDir,
     vendor_dir: String,
     bin_dir: String,
-    io: Rc<RefCell<dyn IOInterface>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
     fs: Filesystem,
 }
 
@@ -37,7 +35,8 @@ fn set_up() -> SetUp {
     let bin_dir = format!("{}/bin", root_dir);
     fs::create_dir_all(&bin_dir).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()));
 
     SetUp {
         root,
@@ -94,7 +93,9 @@ fn run_install_and_exec_binary_with_full_compat(contents: &[u8]) {
         setup.io.clone(),
         setup.bin_dir.clone(),
         "full".to_string(),
-        Some(Rc::new(RefCell::new(Filesystem::new(None)))),
+        Some(std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(
+            None,
+        )))),
         None,
     );
     installer.install_binaries(package, &pkg_dir, true);
diff --git a/crates/shirabe/tests/installer/installation_manager_test.rs b/crates/shirabe/tests/installer/installation_manager_test.rs
index bc1fcfdc..e3e4c0fc 100644
--- a/crates/shirabe/tests/installer/installation_manager_test.rs
+++ b/crates/shirabe/tests/installer/installation_manager_test.rs
@@ -14,8 +14,6 @@ use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
     tokio::runtime::Builder::new_current_thread()
@@ -27,17 +25,23 @@ fn run<F: std::future::Future>(future: F) -> F::Output {
 /// ref: setUp(): the PHP loop/io mocks are never exercised by these tests (the loop has its
 /// constructor disabled), so a real Loop over a real HttpDownloader and a NullIO stand in.
 struct SetUp {
-    loop_: Rc<RefCell<Loop>>,
-    io: Rc<RefCell<dyn IOInterface>>,
+    loop_: std::rc::Rc<std::cell::RefCell<Loop>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
 }
 
 fn set_up() -> SetUp {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(shirabe::config::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 config = std::rc::Rc::new(std::cell::RefCell::new(shirabe::config::Config::new(
+        false, None,
+    )));
     // The PHP loop mock has its constructor disabled and is never exercised by these tests, so a
     // mock HttpDownloader (no real curl backend) stands in.
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(io.clone(), config)));
-    let loop_ = Rc::new(RefCell::new(Loop::new(http_downloader, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
+        io.clone(),
+        config,
+    )));
+    let loop_ = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(http_downloader, None)));
     SetUp { loop_, io }
 }
 
@@ -150,12 +154,12 @@ struct BinaryInstallerCalls {
 
 #[derive(Debug)]
 struct BinaryInstaller {
-    calls: Rc<RefCell<BinaryInstallerCalls>>,
+    calls: std::rc::Rc<std::cell::RefCell<BinaryInstallerCalls>>,
 }
 
 impl BinaryInstaller {
-    fn new() -> (Self, Rc<RefCell<BinaryInstallerCalls>>) {
-        let calls = Rc::new(RefCell::new(BinaryInstallerCalls::default()));
+    fn new() -> (Self, std::rc::Rc<std::cell::RefCell<BinaryInstallerCalls>>) {
+        let calls = std::rc::Rc::new(std::cell::RefCell::new(BinaryInstallerCalls::default()));
         (
             Self {
                 calls: calls.clone(),
@@ -262,7 +266,7 @@ fn typed_package(name: &str, version: &str, r#type: &str) -> PackageInterfaceHan
 }
 
 fn same_handle(a: &PackageInterfaceHandle, b: &PackageInterfaceHandle) -> bool {
-    Rc::ptr_eq(a.as_rc(), b.as_rc())
+    std::rc::Rc::ptr_eq(a.as_rc(), b.as_rc())
 }
 
 #[test]
diff --git a/crates/shirabe/tests/installer/installer_event_test.rs b/crates/shirabe/tests/installer/installer_event_test.rs
index b3bf14df..8a8887ab 100644
--- a/crates/shirabe/tests/installer/installer_event_test.rs
+++ b/crates/shirabe/tests/installer/installer_event_test.rs
@@ -6,14 +6,13 @@ use shirabe::event_dispatcher::EventInterface;
 use shirabe::installer::InstallerEvent;
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[test]
 fn test_getter() {
-    let composer_rc = Rc::new(RefCell::new(PartialOrFullComposer::new_full()));
+    let composer_rc = std::rc::Rc::new(std::cell::RefCell::new(PartialOrFullComposer::new_full()));
     let composer = ComposerHandle::from_rc_unchecked(composer_rc);
-    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 transaction = Transaction::new(vec![], vec![]);
     let event = InstallerEvent::new(
         "EVENT_NAME".to_string(),
diff --git a/crates/shirabe/tests/installer/library_installer_test.rs b/crates/shirabe/tests/installer/library_installer_test.rs
index 44c7e5f7..72272a07 100644
--- a/crates/shirabe/tests/installer/library_installer_test.rs
+++ b/crates/shirabe/tests/installer/library_installer_test.rs
@@ -16,9 +16,7 @@ use shirabe::repository::RepositoryInterface;
 use shirabe::repository::WritableRepositoryInterface;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
 use std::fs;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 // PHP mocks `Composer\Downloader\DownloadManager` with getMockBuilder and asserts its
@@ -34,7 +32,7 @@ mockall::mock! {
         fn get_downloader_for_package(
             &self,
             package: PackageInterfaceHandle,
-        ) -> anyhow::Result<Option<Rc<RefCell<dyn DownloaderInterface>>>>;
+        ) -> anyhow::Result<Option<std::rc::Rc<std::cell::RefCell<dyn DownloaderInterface>>>>;
         async fn download(
             &self,
             package: PackageInterfaceHandle,
@@ -104,7 +102,7 @@ struct SetUp {
     root: TempDir,
     vendor_dir: String,
     bin_dir: String,
-    io: Rc<RefCell<dyn IOInterface>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
     composer: PartialComposerWeakHandle,
     fs: Filesystem,
     composer_full: ComposerHandle,
@@ -116,7 +114,7 @@ fn set_download_manager(setup: &SetUp, dm: MockDownloadManager) {
     setup
         .composer_full
         .borrow_mut()
-        .set_download_manager(Rc::new(RefCell::new(dm)));
+        .set_download_manager(std::rc::Rc::new(std::cell::RefCell::new(dm)));
 }
 
 fn set_up() -> SetUp {
@@ -144,11 +142,12 @@ fn set_up() -> SetUp {
     let mut merged: IndexMap<String, PhpMixed> = IndexMap::new();
     merged.insert("config".to_string(), PhpMixed::Array(config_section));
     config.merge(&merged, Config::SOURCE_UNKNOWN);
-    let config_rc = Rc::new(RefCell::new(config));
+    let config_rc = std::rc::Rc::new(std::cell::RefCell::new(config));
 
-    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 composer_rc = Rc::new(RefCell::new(PartialOrFullComposer::new_full()));
+    let composer_rc = std::rc::Rc::new(std::cell::RefCell::new(PartialOrFullComposer::new_full()));
     let composer = ComposerHandle::from_rc_unchecked(composer_rc.clone());
     composer.borrow_mut().set_config(config_rc);
     // Default unconfigured mock so LibraryInstaller::new can resolve a DownloadManager even in
@@ -156,7 +155,9 @@ fn set_up() -> SetUp {
     // set_download_manager.
     composer
         .borrow_mut()
-        .set_download_manager(Rc::new(RefCell::new(MockDownloadManager::new())));
+        .set_download_manager(std::rc::Rc::new(std::cell::RefCell::new(
+            MockDownloadManager::new(),
+        )));
 
     let weak = PartialComposerHandle::from_rc(composer_rc).downgrade();
 
@@ -236,7 +237,7 @@ fn test_install() {
     dm.expect_install()
         .times(1)
         .withf_st(move |package, target_dir| {
-            Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
+            std::rc::Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
                 && target_dir == expected_path.as_str()
         })
         .returning(|_, _| Ok(None));
@@ -290,8 +291,8 @@ fn test_update() {
     dm.expect_update()
         .times(1)
         .withf_st(move |initial, target, target_dir| {
-            Rc::ptr_eq(initial.as_rc(), expected_initial.as_rc())
-                && Rc::ptr_eq(target.as_rc(), expected_target.as_rc())
+            std::rc::Rc::ptr_eq(initial.as_rc(), expected_initial.as_rc())
+                && std::rc::Rc::ptr_eq(target.as_rc(), expected_target.as_rc())
                 && target_dir == expected_path.as_str()
         })
         .returning(|_, _, _| Ok(None));
@@ -343,7 +344,7 @@ fn test_uninstall() {
     dm.expect_remove()
         .times(1)
         .withf_st(move |package, target_dir| {
-            Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
+            std::rc::Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
                 && target_dir == expected_path.as_str()
         })
         .returning(|_, _| Ok(None));
@@ -426,12 +427,12 @@ fn test_ensure_binaries_installed() {
         .expect_install_binaries()
         .times(1)
         .withf_st(move |package, install_path, warn_on_overwrite| {
-            Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
+            std::rc::Rc::ptr_eq(package.as_rc(), expected_package.as_rc())
                 && install_path == expected_install_path.as_str()
                 && !*warn_on_overwrite
         })
         .returning(|_, _, _| ());
-    library.__set_binary_installer(Rc::new(RefCell::new(binary_installer)));
+    library.__set_binary_installer(std::rc::Rc::new(std::cell::RefCell::new(binary_installer)));
 
     library.ensure_binaries_presence(package.clone());
 
diff --git a/crates/shirabe/tests/installer/metapackage_installer_test.rs b/crates/shirabe/tests/installer/metapackage_installer_test.rs
index 8528f6a7..bc740e74 100644
--- a/crates/shirabe/tests/installer/metapackage_installer_test.rs
+++ b/crates/shirabe/tests/installer/metapackage_installer_test.rs
@@ -8,8 +8,6 @@ use shirabe::installer::{InstallerInterface, MetapackageInstaller};
 use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::repository::{InstalledArrayRepository, RepositoryInterface};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn run<F: std::future::Future>(future: F) -> F::Output {
     tokio::runtime::Builder::new_current_thread()
@@ -19,7 +17,8 @@ fn run<F: std::future::Future>(future: F) -> F::Output {
 }
 
 fn installer() -> MetapackageInstaller {
-    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()));
     MetapackageInstaller::new(io)
 }
 
diff --git a/crates/shirabe/tests/installer/suggested_packages_reporter_test.rs b/crates/shirabe/tests/installer/suggested_packages_reporter_test.rs
index 16650853..046e84e4 100644
--- a/crates/shirabe/tests/installer/suggested_packages_reporter_test.rs
+++ b/crates/shirabe/tests/installer/suggested_packages_reporter_test.rs
@@ -8,16 +8,18 @@ use shirabe::io::IOInterface;
 use shirabe::io::io_interface;
 use shirabe::io::null_io::NullIO;
 use shirabe::repository::{InstalledRepository, LockArrayRepository, RepositoryInterfaceHandle};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// ref: SuggestedPackagesReporterTest::setUp.
 ///
 /// Builds an IO mock and a SuggestedPackagesReporter sharing it. The IOMockGuard runs
 /// assert_complete when it drops at the end of the test scope.
-fn set_up() -> (Rc<RefCell<IOMock>>, SuggestedPackagesReporter, IOMockGuard) {
+fn set_up() -> (
+    std::rc::Rc<std::cell::RefCell<IOMock>>,
+    SuggestedPackagesReporter,
+    IOMockGuard,
+) {
     let (mock, guard) = get_io_mock(io_interface::NORMAL).unwrap();
-    let io: Rc<RefCell<dyn IOInterface>> = mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = mock.clone();
     let reporter = SuggestedPackagesReporter::new(io);
     (mock, reporter, guard)
 }
@@ -32,7 +34,8 @@ fn get_suggested_package_array() -> IndexMap<String, String> {
 }
 
 fn reporter() -> SuggestedPackagesReporter {
-    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()));
     SuggestedPackagesReporter::new(io)
 }
 
diff --git a/crates/shirabe/tests/installer_test.rs b/crates/shirabe/tests/installer_test.rs
index a38c870a..e5006b86 100644
--- a/crates/shirabe/tests/installer_test.rs
+++ b/crates/shirabe/tests/installer_test.rs
@@ -9,8 +9,6 @@ use config_stub::ConfigStubBuilder;
 use test_case::{get_package, get_version_constraint};
 
 use indexmap::IndexMap;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 use shirabe::advisory::{AuditConfig, Auditor};
 use shirabe::autoload::{AutoloadGeneratorInterface, ClassLoader};
@@ -83,7 +81,7 @@ impl DownloadManagerInterface for StubDownloadManager {
     fn get_downloader_for_package(
         &self,
         _package: PackageInterfaceHandle,
-    ) -> anyhow::Result<Option<Rc<RefCell<dyn DownloaderInterface>>>> {
+    ) -> anyhow::Result<Option<std::rc::Rc<std::cell::RefCell<dyn DownloaderInterface>>>> {
         Ok(None)
     }
     async fn download(
@@ -186,7 +184,7 @@ impl AutoloadGeneratorInterface for StubAutoloadGenerator {
     fn set_dry_run(&mut self, _dry_run: bool) {}
     fn set_platform_requirement_filter(
         &mut self,
-        _platform_requirement_filter: Rc<dyn PlatformRequirementFilterInterface>,
+        _platform_requirement_filter: std::rc::Rc<dyn PlatformRequirementFilterInterface>,
     ) {
     }
     #[allow(clippy::too_many_arguments)]
@@ -348,10 +346,10 @@ fn test_installer() {
     let _tear_down = TearDown;
 
     for case in provide_installer() {
-        let io_buffer = Rc::new(RefCell::new(
+        let io_buffer = std::rc::Rc::new(std::cell::RefCell::new(
             BufferIO::new(String::new(), VERBOSITY_NORMAL, None).unwrap(),
         ));
-        let io: Rc<RefCell<dyn IOInterface>> = io_buffer.clone();
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_buffer.clone();
 
         let config = ConfigStubBuilder::new()
             .with("vendor-dir", PhpMixed::String("foo".to_string()))
@@ -359,13 +357,12 @@ fn test_installer() {
             .with("notify-on-install", PhpMixed::Bool(true))
             .build_shared();
 
-        let download_manager: Rc<RefCell<dyn DownloadManagerInterface>> =
-            Rc::new(RefCell::new(StubDownloadManager));
+        let download_manager: std::rc::Rc<std::cell::RefCell<dyn DownloadManagerInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(StubDownloadManager));
 
-        let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(
-            io.clone(),
-            config.clone(),
-        )));
+        let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(
+            HttpDownloader::__new_mock(io.clone(), config.clone()),
+        ));
 
         let mut repository_manager = RepositoryManager::new(
             io.clone(),
@@ -380,13 +377,19 @@ fn test_installer() {
         for repository in &case.repositories {
             repository_manager.add_repository(repository.clone());
         }
-        let repository_manager: Rc<RefCell<dyn RepositoryManagerInterface>> =
-            Rc::new(RefCell::new(repository_manager));
+        let repository_manager: std::rc::Rc<std::cell::RefCell<dyn RepositoryManagerInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(repository_manager));
 
-        let r#loop = Rc::new(RefCell::new(Loop::new(http_downloader.clone(), None)));
-        let installation_manager: Rc<RefCell<InstallationManager>> = Rc::new(RefCell::new(
-            InstallationManager::__new_mock(r#loop, io.clone(), None),
-        ));
+        let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
+            http_downloader.clone(),
+            None,
+        )));
+        let installation_manager: std::rc::Rc<std::cell::RefCell<InstallationManager>> =
+            std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::__new_mock(
+                r#loop,
+                io.clone(),
+                None,
+            )));
 
         // emulate a writable lock file: a real JsonFile over a fresh temp path (initially absent, so
         // the installer falls back to an update; PHP uses an in-memory JsonFile mock instead).
@@ -394,17 +397,20 @@ fn test_installer() {
         let lock_path = lock_dir.path().join("composer.lock");
         let lock_json =
             JsonFile::new(lock_path.to_string_lossy().into_owned(), None, None).unwrap();
-        let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
-        let locker: Rc<RefCell<dyn LockerInterface>> = Rc::new(RefCell::new(Locker::new(
+        let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
             io.clone(),
-            lock_json,
-            installation_manager.clone(),
-            "{}",
-            process,
-        )));
+        ))));
+        let locker: std::rc::Rc<std::cell::RefCell<dyn LockerInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(Locker::new(
+                io.clone(),
+                lock_json,
+                installation_manager.clone(),
+                "{}",
+                process,
+            )));
 
-        let autoload_generator: Rc<RefCell<dyn AutoloadGeneratorInterface>> =
-            Rc::new(RefCell::new(StubAutoloadGenerator));
+        let autoload_generator: std::rc::Rc<std::cell::RefCell<dyn AutoloadGeneratorInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(StubAutoloadGenerator));
 
         let root_package: RootPackageInterfaceHandle =
             RootPackageInterfaceHandle::dup(&case.root_package.clone().into());
@@ -416,7 +422,7 @@ fn test_installer() {
             repository_manager,
             locker,
             installation_manager.clone(),
-            Rc::new(RefCell::new(StubEventDispatcher)),
+            std::rc::Rc::new(std::cell::RefCell::new(StubEventDispatcher)),
             autoload_generator,
         );
         installer.set_audit_config(
@@ -790,10 +796,10 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
         return; // markTestSkipped
     }
 
-    let io_buffer = Rc::new(RefCell::new(
+    let io_buffer = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), VERBOSITY_NORMAL, None).unwrap(),
     ));
-    let io: Rc<RefCell<dyn IOInterface>> = io_buffer.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_buffer.clone();
 
     let is_exception = matches!(case.expect_result, ExpectResult::Exception(_));
 
@@ -845,9 +851,11 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
 
     // The Locker needs a concrete InstallationManager; build a fresh recording mock just for it. The
     // asserted trace comes from the composer's own installation manager (read via as_any below).
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     let locker_loop = composer.borrow().get_loop();
-    let locker_im = Rc::new(RefCell::new(InstallationManager::__new_mock(
+    let locker_im = std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::__new_mock(
         locker_loop,
         io.clone(),
         None,
@@ -856,16 +864,20 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
     let locker = Locker::new(io.clone(), lock_json, locker_im, &contents, process);
     composer
         .borrow_mut()
-        .set_locker(Rc::new(RefCell::new(locker)));
+        .set_locker(std::rc::Rc::new(std::cell::RefCell::new(locker)));
 
     composer
         .borrow_mut()
-        .set_autoload_generator(Rc::new(RefCell::new(StubAutoloadGenerator)));
+        .set_autoload_generator(std::rc::Rc::new(std::cell::RefCell::new(
+            StubAutoloadGenerator,
+        )));
     composer
         .borrow_mut()
-        .set_event_dispatcher(Rc::new(RefCell::new(StubEventDispatcher)));
+        .set_event_dispatcher(std::rc::Rc::new(std::cell::RefCell::new(
+            StubEventDispatcher,
+        )));
 
-    let installer = Rc::new(RefCell::new(Installer::create(
+    let installer = std::rc::Rc::new(std::cell::RefCell::new(Installer::create(
         io.clone(),
         &composer.upcast(),
     )));
@@ -874,9 +886,12 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
     let application = ApplicationHandle::new("Composer".to_string(), "".to_string()).unwrap();
     application.set_catch_exceptions(false);
 
-    let run_result: Rc<RefCell<Option<anyhow::Result<i64>>>> = Rc::new(RefCell::new(None));
+    let run_result: std::rc::Rc<std::cell::RefCell<Option<anyhow::Result<i64>>>> =
+        std::rc::Rc::new(std::cell::RefCell::new(None));
 
-    let install = Rc::new(RefCell::new(CommandData::new(Some("install".to_string()))));
+    let install = std::rc::Rc::new(std::cell::RefCell::new(CommandData::new(Some(
+        "install".to_string(),
+    ))));
     {
         let install_ref = install.borrow();
         install_ref
@@ -944,10 +959,12 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
         }));
     }
     application
-        .add(install.clone() as Rc<RefCell<dyn SymfonyCommand>>)
+        .add(install.clone() as std::rc::Rc<std::cell::RefCell<dyn SymfonyCommand>>)
         .unwrap();
 
-    let update = Rc::new(RefCell::new(CommandData::new(Some("update".to_string()))));
+    let update = std::rc::Rc::new(std::cell::RefCell::new(CommandData::new(Some(
+        "update".to_string(),
+    ))));
     {
         let update_ref = update.borrow();
         for (name, mode) in [
@@ -1045,7 +1062,7 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
         }));
     }
     application
-        .add(update.clone() as Rc<RefCell<dyn SymfonyCommand>>)
+        .add(update.clone() as std::rc::Rc<std::cell::RefCell<dyn SymfonyCommand>>)
         .unwrap();
 
     assert!(
@@ -1059,8 +1076,10 @@ fn do_test_integration(case: &IntegrationCase, expect_output: Option<&str>) {
         .expect("php://memory is a valid stream");
     let mut string_input = StringInput::new(&format!("{} -vvv", case.run)).unwrap();
     string_input.set_interactive(false);
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(string_input));
-    let output: Rc<RefCell<dyn OutputInterface>> = Rc::new(RefCell::new(app_output));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(string_input));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(app_output));
 
     let app_run = application.run(Some(input), Some(output));
 
diff --git a/crates/shirabe/tests/io/console_io_test.rs b/crates/shirabe/tests/io/console_io_test.rs
index 9df851ec..62cb8322 100644
--- a/crates/shirabe/tests/io/console_io_test.rs
+++ b/crates/shirabe/tests/io/console_io_test.rs
@@ -23,17 +23,17 @@ use shirabe_external_packages::symfony::console::input::streamable_input_interfa
 use shirabe_external_packages::symfony::console::output::buffered_output::BufferedOutput;
 use shirabe_external_packages::symfony::console::output::output_interface::OutputInterface;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// Builds a ConsoleIO backed by real, side-effect-free Input/Output/QuestionHelper. PHP uses
 /// PHPUnit mocks here, but for tests that exercise only the authentication map they carry no
 /// expectations, so concrete implementations are an exact substitute.
 fn make_console_io() -> ConsoleIO {
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
     ConsoleIO::new(input, output, QuestionHelper::default())
 }
 
@@ -49,12 +49,17 @@ fn get_input_stream(input: &str) -> shirabe_php_shim::PhpResource {
 /// Builds a ConsoleIO whose interactive input stream yields `answer`, plus a handle on the
 /// `BufferedOutput` so the prompt can be inspected. The input is an `ArrayInput` (interactive by
 /// default) with the answer stream attached, exactly as the question-helper tests set things up.
-fn make_console_io_with_answer(answer: &str) -> (ConsoleIO, Rc<RefCell<BufferedOutput>>) {
+fn make_console_io_with_answer(
+    answer: &str,
+) -> (ConsoleIO, std::rc::Rc<std::cell::RefCell<BufferedOutput>>) {
     let mut array_input = ArrayInput::new(vec![], None).unwrap();
     array_input.set_stream(get_input_stream(answer));
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(array_input));
-    let buffered = Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
-    let output: Rc<RefCell<dyn OutputInterface>> = buffered.clone();
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(array_input));
+    let buffered = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
+        None, false, None,
+    )));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = buffered.clone();
     (
         ConsoleIO::new(input, output, QuestionHelper::default()),
         buffered,
@@ -66,9 +71,11 @@ fn test_is_interactive() {
     // PHP mocks isInteractive to return true then false on consecutive calls. A real ArrayInput
     // exposes a mutable interactive flag, so toggling it between the two asserts is equivalent.
     let array_input = ArrayInput::new(vec![], None).unwrap();
-    let input: Rc<RefCell<dyn InputInterface>> = Rc::new(RefCell::new(array_input));
-    let output: Rc<RefCell<dyn OutputInterface>> =
-        Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(array_input));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(BufferedOutput::new(None, false, None)),
+    );
     let console_io = ConsoleIO::new(input.clone(), output, QuestionHelper::default());
 
     input.borrow_mut().set_interactive(true);
@@ -82,10 +89,13 @@ fn test_write() {
     // PHP: expects write('some information about something', false) at VERBOSITY_NORMAL.
     // A plain (non-Console) OutputInterface routes write to the main output, so the message lands
     // in the BufferedOutput verbatim (no trailing EOL since newline is false).
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
-    let buffered = Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
-    let output: Rc<RefCell<dyn OutputInterface>> = buffered.clone();
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
+    let buffered = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
+        None, false, None,
+    )));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = buffered.clone();
     let console_io = ConsoleIO::new(input, output, QuestionHelper::default());
 
     console_io.write3("some information about something", false, NORMAL);
@@ -123,10 +133,13 @@ fn test_overwrite() {
     //   "\x08" * 12                        (clear previous, len = 12)
     //   'something longer than initial (34)' (new message)
     // The final overwrite needs no fill and newline defaults true, appending a trailing "\n".
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
-    let buffered = Rc::new(RefCell::new(BufferedOutput::new(None, false, None)));
-    let output: Rc<RefCell<dyn OutputInterface>> = buffered.clone();
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
+    let buffered = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
+        None, false, None,
+    )));
+    let output: std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> = buffered.clone();
     let console_io = ConsoleIO::new(input, output, QuestionHelper::default());
 
     console_io.write3("something (<question>strlen = 23</question>)", true, NORMAL);
diff --git a/crates/shirabe/tests/package/archiver/archive_manager_test.rs b/crates/shirabe/tests/package/archiver/archive_manager_test.rs
index b275692b..4f28b468 100644
--- a/crates/shirabe/tests/package/archiver/archive_manager_test.rs
+++ b/crates/shirabe/tests/package/archiver/archive_manager_test.rs
@@ -16,8 +16,6 @@ use shirabe_external_packages::symfony::process::Process;
 use shirabe_php_shim::{
     PhpMixed, file_exists, file_put_contents, realpath, sys_get_temp_dir, unlink,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 // ref: ArchiverTestCase::setUp + ArchiveManagerTest::setUp.
@@ -36,30 +34,34 @@ impl TestCase {
         let guard = TempDir::new().unwrap();
         let test_dir = guard.path().to_string_lossy().to_string();
 
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(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 config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
         // The filename/unknown-format tests never drive the download path, so a mock
         // HttpDownloader (no curl backend) is sufficient to satisfy Loop's dependency.
-        let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(
+        let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(
+            HttpDownloader::__new_mock(io.clone(), config.clone()),
+        ));
+        let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
             io.clone(),
-            config.clone(),
-        )));
-        let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
-        let fs = Rc::new(RefCell::new(Filesystem::new(Some(process.clone()))));
+        ))));
+        let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(
+            process.clone(),
+        ))));
         let mut dm = DownloadManager::new(io.clone(), false, Some(fs.clone()));
         // Factory::createDownloadManager registers a git downloader; the archive tests clone the
         // package source (source type 'git') through it.
         dm.set_downloader(
             "git",
-            Rc::new(RefCell::new(GitDownloader::new(
+            std::rc::Rc::new(std::cell::RefCell::new(GitDownloader::new(
                 io.clone(),
                 config.clone(),
                 Some(process.clone()),
                 Some(fs.clone()),
             ))),
         );
-        let dm = Rc::new(RefCell::new(dm));
-        let r#loop = Rc::new(RefCell::new(Loop::new(http_downloader, None)));
+        let dm = std::rc::Rc::new(std::cell::RefCell::new(dm));
+        let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(http_downloader, None)));
 
         let mut manager = ArchiveManager::new(dm, r#loop);
         manager.add_archiver(Box::new(ZipArchiver::new()));
diff --git a/crates/shirabe/tests/package/loader/root_package_loader_test.rs b/crates/shirabe/tests/package/loader/root_package_loader_test.rs
index 6a13736d..069cf5a7 100644
--- a/crates/shirabe/tests/package/loader/root_package_loader_test.rs
+++ b/crates/shirabe/tests/package/loader/root_package_loader_test.rs
@@ -21,18 +21,16 @@ use shirabe::util::Git as GitUtil;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
 fn http_downloader(
-    io: &Rc<RefCell<dyn IOInterface>>,
-    config: &Rc<RefCell<Config>>,
-) -> Rc<RefCell<HttpDownloader>> {
-    Rc::new(RefCell::new(HttpDownloader::new(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    config: &std::rc::Rc<std::cell::RefCell<Config>>,
+) -> std::rc::Rc<std::cell::RefCell<HttpDownloader>> {
+    std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
@@ -41,8 +39,8 @@ fn http_downloader(
 }
 
 // `$config = new Config; $config->merge(['repositories' => ['packagist' => false]]);`
-fn make_config() -> Rc<RefCell<Config>> {
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+fn make_config() -> std::rc::Rc<std::cell::RefCell<Config>> {
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
     let mut repositories: IndexMap<String, PhpMixed> = IndexMap::new();
     repositories.insert("packagist".to_string(), PhpMixed::Bool(false));
     let mut merge: IndexMap<String, PhpMixed> = IndexMap::new();
@@ -54,10 +52,10 @@ fn make_config() -> Rc<RefCell<Config>> {
 // Stands in for `getMockBuilder('Composer\Repository\RepositoryManager')->disableOriginalConstructor()`.
 // The loader only stores it and feeds it default repositories, so a real instance suffices.
 fn make_manager(
-    io: &Rc<RefCell<dyn IOInterface>>,
-    config: &Rc<RefCell<Config>>,
-) -> Rc<RefCell<RepositoryManager>> {
-    Rc::new(RefCell::new(RepositoryManager::new(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    config: &std::rc::Rc<std::cell::RefCell<Config>>,
+) -> std::rc::Rc<std::cell::RefCell<RepositoryManager>> {
+    std::rc::Rc::new(std::cell::RefCell::new(RepositoryManager::new(
         io.clone(),
         config.clone(),
         http_downloader(io, config),
@@ -103,7 +101,7 @@ mockall::mock! {
 #[ignore = "process_executor.enable_async() drives the async stream path, which calls stream_set_blocking (fcntl(2) todo!() in shirabe-php-shim::stream)"]
 fn test_stability_flags_parsing() {
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
     {
         let mut cfg = IndexMap::new();
         cfg.insert(
@@ -117,7 +115,7 @@ fn test_stability_flags_parsing() {
         config.borrow_mut().merge(&cfg, "test");
     }
 
-    let manager = Rc::new(RefCell::new(RepositoryManager::new(
+    let manager = std::rc::Rc::new(std::cell::RefCell::new(RepositoryManager::new(
         io.clone(),
         config.clone(),
         http_downloader(&io, &config),
@@ -129,7 +127,7 @@ fn test_stability_flags_parsing() {
     process_executor.enable_async();
     let guesser = VersionGuesser::new(
         config.clone(),
-        Rc::new(RefCell::new(process_executor)),
+        std::rc::Rc::new(std::cell::RefCell::new(process_executor)),
         VersionParser::new(),
         Some(io.clone()),
     );
diff --git a/crates/shirabe/tests/package/locker_test.rs b/crates/shirabe/tests/package/locker_test.rs
index bbc333e7..fc66293b 100644
--- a/crates/shirabe/tests/package/locker_test.rs
+++ b/crates/shirabe/tests/package/locker_test.rs
@@ -14,21 +14,24 @@ use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
 use shirabe::util::process_executor::ProcessExecutor;
 use shirabe_php_shim::{LogicException, PhpMixed, hash};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
-fn installation_manager(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<InstallationManager>> {
+fn installation_manager(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) -> std::rc::Rc<std::cell::RefCell<InstallationManager>> {
     // These tests never reach Locker::get_package_time, so the InstallationManager is never
     // actually used; build it over a mock HttpDownloader to avoid the unimplemented curl backend.
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::__new_mock(io.clone(), config)));
-    let r#loop = Rc::new(RefCell::new(Loop::new(http_downloader, None)));
-    Rc::new(RefCell::new(InstallationManager::new(
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::__new_mock(
+        io.clone(),
+        config,
+    )));
+    let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(http_downloader, None)));
+    std::rc::Rc::new(std::cell::RefCell::new(InstallationManager::new(
         r#loop,
         io.clone(),
         None,
@@ -57,7 +60,11 @@ fn get_json_content(custom_data: &[(&str, &str)]) -> String {
 fn make_locker(
     json_content: &str,
     lock_contents: Option<&str>,
-) -> (Locker, TempDir, Rc<RefCell<dyn IOInterface>>) {
+) -> (
+    Locker,
+    TempDir,
+    std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) {
     let temp_dir = TempDir::new().unwrap();
     let lock_path = temp_dir.path().join("composer.lock");
     if let Some(contents) = lock_contents {
@@ -66,7 +73,9 @@ fn make_locker(
 
     let io = null_io();
     let json_file = JsonFile::new(lock_path.to_string_lossy().into_owned(), None, None).unwrap();
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     let locker = Locker::new(
         io.clone(),
         json_file,
diff --git a/crates/shirabe/tests/package/version/version_guesser_test.rs b/crates/shirabe/tests/package/version/version_guesser_test.rs
index 1a3f23c1..92d5e90b 100644
--- a/crates/shirabe/tests/package/version/version_guesser_test.rs
+++ b/crates/shirabe/tests/package/version/version_guesser_test.rs
@@ -9,8 +9,6 @@ use shirabe::util::Git as GitUtil;
 use shirabe::util::platform::Platform;
 use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // Mirrors VersionGuesserTest::setUp/tearDown: reset GitUtil's cached `version`
 // static so each test re-runs `git --version` against its own mock.
@@ -27,19 +25,19 @@ impl Drop for TearDown {
 }
 
 // `$config = new Config; $config->merge(['repositories' => ['packagist' => false]]);`
-fn make_config() -> Rc<RefCell<Config>> {
+fn make_config() -> std::rc::Rc<std::cell::RefCell<Config>> {
     let mut config = Config::new(true, None);
     let mut repositories: IndexMap<String, PhpMixed> = IndexMap::new();
     repositories.insert("packagist".to_string(), PhpMixed::Bool(false));
     let mut merge: IndexMap<String, PhpMixed> = IndexMap::new();
     merge.insert("repositories".to_string(), PhpMixed::Array(repositories));
     config.merge(&merge, Config::SOURCE_UNKNOWN);
-    Rc::new(RefCell::new(config))
+    std::rc::Rc::new(std::cell::RefCell::new(config))
 }
 
 fn make_guesser(
-    config: Rc<RefCell<Config>>,
-    process: Rc<RefCell<ProcessExecutor>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
 ) -> VersionGuesser {
     VersionGuesser::new(config, process, VersionParser::new(), None)
 }
@@ -615,8 +613,8 @@ fn test_get_root_version_from_env() {
 
     for (env, expected_version) in root_env_versions {
         Platform::put_env("COMPOSER_ROOT_VERSION", env);
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
-        let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
+        let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
         let guesser = VersionGuesser::new(config, process, VersionParser::new(), None);
         assert_eq!(
             expected_version,
diff --git a/crates/shirabe/tests/package/version/version_selector_test.rs b/crates/shirabe/tests/package/version/version_selector_test.rs
index 3a0c7019..70874bcb 100644
--- a/crates/shirabe/tests/package/version/version_selector_test.rs
+++ b/crates/shirabe/tests/package/version/version_selector_test.rs
@@ -19,8 +19,6 @@ use shirabe_external_packages::symfony::console::output::output_interface;
 use shirabe_php_shim::PhpMixed;
 use shirabe_php_shim::{PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION};
 use shirabe_semver::constraint::AnyConstraint;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 mockall::mock! {
     RepositorySet {}
@@ -41,8 +39,10 @@ impl std::fmt::Debug for MockRepositorySet {
     }
 }
 
-fn into_seam(mock: MockRepositorySet) -> Rc<RefCell<dyn RepositorySetInterface>> {
-    Rc::new(RefCell::new(mock))
+fn into_seam(
+    mock: MockRepositorySet,
+) -> std::rc::Rc<std::cell::RefCell<dyn RepositorySetInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(mock))
 }
 
 /// Mirrors PHPUnit `assertSame($expected, $best)`: object identity, not value equality.
@@ -77,7 +77,7 @@ fn find_best(
             dyn shirabe::filter::platform_requirement_filter::PlatformRequirementFilterInterface,
         >,
     >,
-    io: Option<Rc<RefCell<dyn IOInterface>>>,
+    io: Option<std::rc::Rc<std::cell::RefCell<dyn IOInterface>>>,
 ) -> Option<PackageInterfaceHandle> {
     version_selector
         .find_best_candidate(
@@ -159,10 +159,10 @@ fn test_latest_version_is_returned_that_matches_php_requirements() {
     let mut version_selector =
         VersionSelector::new(into_seam(repository_set), Some(&mut platform)).unwrap();
 
-    let io = Rc::new(RefCell::new(
+    let io = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), output_interface::VERBOSITY_NORMAL, None).unwrap(),
     ));
-    let io_dyn: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
     let best = find_best(
         &mut version_selector,
         package_name,
@@ -180,10 +180,10 @@ fn test_latest_version_is_returned_that_matches_php_requirements() {
         io.borrow().get_output()
     );
 
-    let io = Rc::new(RefCell::new(
+    let io = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), output_interface::VERBOSITY_VERBOSE, None).unwrap(),
     ));
-    let io_dyn: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
     let best = find_best(
         &mut version_selector,
         package_name,
diff --git a/crates/shirabe/tests/question/strict_confirmation_question_test.rs b/crates/shirabe/tests/question/strict_confirmation_question_test.rs
index d8606ebe..37d57117 100644
--- a/crates/shirabe/tests/question/strict_confirmation_question_test.rs
+++ b/crates/shirabe/tests/question/strict_confirmation_question_test.rs
@@ -7,8 +7,6 @@ use shirabe_external_packages::symfony::console::input::streamable_input_interfa
 use shirabe_external_packages::symfony::console::output::output_interface::OutputInterface;
 use shirabe_external_packages::symfony::console::output::stream_output::StreamOutput;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const TRUE_ANSWER_REGEX: &str = "/^y(?:es)?$/i";
 const FALSE_ANSWER_REGEX: &str = "/^no?$/i";
@@ -111,12 +109,12 @@ fn get_input_stream(input: &str) -> shirabe_php_shim::PhpResource {
     stream
 }
 
-fn create_output_interface() -> Rc<RefCell<dyn OutputInterface>> {
+fn create_output_interface() -> std::rc::Rc<std::cell::RefCell<dyn OutputInterface>> {
     let stream = shirabe_php_shim::php_fopen_resource("php://memory", "r+");
     let output = StreamOutput::new(stream, None, None, None)
         .unwrap()
         .expect("php://memory is a valid stream");
-    Rc::new(RefCell::new(output))
+    std::rc::Rc::new(std::cell::RefCell::new(output))
 }
 
 /// @return array{ArrayInput, QuestionHelper}
diff --git a/crates/shirabe/tests/repository/artifact_repository_test.rs b/crates/shirabe/tests/repository/artifact_repository_test.rs
index 558ee8b1..2bfe85de 100644
--- a/crates/shirabe/tests/repository/artifact_repository_test.rs
+++ b/crates/shirabe/tests/repository/artifact_repository_test.rs
@@ -4,8 +4,6 @@ use indexmap::IndexMap;
 use shirabe::io::{IOInterface, NullIO};
 use shirabe::repository::ArtifactRepository;
 use shirabe_php_shim::{PhpMixed, extension_loaded};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// Returns true when the test should be skipped because the zip extension is
 /// unavailable, mirroring PHP's markTestSkipped in setUp.
@@ -29,7 +27,8 @@ fn create_repo(url: &str) -> ArtifactRepository {
     coordinates.insert("type".to_string(), PhpMixed::String("artifact".to_string()));
     coordinates.insert("url".to_string(), PhpMixed::String(url.to_string()));
 
-    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()));
     ArtifactRepository::new(coordinates, io).unwrap()
 }
 
diff --git a/crates/shirabe/tests/repository/composer_repository_test.rs b/crates/shirabe/tests/repository/composer_repository_test.rs
index 8e5a7f12..613dbb8e 100644
--- a/crates/shirabe/tests/repository/composer_repository_test.rs
+++ b/crates/shirabe/tests/repository/composer_repository_test.rs
@@ -11,8 +11,6 @@ use shirabe::repository::composer_repository::{ComposerRepository, ProviderListi
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::constraint::{AnyConstraint, SimpleConstraint};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 // Mirrors PHP's `['url' => .., 'body' => ..]` mock entry (status defaults to 200,
@@ -53,8 +51,8 @@ fn create_config_read_only() -> (Config, TempDir) {
     (config, home)
 }
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
 fn repo_config(url: &str) -> IndexMap<String, PhpMixed> {
@@ -250,9 +248,9 @@ fn test_what_provides() {
     )
     .unwrap();
 
-    let rc = Rc::new(RefCell::new(repo));
-    let rc_dyn: Rc<RefCell<dyn RepositoryInterface>> = rc.clone();
-    rc.borrow().set_self_handle(Rc::downgrade(&rc_dyn));
+    let rc = std::rc::Rc::new(std::cell::RefCell::new(repo));
+    let rc_dyn: std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>> = rc.clone();
+    rc.borrow().set_self_handle(std::rc::Rc::downgrade(&rc_dyn));
 
     let mut provider_listing: IndexMap<String, ProviderListingEntry> = IndexMap::new();
     provider_listing.insert("a".to_string(), ProviderListingEntry { sha256 });
diff --git a/crates/shirabe/tests/repository/filesystem_repository_test.rs b/crates/shirabe/tests/repository/filesystem_repository_test.rs
index e8bdddb2..f9d03ecd 100644
--- a/crates/shirabe/tests/repository/filesystem_repository_test.rs
+++ b/crates/shirabe/tests/repository/filesystem_repository_test.rs
@@ -15,8 +15,6 @@ use shirabe::repository::filesystem_repository::FilesystemRepository;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
 use shirabe_semver::VersionParser;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 /// PHP mocks JsonFile::read()/exists(); without a mocking framework the canned read value is
 /// materialized as a real temp file whose decoded JSON reproduces the mock return value exactly.
@@ -107,14 +105,14 @@ mockall::mock! {
         fn execute(
             &mut self,
             repo: &mut dyn InstalledRepositoryInterface,
-            operations: Vec<Rc<dyn OperationInterface>>,
+            operations: Vec<std::rc::Rc<dyn OperationInterface>>,
             dev_mode: bool,
             run_scripts: bool,
             download_only: bool,
         ) -> anyhow::Result<()>;
         fn get_install_path(&mut self, package: PackageInterfaceHandle) -> Option<String>;
         fn set_output_progress(&mut self, output_progress: bool);
-        fn notify_installs(&mut self, io: Rc<RefCell<dyn IOInterface>>);
+        fn notify_installs(&mut self, io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>);
     }
 }
 
diff --git a/crates/shirabe/tests/repository/path_repository_test.rs b/crates/shirabe/tests/repository/path_repository_test.rs
index f86d659d..1cd034d2 100644
--- a/crates/shirabe/tests/repository/path_repository_test.rs
+++ b/crates/shirabe/tests/repository/path_repository_test.rs
@@ -11,8 +11,6 @@ use shirabe::util::{Platform, ProcessExecutor};
 use shirabe_php_shim::{
     DIRECTORY_SEPARATOR, PhpMixed, file_get_contents, hash, realpath, serialize,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn fixtures_dir() -> String {
     format!(
@@ -23,14 +21,15 @@ fn fixtures_dir() -> String {
 
 /// ref: PathRepositoryTest::createPathRepo
 fn create_path_repo(options: IndexMap<String, PhpMixed>) -> PathRepository {
-    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 config = Rc::new(RefCell::new(Config::new(true, None)));
-    let proc = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
+    let proc = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     // ref: createPathRepo wires the ProcessExecutor through a Loop so the VersionGuesser's async
     // git calls are permitted; constructing the Loop calls enable_async() on the shared executor.
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
diff --git a/crates/shirabe/tests/repository/repository_factory_test.rs b/crates/shirabe/tests/repository/repository_factory_test.rs
index ef523808..287e7a4e 100644
--- a/crates/shirabe/tests/repository/repository_factory_test.rs
+++ b/crates/shirabe/tests/repository/repository_factory_test.rs
@@ -7,14 +7,13 @@ use shirabe::io::null_io::NullIO;
 use shirabe::repository::RepositoryFactory;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[test]
 fn test_manager_with_all_repository_types() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
diff --git a/crates/shirabe/tests/repository/repository_manager_test.rs b/crates/shirabe/tests/repository/repository_manager_test.rs
index c67cec49..2eac5265 100644
--- a/crates/shirabe/tests/repository/repository_manager_test.rs
+++ b/crates/shirabe/tests/repository/repository_manager_test.rs
@@ -14,8 +14,6 @@ use shirabe::repository::{
 use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -50,13 +48,15 @@ impl Drop for TearDown {
     }
 }
 
-fn null_io() -> Rc<RefCell<dyn IOInterface>> {
-    Rc::new(RefCell::new(NullIO::new()))
+fn null_io() -> std::rc::Rc<std::cell::RefCell<dyn IOInterface>> {
+    std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()))
 }
 
-fn http_downloader(io: &Rc<RefCell<dyn IOInterface>>) -> Rc<RefCell<HttpDownloader>> {
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
-    Rc::new(RefCell::new(HttpDownloader::new(
+fn http_downloader(
+    io: &std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+) -> std::rc::Rc<std::cell::RefCell<HttpDownloader>> {
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
+    std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config,
         IndexMap::new(),
@@ -78,7 +78,7 @@ fn test_prepend() {
     let _tear_down = TearDown::new(tmpdir.path().to_path_buf());
 
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
     let mut rm = RepositoryManager::new(io.clone(), config, http_downloader(&io), None, None);
 
     let repository1 = RepositoryInterfaceHandle::new(ArrayRepository::new(vec![]).unwrap());
@@ -96,7 +96,7 @@ fn test_repo_creation() {
     let _tear_down = TearDown::new(tmpdir.path().to_path_buf());
 
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
     let mut rm =
         RepositoryManager::new(io.clone(), config.clone(), http_downloader(&io), None, None);
 
@@ -181,7 +181,7 @@ fn test_invalid_repo_creation_throws() {
     let _tear_down = TearDown::new(tmpdir.path().to_path_buf());
 
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
     let rm = RepositoryManager::new(io.clone(), config.clone(), http_downloader(&io), None, None);
 
     config.borrow_mut().merge(
@@ -217,7 +217,7 @@ fn test_filter_repo_wrapping() {
     let _tear_down = TearDown::new(tmpdir.path().to_path_buf());
 
     let io = null_io();
-    let config = Rc::new(RefCell::new(Config::new(false, None)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(false, None)));
     let mut rm = RepositoryManager::new(io.clone(), config, http_downloader(&io), None, None);
 
     rm.set_repository_class("path", "Composer\\Repository\\PathRepository");
diff --git a/crates/shirabe/tests/repository/vcs/forgejo_driver_test.rs b/crates/shirabe/tests/repository/vcs/forgejo_driver_test.rs
index 296309f4..d9138b0c 100644
--- a/crates/shirabe/tests/repository/vcs/forgejo_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/forgejo_driver_test.rs
@@ -11,14 +11,12 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
     home: TempDir,
-    config: Rc<RefCell<Config>>,
-    io: Rc<RefCell<dyn IOInterface>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
 }
 
 fn set_up() -> SetUp {
@@ -39,11 +37,12 @@ fn set_up() -> SetUp {
 
     // PHP mocks IOInterface with isInteractive() => true; on the passing (200) paths
     // exercised here the interactivity flag is never consulted, so a bare NullIO matches.
-    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()));
 
     SetUp {
         home,
-        config: Rc::new(RefCell::new(config)),
+        config: std::rc::Rc::new(std::cell::RefCell::new(config)),
         io,
     }
 }
@@ -73,7 +72,7 @@ impl Drop for TearDown {
 fn initialize_driver(
     set_up: &SetUp,
     repo_url: &str,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
 ) -> (ForgejoDriver, ProcessExecutorMockGuard) {
     let (process, process_guard) = get_process_executor_mock(vec![], false, MockHandler::default());
 
@@ -93,7 +92,10 @@ fn initialize_driver(
 
 fn http_mock(
     expectations: Vec<shirabe::util::http_downloader::HttpDownloaderMockExpectation>,
-) -> (Rc<RefCell<HttpDownloader>>, HttpDownloaderMockGuard) {
+) -> (
+    std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
+    HttpDownloaderMockGuard,
+) {
     get_http_downloader_mock(expectations, true, HttpDownloaderMockHandler::default())
 }
 
diff --git a/crates/shirabe/tests/repository/vcs/fossil_driver_test.rs b/crates/shirabe/tests/repository/vcs/fossil_driver_test.rs
index 1a5a4256..77c1f130 100644
--- a/crates/shirabe/tests/repository/vcs/fossil_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/fossil_driver_test.rs
@@ -7,8 +7,6 @@ use shirabe::io::null_io::NullIO;
 use shirabe::repository::vcs::FossilDriver;
 use shirabe::util::filesystem::Filesystem;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -66,8 +64,9 @@ fn support_provider() -> Vec<(&'static str, bool)> {
 #[test]
 fn test_support() {
     for (url, assertion) in support_provider() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
         let result = FossilDriver::supports(io, config, url, false).unwrap();
         assert_eq!(assertion, result);
     }
diff --git a/crates/shirabe/tests/repository/vcs/git_bitbucket_driver_test.rs b/crates/shirabe/tests/repository/vcs/git_bitbucket_driver_test.rs
index 124d5291..4d84bcf2 100644
--- a/crates/shirabe/tests/repository/vcs/git_bitbucket_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/git_bitbucket_driver_test.rs
@@ -11,8 +11,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
 use shirabe::util::process_executor::ProcessExecutor;
 use shirabe_php_shim::{InvalidArgumentException, PhpMixed, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -70,14 +68,16 @@ fn http_body(
 // then calls initialize().
 fn get_driver(
     url: &str,
-    io: Rc<RefCell<dyn IOInterface>>,
-    config: Rc<RefCell<Config>>,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
 ) -> anyhow::Result<GitBitbucketDriver> {
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
 
     let mut driver = GitBitbucketDriver::new(repo_config, io, config, http_downloader, process);
     driver.initialize()?;
@@ -89,8 +89,9 @@ fn test_get_root_identifier_wrong_scm_type() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) = get_http_downloader_mock(
         vec![http_body(
@@ -124,8 +125,9 @@ fn test_driver() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let urls = [
         "https://api.bitbucket.org/2.0/repositories/user/repo?fields=-project%2C-owner",
@@ -238,8 +240,9 @@ fn test_initialize_invalid_repository_url() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard) =
         get_http_downloader_mock(vec![], true, HttpDownloaderMockHandler::default());
@@ -257,8 +260,9 @@ fn test_invalid_support_data() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let repo_url = "https://bitbucket.org/user/repo.git";
 
@@ -306,8 +310,9 @@ fn test_invalid_support_data() {
 
 #[test]
 fn test_supports() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
 
     assert!(
         GitBitbucketDriver::supports(
diff --git a/crates/shirabe/tests/repository/vcs/git_driver_test.rs b/crates/shirabe/tests/repository/vcs/git_driver_test.rs
index be26dd1d..7a85d4cc 100644
--- a/crates/shirabe/tests/repository/vcs/git_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/git_driver_test.rs
@@ -13,8 +13,6 @@ use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe::util::platform::Platform;
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::{PhpMixed, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -80,8 +78,9 @@ fn test_get_root_identifier_from_remote_local_repository() {
     let home_path = home.path().to_string_lossy().into_owned();
     let _tear_down = TearDown::new(home.path().to_path_buf(), network_env);
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -114,8 +113,9 @@ fn test_get_root_identifier_from_remote() {
     let home_path = home.path().to_string_lossy().into_owned();
     let _tear_down = TearDown::new(home.path().to_path_buf(), network_env);
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -182,8 +182,9 @@ fn test_get_root_identifier_from_local_with_network_disabled() {
 
     Platform::put_env("COMPOSER_DISABLE_NETWORK", "1");
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -218,8 +219,9 @@ fn test_get_branches_filter_invalid_branch_names() {
     let home_path = home.path().to_string_lossy().into_owned();
     let _tear_down = TearDown::new(home.path().to_path_buf(), network_env);
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -270,8 +272,9 @@ fn test_file_get_content_invalid_identifier() {
     } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf(), network_env);
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -302,8 +305,9 @@ fn test_get_change_date_invalid_identifier() {
     } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf(), network_env);
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
diff --git a/crates/shirabe/tests/repository/vcs/github_driver_test.rs b/crates/shirabe/tests/repository/vcs/github_driver_test.rs
index 11da393a..5b8367c7 100644
--- a/crates/shirabe/tests/repository/vcs/github_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/github_driver_test.rs
@@ -15,8 +15,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -136,8 +134,9 @@ fn test_supports() {
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
     for (expected, repo_url) in supports_provider() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
 
         assert_eq!(
             expected,
@@ -157,13 +156,14 @@ fn test_private_repository() {
     let identifier = "v0.0.0";
     let sha = "SOMESHA";
 
-    let config = Rc::new(RefCell::new(config));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new()
-            .with_is_interactive(true)
-            .with_ask_and_hide_answer(Some("sometoken".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new()
+                .with_is_interactive(true)
+                .with_ask_and_hide_answer(Some("sometoken".to_string())),
+        ));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) = get_http_downloader_mock(
         vec![
@@ -239,9 +239,10 @@ fn test_public_repository() {
     let identifier = "v0.0.0";
     let sha = "SOMESHA";
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![http_body(
@@ -252,7 +253,7 @@ fn test_public_repository() {
         HttpDownloaderMockHandler::default(),
     );
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
@@ -296,9 +297,10 @@ fn test_public_repository2() {
     let identifier = "feature/3.2-foo";
     let sha = "SOMESHA";
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![
@@ -329,7 +331,7 @@ fn test_public_repository2() {
         HttpDownloaderMockHandler::default(),
     );
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
@@ -379,9 +381,10 @@ fn test_invalid_support_data() {
     let identifier = "feature/3.2-foo";
     let sha = "SOMESHA";
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![
@@ -412,7 +415,7 @@ fn test_invalid_support_data() {
         HttpDownloaderMockHandler::default(),
     );
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
@@ -522,9 +525,10 @@ fn test_funding_format() {
         let identifier = "feature/3.2-foo";
         let sha = "SOMESHA";
 
-        let config = Rc::new(RefCell::new(config));
-        let io: Rc<RefCell<dyn IOInterface>> =
-            Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+            std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+        );
 
         let (http_downloader, _http_guard) = get_http_downloader_mock(
             vec![
@@ -552,7 +556,7 @@ fn test_funding_format() {
             HttpDownloaderMockHandler::default(),
         );
 
-        let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+        let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
         let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
         repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
@@ -621,9 +625,10 @@ fn test_public_repository_archived() {
         sha
     );
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![
@@ -657,7 +662,7 @@ fn test_public_repository_archived() {
         HttpDownloaderMockHandler::default(),
     );
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
@@ -688,9 +693,10 @@ fn test_private_repository_no_interaction() {
     let identifier = "v0.0.0";
     let sha = "SOMESHA";
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(false)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(false)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![http_status(repo_api_url, 404)],
@@ -810,12 +816,13 @@ fn test_initialize_invalid_repo_url() {
         let SetUp { home, config } = set_up();
         let _tear_down = TearDown::new(home.path().to_path_buf());
 
-        let config = Rc::new(RefCell::new(config));
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
         let (http_downloader, _http_guard) =
             get_http_downloader_mock(vec![], true, HttpDownloaderMockHandler::default());
-        let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+        let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
         let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
         repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
@@ -838,9 +845,10 @@ fn test_get_empty_file_content() {
 
     let repo_url = "http://github.com/composer/packagist";
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_is_interactive(true)));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_is_interactive(true)),
+    );
 
     let (http_downloader, _http_guard) = get_http_downloader_mock(
         vec![
@@ -857,7 +865,7 @@ fn test_get_empty_file_content() {
         HttpDownloaderMockHandler::default(),
     );
 
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(repo_url.to_string()));
diff --git a/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs b/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
index f3648630..1a201ba0 100644
--- a/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/gitlab_driver_test.rs
@@ -10,8 +10,6 @@ use shirabe::repository::vcs::GitLabDriver;
 use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
 use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_php_shim::{PhpMixed, extension_loaded};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // Mirrors GitLabDriverTest::setUp's `gitlab-domains` configuration.
 fn make_config() -> Config {
@@ -38,15 +36,16 @@ fn make_config() -> Config {
 // bare `getMock()` ProcessExecutor; none of these tests invoke git, so an empty
 // strict expectation set both matches PHP and catches unexpected process calls.
 struct Fixtures {
-    io: Rc<RefCell<dyn IOInterface>>,
-    config: Rc<RefCell<Config>>,
-    process: Rc<RefCell<ProcessExecutor>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     _process_guard: ProcessExecutorMockGuard,
 }
 
 fn fixtures() -> Fixtures {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(make_config()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(make_config()));
     let (process, _process_guard) = get_process_executor_mock(vec![], true, MockHandler::default());
     Fixtures {
         io,
@@ -60,7 +59,10 @@ fn fixtures() -> Fixtures {
 fn http_mock_with_body(
     url: &str,
     body: &str,
-) -> (Rc<RefCell<HttpDownloader>>, HttpDownloaderMockGuard) {
+) -> (
+    std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
+    HttpDownloaderMockGuard,
+) {
     get_http_downloader_mock(
         vec![expect_full(url, None, 200, body, vec![String::new()])],
         true,
@@ -625,8 +627,9 @@ fn test_get_branches() {
 #[test]
 fn test_supports() {
     for (url, expected) in data_for_test_supports() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(make_config()));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(make_config()));
 
         assert_eq!(
             expected,
@@ -867,7 +870,7 @@ fn test_protocol_override_repository_url_generation() {
     );
     top.insert("config".to_string(), PhpMixed::Array(config_section));
     config.merge(&top, Config::SOURCE_UNKNOWN);
-    let config = Rc::new(RefCell::new(config));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
 
     let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
     repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
diff --git a/crates/shirabe/tests/repository/vcs/hg_driver_test.rs b/crates/shirabe/tests/repository/vcs/hg_driver_test.rs
index 5e16c679..be36f412 100644
--- a/crates/shirabe/tests/repository/vcs/hg_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/hg_driver_test.rs
@@ -12,8 +12,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::{PhpMixed, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -70,8 +68,9 @@ fn supports_data_provider() -> Vec<&'static str> {
 #[test]
 fn test_supports() {
     for repository_url in supports_data_provider() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
 
         assert!(HgDriver::supports(io, config, repository_url, false).unwrap());
     }
@@ -82,8 +81,9 @@ fn test_get_branches_filter_invalid_branch_names() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -120,8 +120,9 @@ fn test_file_get_content_invalid_identifier() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
@@ -148,8 +149,9 @@ fn test_get_change_date_invalid_identifier() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
diff --git a/crates/shirabe/tests/repository/vcs/perforce_driver_test.rs b/crates/shirabe/tests/repository/vcs/perforce_driver_test.rs
index 13b36a3c..ea7976fd 100644
--- a/crates/shirabe/tests/repository/vcs/perforce_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/perforce_driver_test.rs
@@ -10,8 +10,6 @@ use shirabe::util::HttpDownloader;
 use shirabe::util::filesystem::Filesystem;
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 const TEST_URL: &str = "TEST_PERFORCE_URL";
@@ -92,9 +90,10 @@ fn make_driver(
     config: Config,
     repo_config: &IndexMap<String, PhpMixed>,
 ) -> (PerforceDriver, ProcessExecutorMockGuard) {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(config));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
@@ -130,8 +129,9 @@ impl Drop for TearDown {
 
 #[test]
 fn test_supports_returns_false_no_deep_check() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
 
     assert!(!PerforceDriver::supports(io, config, "existing.url", false).unwrap());
 }
diff --git a/crates/shirabe/tests/repository/vcs/svn_driver_test.rs b/crates/shirabe/tests/repository/vcs/svn_driver_test.rs
index 70eeeadc..6a74063d 100644
--- a/crates/shirabe/tests/repository/vcs/svn_driver_test.rs
+++ b/crates/shirabe/tests/repository/vcs/svn_driver_test.rs
@@ -12,8 +12,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::{PhpMixed, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -69,8 +67,9 @@ fn support_provider() -> Vec<(&'static str, bool)> {
 #[test]
 fn test_support() {
     for (url, assertion) in support_provider() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
 
         assert_eq!(
             assertion,
@@ -84,8 +83,9 @@ fn test_wrong_credentials_in_url() {
     let SetUp { home, config } = set_up();
     let _tear_down = TearDown::new(home.path().to_path_buf());
 
-    let config = Rc::new(RefCell::new(config));
-    let console: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let console: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
 
     let (http_downloader, _http_guard): (_, HttpDownloaderMockGuard) =
         get_http_downloader_mock(vec![], false, HttpDownloaderMockHandler::default());
diff --git a/crates/shirabe/tests/repository/vcs_repository_test.rs b/crates/shirabe/tests/repository/vcs_repository_test.rs
index 1ee72cb8..9ae3eac4 100644
--- a/crates/shirabe/tests/repository/vcs_repository_test.rs
+++ b/crates/shirabe/tests/repository/vcs_repository_test.rs
@@ -11,8 +11,6 @@ use shirabe::util::filesystem::Filesystem;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 use tempfile::TempDir;
 
 struct SetUp {
@@ -196,16 +194,19 @@ fn test_load_versions() {
     );
     top.insert("config".to_string(), PhpMixed::Array(config_section));
     config.merge(&top, Config::SOURCE_UNKNOWN);
-    let config = Rc::new(RefCell::new(config));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let http_downloader = Rc::new(RefCell::new(HttpDownloader::new(
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let http_downloader = std::rc::Rc::new(std::cell::RefCell::new(HttpDownloader::new(
         io.clone(),
         config.clone(),
         IndexMap::new(),
         false,
     )));
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(Some(io.clone()))));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(Some(
+        io.clone(),
+    ))));
     // VcsRepository's git driver / VersionGuesser run async git processes; constructing a Loop
     // enables async on the shared ProcessExecutor.
     let _loop = Loop::new(http_downloader.clone(), Some(process.clone()));
diff --git a/crates/shirabe/tests/script/event_test.rs b/crates/shirabe/tests/script/event_test.rs
index e249269d..e4fea99d 100644
--- a/crates/shirabe/tests/script/event_test.rs
+++ b/crates/shirabe/tests/script/event_test.rs
@@ -9,13 +9,12 @@ use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::package::{RootPackageHandle, RootPackageInterfaceHandle};
 use shirabe::script::{Event, OriginatingEvent};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn create_composer_instance() -> ComposerHandle {
-    let composer =
-        ComposerHandle::from_rc_unchecked(Rc::new(RefCell::new(PartialOrFullComposer::new_full())));
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let composer = ComposerHandle::from_rc_unchecked(std::rc::Rc::new(std::cell::RefCell::new(
+        PartialOrFullComposer::new_full(),
+    )));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
     composer.borrow_mut().set_config(config);
     let package: RootPackageInterfaceHandle = RootPackageHandle::new(
         "foo".to_string(),
@@ -29,7 +28,8 @@ fn create_composer_instance() -> ComposerHandle {
 
 #[test]
 fn test_event_sets_originating_event() {
-    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 composer = create_composer_instance();
 
     let originating_event = BaseEvent::new("originatingEvent".to_string(), vec![], IndexMap::new());
@@ -62,7 +62,8 @@ fn test_event_sets_originating_event() {
 
 #[test]
 fn test_event_calculates_nested_originating_event() {
-    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 composer = create_composer_instance();
 
     let originating_event =
diff --git a/crates/shirabe/tests/util/auth_helper_test.rs b/crates/shirabe/tests/util/auth_helper_test.rs
index 905cbf7f..d719abf3 100644
--- a/crates/shirabe/tests/util/auth_helper_test.rs
+++ b/crates/shirabe/tests/util/auth_helper_test.rs
@@ -8,21 +8,19 @@ use shirabe::io::IOInterface;
 use shirabe::io::io_interface;
 use shirabe::util::{AuthHelper, Bitbucket, StoreAuth};
 use shirabe_php_shim::{PhpMixed, base64_encode, json_encode};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // Mirrors AuthHelperTest::setUp: a DEBUG-verbosity IOMock plus a real Config, both
 // shared with the AuthHelper under test. The IOMockGuard runs assert_complete on drop.
 struct Fixture {
-    io: Rc<RefCell<IOMock>>,
-    config: Rc<RefCell<shirabe::config::Config>>,
+    io: std::rc::Rc<std::cell::RefCell<IOMock>>,
+    config: std::rc::Rc<std::cell::RefCell<shirabe::config::Config>>,
     auth_helper: AuthHelper,
     _guard: crate::io_mock::IOMockGuard,
 }
 
-fn set_up_with_config(config: Rc<RefCell<shirabe::config::Config>>) -> Fixture {
+fn set_up_with_config(config: std::rc::Rc<std::cell::RefCell<shirabe::config::Config>>) -> Fixture {
     let (mock, guard) = get_io_mock(io_interface::DEBUG).unwrap();
-    let io: Rc<RefCell<dyn IOInterface>> = mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = mock.clone();
     let auth_helper = AuthHelper::new(io, config.clone());
     Fixture {
         io: mock,
@@ -38,7 +36,12 @@ fn set_up() -> Fixture {
 
 // Mirrors AuthHelperTest::expectsAuthentication: pre-seed the IO so hasAuthentication
 // and getAuthentication return the given credentials for `origin`.
-fn expects_authentication(io: &Rc<RefCell<IOMock>>, origin: &str, username: &str, password: &str) {
+fn expects_authentication(
+    io: &std::rc::Rc<std::cell::RefCell<IOMock>>,
+    origin: &str,
+    username: &str,
+    password: &str,
+) {
     use shirabe::io::IOInterfaceMutable;
     io.borrow_mut().set_authentication(
         origin.to_string(),
diff --git a/crates/shirabe/tests/util/bitbucket_test.rs b/crates/shirabe/tests/util/bitbucket_test.rs
index db45b3e1..d9010ab1 100644
--- a/crates/shirabe/tests/util/bitbucket_test.rs
+++ b/crates/shirabe/tests/util/bitbucket_test.rs
@@ -14,8 +14,6 @@ use shirabe::util::http_downloader::{
 };
 use shirabe::util::process_executor::MockHandler;
 use shirabe_php_shim::{PhpMixed, time};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const USERNAME: &str = "username";
 const PASSWORD: &str = "password";
@@ -60,9 +58,9 @@ fn placeholder_auth_config_source() -> Box<MockConfigSource> {
 // real Config, the captured `time()`, and the Bitbucket under test. The mock guards
 // run their assert_complete on drop at the end of the test scope.
 struct Fixture {
-    io: Rc<RefCell<IOMock>>,
-    config: Rc<RefCell<Config>>,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    io: std::rc::Rc<std::cell::RefCell<IOMock>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
     time: i64,
     bitbucket: Bitbucket,
     _io_guard: crate::io_mock::IOMockGuard,
@@ -70,7 +68,7 @@ struct Fixture {
 }
 
 fn set_up_with_config_and_http(
-    config: Rc<RefCell<Config>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
     http_expectations: Vec<HttpDownloaderMockExpectation>,
 ) -> Fixture {
     let (io_mock, io_guard) = get_io_mock(io_interface::DEBUG).unwrap();
@@ -80,7 +78,7 @@ fn set_up_with_config_and_http(
         HttpDownloaderMockHandler::default(),
     );
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let time = time();
     let bitbucket = Bitbucket::new(
         io,
@@ -127,7 +125,7 @@ fn access_token_body() -> String {
 // mirroring BitbucketTest::setExpectationsForStoringAccessToken. Verification happens
 // when the mocks are dropped together with the Config.
 fn set_expectations_for_storing_access_token(
-    config: &Rc<RefCell<Config>>,
+    config: &std::rc::Rc<std::cell::RefCell<Config>>,
     time: i64,
     remove_basic_auth: bool,
 ) {
@@ -575,7 +573,7 @@ fn test_authorize_oauth_without_available_git_config_token() {
         },
     );
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let time = time();
     let mut bitbucket =
         Bitbucket::new(io, config, Some(process), Some(http_downloader), Some(time)).unwrap();
@@ -592,7 +590,7 @@ fn test_authorize_oauth_with_available_git_config_token() {
     let (process, _process_guard) =
         get_process_executor_mock(vec![], false, MockHandler::default());
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let time = time();
     let mut bitbucket =
         Bitbucket::new(io, config, Some(process), Some(http_downloader), Some(time)).unwrap();
diff --git a/crates/shirabe/tests/util/config_validator_test.rs b/crates/shirabe/tests/util/config_validator_test.rs
index 6d7aaf8f..a65cfa56 100644
--- a/crates/shirabe/tests/util/config_validator_test.rs
+++ b/crates/shirabe/tests/util/config_validator_test.rs
@@ -4,8 +4,6 @@ use shirabe::io::io_interface::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::package::loader::validating_array_loader::ValidatingArrayLoader;
 use shirabe::util::config_validator::ConfigValidator;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn fixture(name: &str) -> String {
     format!(
@@ -16,7 +14,8 @@ fn fixture(name: &str) -> String {
 }
 
 fn validate(file: &str) -> Vec<String> {
-    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 config_validator = ConfigValidator::new(io);
     let (_, _, warnings) = config_validator.validate(
         file,
diff --git a/crates/shirabe/tests/util/forgejo_test.rs b/crates/shirabe/tests/util/forgejo_test.rs
index 106cdabc..3829ebf2 100644
--- a/crates/shirabe/tests/util/forgejo_test.rs
+++ b/crates/shirabe/tests/util/forgejo_test.rs
@@ -9,8 +9,6 @@ use shirabe::io::io_interface;
 use shirabe::util::Forgejo;
 use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const USERNAME: &str = "username";
 const ACCESS_TOKEN: &str = "access-token";
@@ -63,11 +61,11 @@ fn get_conf_json_mock(origin: &str) -> Box<MockConfigSource> {
 }
 
 fn build_forgejo(
-    io_mock: &Rc<RefCell<IOMock>>,
-    config: Rc<RefCell<Config>>,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    io_mock: &std::rc::Rc<std::cell::RefCell<IOMock>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
 ) -> Forgejo {
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     Forgejo::new(io, config, http_downloader)
 }
 
diff --git a/crates/shirabe/tests/util/git_test.rs b/crates/shirabe/tests/util/git_test.rs
index 991dc91c..907ec38a 100644
--- a/crates/shirabe/tests/util/git_test.rs
+++ b/crates/shirabe/tests/util/git_test.rs
@@ -12,8 +12,6 @@ use shirabe::util::git::Git;
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe::util::process_executor::{MockExpectation, MockHandler, ProcessExecutor};
 use shirabe_php_shim::{PhpMixed, RuntimeException};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // No-op ConfigSourceInterface, equivalent to PHPUnit's
 // `getMockBuilder(Config::class)` auto-stubbing getConfigSource/getAuthConfigSource:
@@ -73,10 +71,15 @@ impl ConfigSourceInterface for NullConfigSource {
 // flattens each callable to a `Vec<String>` and hands it to `execute_args`, which always
 // builds a `PhpMixed::List`. So the single-token string command becomes a one-element list,
 // and the corresponding process expectation is a one-element list as well.
-fn build_git(io: IOStub, config: Config, process: Rc<RefCell<ProcessExecutor>>) -> Git {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(io));
-    let config = Rc::new(RefCell::new(config));
-    let fs = Rc::new(RefCell::new(Filesystem::new(None)));
+fn build_git(
+    io: IOStub,
+    config: Config,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+) -> Git {
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(io));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(config));
+    let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None)));
     Git::new(io, config, process, fs)
 }
 
diff --git a/crates/shirabe/tests/util/github_test.rs b/crates/shirabe/tests/util/github_test.rs
index b9abeb26..377a44fa 100644
--- a/crates/shirabe/tests/util/github_test.rs
+++ b/crates/shirabe/tests/util/github_test.rs
@@ -9,8 +9,6 @@ use shirabe::io::io_interface;
 use shirabe::util::GitHub;
 use shirabe::util::http_downloader::{HttpDownloader, HttpDownloaderMockHandler};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const PASSWORD: &str = "password";
 const MESSAGE: &str = "mymessage";
@@ -62,18 +60,18 @@ fn get_conf_json_mock(origin: &str) -> Box<MockConfigSource> {
 }
 
 fn build_github(
-    io_mock: &Rc<RefCell<IOMock>>,
-    config: Rc<RefCell<Config>>,
-    http_downloader: Rc<RefCell<HttpDownloader>>,
+    io_mock: &std::rc::Rc<std::cell::RefCell<IOMock>>,
+    config: std::rc::Rc<std::cell::RefCell<Config>>,
+    http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
 ) -> GitHub {
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     GitHub::new(io, config, None, Some(http_downloader)).unwrap()
 }
 
 // The PHP Config mock returns null for `get('github-expose-hostname')`, which is
 // falsy and skips the `hostname` process call. A real Config defaults that key to
 // true, so the stub seeds false to reproduce the mock's behaviour.
-fn build_config() -> Rc<RefCell<Config>> {
+fn build_config() -> std::rc::Rc<std::cell::RefCell<Config>> {
     ConfigStubBuilder::new()
         .with("github-expose-hostname", PhpMixed::Bool(false))
         .build_shared()
diff --git a/crates/shirabe/tests/util/gitlab_test.rs b/crates/shirabe/tests/util/gitlab_test.rs
index 46c03585..70aa4656 100644
--- a/crates/shirabe/tests/util/gitlab_test.rs
+++ b/crates/shirabe/tests/util/gitlab_test.rs
@@ -9,8 +9,6 @@ use shirabe::io::io_interface;
 use shirabe::util::GitLab;
 use shirabe::util::http_downloader::HttpDownloaderMockHandler;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const USERNAME: &str = "username";
 const PASSWORD: &str = "password";
@@ -50,7 +48,10 @@ fn get_auth_json_mock() -> Box<MockAuthJson> {
     Box::new(mock)
 }
 
-fn set_up(io_mock: &Rc<RefCell<IOMock>>, config: &Rc<RefCell<Config>>) {
+fn set_up(
+    io_mock: &std::rc::Rc<std::cell::RefCell<IOMock>>,
+    config: &std::rc::Rc<std::cell::RefCell<Config>>,
+) {
     config
         .borrow_mut()
         .set_auth_config_source(get_auth_json_mock());
@@ -91,7 +92,7 @@ fn test_username_password_authentication_flow() {
     let config = ConfigStubBuilder::new().build_shared();
     set_up(&io_mock, &config);
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let mut gitlab = GitLab::new(io, config, None, Some(http_downloader)).unwrap();
 
     assert!(
@@ -138,7 +139,7 @@ fn test_username_password_failure() {
     let config = ConfigStubBuilder::new().build_shared();
     set_up(&io_mock, &config);
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
     let mut gitlab = GitLab::new(io, config, None, Some(http_downloader)).unwrap();
 
     let err = gitlab
diff --git a/crates/shirabe/tests/util/http_downloader_test.rs b/crates/shirabe/tests/util/http_downloader_test.rs
index b1841840..2be5eb96 100644
--- a/crates/shirabe/tests/util/http_downloader_test.rs
+++ b/crates/shirabe/tests/util/http_downloader_test.rs
@@ -12,8 +12,6 @@ use shirabe::util::Platform;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe_external_packages::symfony::console::output::output_interface::VERBOSITY_NORMAL;
 use shirabe_php_shim::{PHP_EOL, PhpMixed};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // PHP performs a live HTTP get to assert the URL's user:pass is captured via
 // setAuthentication. The credential capture happens in `add_job`, before any
@@ -37,12 +35,12 @@ fn test_capture_authentication_params_from_url() {
         .unwrap();
 
     // The PHP Config mock returns [] for github-domains/gitlab-domains.
-    let config: Rc<RefCell<Config>> = ConfigStubBuilder::new()
+    let config: std::rc::Rc<std::cell::RefCell<Config>> = ConfigStubBuilder::new()
         .with("github-domains", PhpMixed::Array(IndexMap::new()))
         .with("gitlab-domains", PhpMixed::Array(IndexMap::new()))
         .build_shared();
 
-    let io: Rc<RefCell<dyn IOInterface>> = io_mock.clone();
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io_mock.clone();
 
     Platform::put_env("COMPOSER_DISABLE_NETWORK", "1");
     let mut fs = HttpDownloader::new(io, config, IndexMap::new(), false);
@@ -59,10 +57,10 @@ fn test_capture_authentication_params_from_url() {
 
 #[test]
 fn test_output_warnings() {
-    let io: Rc<RefCell<BufferIO>> = Rc::new(RefCell::new(
+    let io: std::rc::Rc<std::cell::RefCell<BufferIO>> = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), VERBOSITY_NORMAL, None).unwrap(),
     ));
-    let io_dyn: Rc<RefCell<dyn IOInterface>> = io.clone();
+    let io_dyn: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
 
     HttpDownloader::output_warnings(io_dyn.clone(), "$URL", &IndexMap::new()).unwrap();
     assert_eq!("", io.borrow().get_output());
diff --git a/crates/shirabe/tests/util/perforce_test.rs b/crates/shirabe/tests/util/perforce_test.rs
index b6f8f116..b63a5e0e 100644
--- a/crates/shirabe/tests/util/perforce_test.rs
+++ b/crates/shirabe/tests/util/perforce_test.rs
@@ -9,8 +9,6 @@ use shirabe::util::Perforce;
 use shirabe::util::filesystem::Filesystem;
 use shirabe::util::process_executor::{MockHandler, ProcessExecutor};
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 const TEST_DEPOT: &str = "depot";
 const TEST_BRANCH: &str = "branch";
@@ -41,8 +39,9 @@ fn get_test_repo_config() -> IndexMap<String, PhpMixed> {
 }
 
 fn create_new_perforce_with_windows_flag(flag: bool) -> Perforce {
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
     Perforce::new(
         get_test_repo_config(),
         TEST_PORT.to_string(),
@@ -57,8 +56,8 @@ fn create_new_perforce_with_windows_flag(flag: bool) -> Perforce {
 // ProcessExecutor and IO it configured, matching the PHP `setUp` wiring.
 fn create_perforce(
     flag: bool,
-    process: Rc<RefCell<ProcessExecutor>>,
-    io: Rc<RefCell<dyn IOInterface>>,
+    process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
 ) -> Perforce {
     Perforce::new(
         get_test_repo_config(),
@@ -201,7 +200,8 @@ fn test_query_p4_user_with_user_set_in_p4_variables_with_windows_os() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_user(None);
 
@@ -224,7 +224,8 @@ fn test_query_p4_user_with_user_set_in_p4_variables_not_windows_os() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(false, process, io);
     perforce.set_user(None);
 
@@ -240,9 +241,10 @@ fn test_query_p4_user_queries_for_user() {
     // Non-strict empty process mock: the p4-variable lookup returns empty so the
     // code falls through to io->ask().
     let (process, _guard) = get_process_executor_mock(vec![], false, MockHandler::default());
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
+        ));
     let mut perforce = create_perforce(true, process, io);
     perforce.set_user(None);
 
@@ -261,9 +263,10 @@ fn test_query_p4_user_stores_response_to_query_for_user_with_windows() {
         true,
         MockHandler::default(),
     );
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
+        ));
     let mut perforce = create_perforce(true, process, io);
     perforce.set_user(None);
 
@@ -284,9 +287,10 @@ fn test_query_p4_user_stores_response_to_query_for_user_without_windows() {
         true,
         MockHandler::default(),
     );
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new().with_ask(PhpMixed::String("TEST_QUERY_USER".to_string())),
+        ));
     let mut perforce = create_perforce(false, process, io);
     perforce.set_user(None);
 
@@ -304,9 +308,10 @@ fn test_query_p4_user_escapes_injection_on_windows() {
         true,
         MockHandler::default(),
     );
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask(PhpMixed::String("foo && calc.exe".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new().with_ask(PhpMixed::String("foo && calc.exe".to_string())),
+        ));
     let mut perforce = create_perforce(true, process, io);
     perforce.set_user(None);
 
@@ -324,9 +329,9 @@ fn test_query_p4_user_escapes_injection_on_unix() {
         true,
         MockHandler::default(),
     );
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask(PhpMixed::String("foo; id".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_ask(PhpMixed::String("foo; id".to_string()))),
+    );
     let mut perforce = create_perforce(false, process, io);
     perforce.set_user(None);
 
@@ -343,8 +348,9 @@ fn test_query_p4_password_with_password_already_set() {
         "p4password".to_string(),
         PhpMixed::String("TEST_PASSWORD".to_string()),
     );
-    let process = Rc::new(RefCell::new(ProcessExecutor::new(None)));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
+    let process = std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
     let mut perforce = Perforce::new(
         repo_config,
         "port".to_string(),
@@ -373,7 +379,8 @@ fn test_query_p4_password_with_password_set_in_p4_variables_with_windows_os() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let password = perforce.query_p4_password();
@@ -392,7 +399,8 @@ fn test_query_p4_password_with_password_set_in_p4_variables_not_windows_os() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(false, process, io);
 
     let password = perforce.query_p4_password();
@@ -404,9 +412,10 @@ fn test_query_p4_password_queries_for_password() {
     // Non-strict empty process mock: the p4-variable lookup returns empty so the
     // code falls through to io->askAndHideAnswer().
     let (process, _guard) = get_process_executor_mock(vec![], false, MockHandler::default());
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new().with_ask_and_hide_answer(Some("TEST_QUERY_PASSWORD".to_string())),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new().with_ask_and_hide_answer(Some("TEST_QUERY_PASSWORD".to_string())),
+        ));
     let mut perforce = create_perforce(true, process, io);
 
     let password = perforce.query_p4_password();
@@ -420,7 +429,8 @@ fn test_is_logged_in() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     perforce.is_logged_in().unwrap();
@@ -467,7 +477,8 @@ fn test_get_branches_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_stream("//depot/branch");
 
@@ -487,7 +498,8 @@ fn test_get_branches_without_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let branches = perforce.get_branches();
@@ -519,7 +531,8 @@ fn test_get_tags_without_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let tags = perforce.get_tags();
@@ -552,7 +565,8 @@ fn test_get_tags_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_stream("//depot/branch");
 
@@ -582,7 +596,8 @@ fn test_check_stream_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let result = perforce.check_stream();
@@ -612,7 +627,8 @@ fn test_get_composer_information_without_label_without_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let result = perforce.get_composer_information("//depot").unwrap();
@@ -657,7 +673,8 @@ fn test_get_composer_information_with_label_without_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     let result = perforce.get_composer_information("//depot@0.0.1").unwrap();
@@ -686,7 +703,8 @@ fn test_get_composer_information_without_label_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_stream("//depot/branch");
 
@@ -732,7 +750,8 @@ fn test_get_composer_information_with_label_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_stream("//depot/branch");
 
@@ -761,7 +780,8 @@ fn test_sync_code_base_without_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
 
     perforce.sync_code_base(Some("label")).unwrap();
@@ -786,7 +806,8 @@ fn test_sync_code_base_with_stream() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process, io);
     perforce.set_stream("//depot/branch");
 
@@ -849,10 +870,11 @@ fn test_cleanup_client_spec_should_delete_client() {
         true,
         MockHandler::default(),
     );
-    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 mut perforce = create_perforce(true, process.clone(), io);
 
-    let fs = Rc::new(RefCell::new(Filesystem::new(Some(process))));
+    let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(process))));
     perforce.set_filesystem(fs);
 
     perforce.cleanup_client_spec();
diff --git a/crates/shirabe/tests/util/process_executor_test.rs b/crates/shirabe/tests/util/process_executor_test.rs
index 78c5f9f7..e093a801 100644
--- a/crates/shirabe/tests/util/process_executor_test.rs
+++ b/crates/shirabe/tests/util/process_executor_test.rs
@@ -16,8 +16,6 @@ use shirabe_external_packages::symfony::console::output::output_interface::{
     OutputInterface, VERBOSITY_DEBUG, VERBOSITY_NORMAL,
 };
 use shirabe_php_shim::{PHP_EOL, trim};
-use std::cell::RefCell;
-use std::rc::Rc;
 
 #[test]
 fn test_execute_captures_output() {
@@ -90,11 +88,12 @@ fn hide_password_provider() -> Vec<(&'static str, &'static str)> {
 #[test]
 fn test_hide_passwords() {
     for (command, expected_command_output) in hide_password_provider() {
-        let buffer = Rc::new(RefCell::new(
+        let buffer = std::rc::Rc::new(std::cell::RefCell::new(
             BufferIO::new(String::new(), VERBOSITY_DEBUG, None).unwrap(),
         ));
-        let mut process =
-            ProcessExecutor::new(Some(buffer.clone() as Rc<RefCell<dyn IOInterface>>));
+        let mut process = ProcessExecutor::new(Some(
+            buffer.clone() as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>
+        ));
         let mut output = String::new();
         process.execute(command, &mut output, None).unwrap();
         assert_eq!(
@@ -106,10 +105,12 @@ fn test_hide_passwords() {
 
 #[test]
 fn test_doesnt_hide_ports() {
-    let buffer = Rc::new(RefCell::new(
+    let buffer = std::rc::Rc::new(std::cell::RefCell::new(
         BufferIO::new(String::new(), VERBOSITY_DEBUG, None).unwrap(),
     ));
-    let mut process = ProcessExecutor::new(Some(buffer.clone() as Rc<RefCell<dyn IOInterface>>));
+    let mut process = ProcessExecutor::new(Some(
+        buffer.clone() as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>
+    ));
     let mut output = String::new();
     process
         .execute("echo https://localhost:1234/", &mut output, None)
@@ -128,21 +129,22 @@ fn test_split_lines() {
 
 #[test]
 fn test_console_io_does_not_format_symfony_console_style() {
-    let output = Rc::new(RefCell::new(BufferedOutput::new(
+    let output = std::rc::Rc::new(std::cell::RefCell::new(BufferedOutput::new(
         Some(VERBOSITY_NORMAL),
         true,
         None,
     )));
-    let input: Rc<RefCell<dyn InputInterface>> =
-        Rc::new(RefCell::new(ArrayInput::new(vec![], None).unwrap()));
+    let input: std::rc::Rc<std::cell::RefCell<dyn InputInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(ArrayInput::new(vec![], None).unwrap()),
+    );
     let console_io = ConsoleIO::new(
         input,
-        output.clone() as Rc<RefCell<dyn OutputInterface>>,
+        output.clone() as std::rc::Rc<std::cell::RefCell<dyn OutputInterface>>,
         QuestionHelper::default(),
     );
-    let mut process = ProcessExecutor::new(Some(
-        Rc::new(RefCell::new(console_io)) as Rc<RefCell<dyn IOInterface>>
-    ));
+    let mut process =
+        ProcessExecutor::new(Some(std::rc::Rc::new(std::cell::RefCell::new(console_io))
+            as std::rc::Rc<std::cell::RefCell<dyn IOInterface>>));
 
     process
         .execute(
diff --git a/crates/shirabe/tests/util/remote_filesystem_test.rs b/crates/shirabe/tests/util/remote_filesystem_test.rs
index c699b94a..9c1fe0bd 100644
--- a/crates/shirabe/tests/util/remote_filesystem_test.rs
+++ b/crates/shirabe/tests/util/remote_filesystem_test.rs
@@ -9,13 +9,11 @@ use shirabe_php_shim::{
     PHP_URL_HOST, PhpMixed, STREAM_NOTIFY_FILE_SIZE_IS, STREAM_NOTIFY_PROGRESS, file_get_contents,
     parse_url, strpos, unlink,
 };
-use std::cell::RefCell;
-use std::rc::Rc;
 
 // Mirrors RemoteFilesystemTest::getConfigMock: get('github-domains') and
 // get('gitlab-domains') return [], everything else returns null. add_authentication_options
 // reads gitlab-domains, so seed it as an empty list.
-fn config_mock() -> Rc<RefCell<shirabe::config::Config>> {
+fn config_mock() -> std::rc::Rc<std::cell::RefCell<shirabe::config::Config>> {
     ConfigStubBuilder::new()
         .with("github-domains", PhpMixed::List(vec![]))
         .with("gitlab-domains", PhpMixed::List(vec![]))
@@ -25,7 +23,7 @@ fn config_mock() -> Rc<RefCell<shirabe::config::Config>> {
 // Mirrors RemoteFilesystemTest::callGetOptionsForUrl: build a RemoteFilesystem, set the
 // private file_url, then invoke the private get_options_for_url with the given args.
 fn call_get_options_for_url(
-    io: Rc<RefCell<dyn IOInterface>>,
+    io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
     origin_url: &str,
     additional_options: IndexMap<String, PhpMixed>,
     options: IndexMap<String, PhpMixed>,
@@ -50,8 +48,9 @@ fn http_header_list(res: &IndexMap<String, PhpMixed>) -> Option<Vec<String>> {
 
 #[test]
 fn test_get_options_for_url() {
-    let io: Rc<RefCell<dyn IOInterface>> =
-        Rc::new(RefCell::new(IOStub::new().with_has_authentication(false)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = std::rc::Rc::new(
+        std::cell::RefCell::new(IOStub::new().with_has_authentication(false)),
+    );
 
     let res = call_get_options_for_url(
         io,
@@ -72,11 +71,12 @@ fn test_get_options_for_url_with_authorization() {
     let mut auth: IndexMap<String, Option<String>> = IndexMap::new();
     auth.insert("username".to_string(), Some("login".to_string()));
     auth.insert("password".to_string(), Some("password".to_string()));
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new()
-            .with_has_authentication(true)
-            .with_get_authentication(auth),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new()
+                .with_has_authentication(true)
+                .with_get_authentication(auth),
+        ));
 
     let options = call_get_options_for_url(
         io,
@@ -100,11 +100,12 @@ fn test_get_options_for_url_with_stream_options() {
     let mut auth: IndexMap<String, Option<String>> = IndexMap::new();
     auth.insert("username".to_string(), None);
     auth.insert("password".to_string(), None);
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new()
-            .with_has_authentication(true)
-            .with_get_authentication(auth),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new()
+                .with_has_authentication(true)
+                .with_get_authentication(auth),
+        ));
 
     let mut ssl: IndexMap<String, PhpMixed> = IndexMap::new();
     ssl.insert("allow_self_signed".to_string(), PhpMixed::Bool(true));
@@ -136,11 +137,12 @@ fn test_get_options_for_url_with_call_options_keeps_header() {
     let mut auth: IndexMap<String, Option<String>> = IndexMap::new();
     auth.insert("username".to_string(), None);
     auth.insert("password".to_string(), None);
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(
-        IOStub::new()
-            .with_has_authentication(true)
-            .with_get_authentication(auth),
-    ));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(
+            IOStub::new()
+                .with_has_authentication(true)
+                .with_get_authentication(auth),
+        ));
 
     let mut http: IndexMap<String, PhpMixed> = IndexMap::new();
     http.insert(
@@ -172,7 +174,8 @@ fn test_get_options_for_url_with_call_options_keeps_header() {
 
 #[test]
 fn test_callback_get_file_size() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
     let mut fs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
     fs.__callback_get(STREAM_NOTIFY_FILE_SIZE_IS, 0, Some(String::new()), 0, 0, 20)
         .unwrap();
@@ -181,7 +184,8 @@ fn test_callback_get_file_size() {
 
 #[test]
 fn test_callback_get_notify_progress() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
     let mut fs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
     fs.__set_bytes_max(20);
     fs.__set_progress(true);
@@ -193,7 +197,8 @@ fn test_callback_get_notify_progress() {
 
 #[test]
 fn test_callback_get_passes_through404() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
     let mut fs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
 
     fs.__callback_get(
@@ -226,7 +231,8 @@ fn this_file() -> String {
 
 #[test]
 fn test_get_contents() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
     let mut fs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
 
     let res = fs
@@ -242,7 +248,8 @@ fn test_get_contents() {
 
 #[test]
 fn test_copy() {
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
     let mut fs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
 
     let file = tempfile::NamedTempFile::new().unwrap();
@@ -293,7 +300,8 @@ fn provide_bitbucket_public_download_urls() -> Vec<(&'static str, &'static str)>
 #[ignore = "performs a real network download; get_remote_contents has no stream layer (TODO(phase-c)) and returns None, so getContents raises a TransportException"]
 fn test_bit_bucket_public_download() {
     for (url, contents) in provide_bitbucket_public_download_urls() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(IOStub::new()));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(IOStub::new()));
         let mut rfs = RemoteFilesystem::new(io, config_mock(), IndexMap::new(), false, None);
         let hostname = parse_url(url, PHP_URL_HOST);
         let hostname = hostname.as_string().unwrap_or("");
diff --git a/crates/shirabe/tests/util/svn_test.rs b/crates/shirabe/tests/util/svn_test.rs
index f7006345..650fbd89 100644
--- a/crates/shirabe/tests/util/svn_test.rs
+++ b/crates/shirabe/tests/util/svn_test.rs
@@ -6,8 +6,6 @@ use shirabe::io::IOInterface;
 use shirabe::io::null_io::NullIO;
 use shirabe::util::svn::Svn;
 use shirabe_php_shim::PhpMixed;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 fn map(pairs: Vec<(&str, PhpMixed)>) -> IndexMap<String, PhpMixed> {
     pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect()
@@ -43,8 +41,9 @@ fn url_provider() -> Vec<(&'static str, Vec<&'static str>)> {
 #[test]
 fn test_credentials() {
     for (url, expect) in url_provider() {
-        let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-        let config = Rc::new(RefCell::new(Config::new(true, None)));
+        let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+            std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+        let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
         let mut svn = Svn::new(url.to_string(), io, config, None);
 
         let expect: Vec<String> = expect.iter().map(|s| s.to_string()).collect();
@@ -56,8 +55,9 @@ fn test_credentials() {
 fn test_interactive_string() {
     let url = "http://svn.example.org";
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let config = Rc::new(RefCell::new(Config::new(true, None)));
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let config = std::rc::Rc::new(std::cell::RefCell::new(Config::new(true, None)));
     let mut svn = Svn::new(url.to_string(), io, config, None);
 
     assert_eq!(
@@ -79,8 +79,14 @@ fn test_credentials_from_config() {
     let mut config = Config::new(true, None);
     config.merge(&http_basic_config("svn.apache.org", "foo", "bar"), "test");
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let mut svn = Svn::new(url.to_string(), io, Rc::new(RefCell::new(config)), None);
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let mut svn = Svn::new(
+        url.to_string(),
+        io,
+        std::rc::Rc::new(std::cell::RefCell::new(config)),
+        None,
+    );
 
     assert_eq!(
         vec![
@@ -100,8 +106,14 @@ fn test_credentials_from_config_with_cache_credentials_true() {
     let mut config = Config::new(true, None);
     config.merge(&http_basic_config("svn.apache.org", "foo", "bar"), "test");
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let mut svn = Svn::new(url.to_string(), io, Rc::new(RefCell::new(config)), None);
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let mut svn = Svn::new(
+        url.to_string(),
+        io,
+        std::rc::Rc::new(std::cell::RefCell::new(config)),
+        None,
+    );
     svn.set_cache_credentials(true);
 
     assert_eq!(
@@ -122,8 +134,14 @@ fn test_credentials_from_config_with_cache_credentials_false() {
     let mut config = Config::new(true, None);
     config.merge(&http_basic_config("svn.apache.org", "foo", "bar"), "test");
 
-    let io: Rc<RefCell<dyn IOInterface>> = Rc::new(RefCell::new(NullIO::new()));
-    let mut svn = Svn::new(url.to_string(), io, Rc::new(RefCell::new(config)), None);
+    let io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(NullIO::new()));
+    let mut svn = Svn::new(
+        url.to_string(),
+        io,
+        std::rc::Rc::new(std::cell::RefCell::new(config)),
+        None,
+    );
     svn.set_cache_credentials(false);
 
     assert_eq!(