fix(autoload-generator): survive listeners that re-enter dump()

AutoloadGenerator::dump dispatches PRE_AUTOLOAD_DUMP / POST_AUTOLOAD_DUMP, and
EventDispatcher::make_autoloader answers those by walking back into the Composer
graph -- the local repository, the installation manager, and the generator
itself. Installer::run held mutable borrows of all three across the dump call,
so any plugin subscribing to either event panicked with "RefCell already
borrowed" before its listener ran.

dump() and build_package_map() now take the local repository, the installation
manager and the locker as shared handles instead of &mut dyn, and the borrow is
taken where it is used.

The generator itself is re-entered, not just borrowed twice: PHP listeners reach
it through Composer::getAutoloadGenerator() and call setDevMode() while dump()
is running, and make_autoloader asks the same object for a package map. That is
not expressible behind &mut self, so the mutable state moves into Cell/RefCell
fields and the whole AutoloadGeneratorInterface takes &self.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

3 files changed, 75 insertions, 49 deletions

diff --git a/crates/shirabe/tests/autoload/autoload_generator_test.rs b/crates/shirabe/tests/autoload/autoload_generator_test.rs
index 92baadcd..97fabf16 100644
--- a/crates/shirabe/tests/autoload/autoload_generator_test.rs
+++ b/crates/shirabe/tests/autoload/autoload_generator_test.rs
@@ -14,9 +14,7 @@ use shirabe::package::handle::{
     AliasPackageHandle, CompletePackageHandle, PackageHandle, RootPackageHandle,
 };
 use shirabe::package::{Link, PackageInterfaceHandle, RootPackageInterfaceHandle};
-use shirabe::repository::{
-    InstalledArrayRepository, InstalledRepositoryInterfaceHandle, WritableRepositoryInterface,
-};
+use shirabe::repository::{InstalledArrayRepository, InstalledRepositoryInterfaceHandle};
 use shirabe::script::ScriptEvents;
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
@@ -127,10 +125,10 @@ struct SetUp {
     prev_cwd: std::path::PathBuf,
     working_dir: String,
     vendor_dir: String,
-    repository: InstalledArrayRepository,
+    repository: shirabe::repository::RepositoryInterfaceHandle,
     /// ref: `$this->configValueMap['use-include-path']`, which testUseGlobalIncludePath mutates.
     use_include_path: bool,
-    im: InstallationManager,
+    im: std::rc::Rc<std::cell::RefCell<dyn shirabe::installer::InstallationManagerInterface>>,
     io: std::rc::Rc<std::cell::RefCell<BufferIO>>,
     generator: AutoloadGenerator,
     event_dispatcher: std::rc::Rc<std::cell::RefCell<EventDispatcher>>,
@@ -181,9 +179,15 @@ fn set_up() -> SetUp {
     ));
 
     let dispatcher_io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>> = io.clone();
-    let im = make_installation_manager(&vendor_dir, dispatcher_io.clone());
+    let im: std::rc::Rc<std::cell::RefCell<dyn shirabe::installer::InstallationManagerInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(make_installation_manager(
+            &vendor_dir,
+            dispatcher_io.clone(),
+        )));
 
-    let repository = InstalledArrayRepository::new().unwrap();
+    let repository = shirabe::repository::RepositoryInterfaceHandle::new(
+        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.
@@ -237,7 +241,12 @@ impl SetUp {
 
     fn set_canonical_packages(&mut self, packages: Vec<PackageInterfaceHandle>) {
         for p in packages {
-            self.repository.add_package(p).unwrap();
+            self.repository
+                .borrow_mut()
+                .as_writable_repository_interface_mut()
+                .expect("the test repository is writable")
+                .add_package(p)
+                .unwrap();
         }
     }
 }
@@ -357,9 +366,9 @@ fn dump(
     } = s;
     generator.dump(
         &config,
-        repository,
+        repository.clone(),
         package,
-        im,
+        im.clone(),
         "composer",
         scan_psr_packages,
         Some(suffix.to_string()),
@@ -497,9 +506,10 @@ fn test_vendor_dir_same_as_working_dir() {
     let mut s = set_up();
     s.vendor_dir = s.working_dir.clone();
     // Re-register the install-path stub so getInstallPath uses the new vendor dir.
-    s.im.add_installer(std::rc::Rc::new(InstallPathStubInstaller {
-        vendor_dir: s.vendor_dir.clone(),
-    }));
+    s.im.borrow()
+        .add_installer(std::rc::Rc::new(InstallPathStubInstaller {
+            vendor_dir: s.vendor_dir.clone(),
+        }));
 
     let package = new_root_pkg("root/a");
     package.set_autoload(autoload(vec![
@@ -557,9 +567,10 @@ fn test_root_package_autoloading_alternative_vendor_dir() {
     ]));
 
     s.vendor_dir = format!("{}/subdir", s.vendor_dir);
-    s.im.add_installer(std::rc::Rc::new(InstallPathStubInstaller {
-        vendor_dir: s.vendor_dir.clone(),
-    }));
+    s.im.borrow()
+        .add_installer(std::rc::Rc::new(InstallPathStubInstaller {
+            vendor_dir: s.vendor_dir.clone(),
+        }));
 
     s.ensure_dir(&format!("{}/composer", s.vendor_dir));
     s.ensure_dir(&format!("{}/src", s.working_dir));
@@ -1851,7 +1862,9 @@ fn test_files_autoload_generation_remove_extra_entities_from_autoload_files() {
         &format!("{}/include_paths.php", composer_out),
     );
 
-    s.repository = InstalledArrayRepository::new().unwrap();
+    s.repository = shirabe::repository::RepositoryInterfaceHandle::new(
+        InstalledArrayRepository::new().unwrap(),
+    );
     s.set_canonical_packages(not_autoload_packages());
     dump(
         &mut s,
@@ -1883,7 +1896,9 @@ fn test_files_autoload_generation_remove_extra_entities_from_autoload_files() {
         &format!("{}/include_paths.php", composer_out),
     );
 
-    s.repository = InstalledArrayRepository::new().unwrap();
+    s.repository = shirabe::repository::RepositoryInterfaceHandle::new(
+        InstalledArrayRepository::new().unwrap(),
+    );
     s.set_canonical_packages(not_autoload_packages());
     dump(&mut s, not_autoload_package.into(), false, "FilesAutoload").unwrap();
     assert_file_content_equals(
@@ -2015,7 +2030,11 @@ fn test_vendor_dir_excluded_from_working_dir() {
 
     s.set_canonical_packages(vec![vendor_package.into()]);
 
-    let mut im = make_installation_manager(&vendor_dir, s.io.clone());
+    let im: std::rc::Rc<std::cell::RefCell<dyn shirabe::installer::InstallationManagerInterface>> =
+        std::rc::Rc::new(std::cell::RefCell::new(make_installation_manager(
+            &vendor_dir,
+            s.io.clone(),
+        )));
 
     s.ensure_dir(&format!("{}/src/Foo", working_dir));
     s.ensure_dir(&format!("{}/classmap", working_dir));
@@ -2049,9 +2068,9 @@ fn test_vendor_dir_excluded_from_working_dir() {
     s.generator
         .dump(
             &config,
-            &mut s.repository,
+            s.repository.clone(),
             package.into(),
-            &mut im,
+            im,
             "composer",
             true,
             Some("_13".to_string()),
@@ -2241,7 +2260,11 @@ fn test_autoload_rules_in_package_that_does_not_exist_on_disk() {
     )]));
     let map = s
         .generator
-        .build_package_map(&mut s.im, package.clone().into(), vec![dep.clone().into()])
+        .build_package_map(
+            s.im.clone(),
+            package.clone().into(),
+            vec![dep.clone().into()],
+        )
         .unwrap();
     let parsed = s
         .generator
diff --git a/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs b/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
index d97c14f0..af8a33db 100644
--- a/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
+++ b/crates/shirabe/tests/event_dispatcher/event_dispatcher_test.rs
@@ -19,8 +19,7 @@ use shirabe::package::{
     LockerInterface, PackageInterfaceHandle, RootPackageHandle, RootPackageInterfaceHandle,
 };
 use shirabe::repository::{
-    InstalledArrayRepository, InstalledRepositoryInterface, RepositoryInterfaceHandle,
-    RepositoryManagerInterface,
+    InstalledArrayRepository, RepositoryInterfaceHandle, RepositoryManagerInterface,
 };
 use shirabe::script::Event as ScriptEvent;
 use shirabe::script::ScriptEvents;
@@ -405,30 +404,30 @@ mockall::mock! {
     #[derive(Debug)]
     pub AutoloadGenerator {}
     impl AutoloadGeneratorInterface for AutoloadGenerator {
-        fn set_dev_mode(&mut self, dev_mode: bool);
-        fn set_class_map_authoritative(&mut self, class_map_authoritative: bool);
-        fn set_apcu(&mut self, apcu: bool, apcu_prefix: Option<String>);
-        fn set_run_scripts(&mut self, run_scripts: bool);
-        fn set_dry_run(&mut self, dry_run: bool);
+        fn set_dev_mode(&self, dev_mode: bool);
+        fn set_class_map_authoritative(&self, class_map_authoritative: bool);
+        fn set_apcu(&self, apcu: bool, apcu_prefix: Option<String>);
+        fn set_run_scripts(&self, run_scripts: bool);
+        fn set_dry_run(&self, dry_run: bool);
         fn set_platform_requirement_filter(
-            &mut self,
+            &self,
             platform_requirement_filter: std::rc::Rc<dyn PlatformRequirementFilterInterface>,
         );
-        fn dump<'a>(
-            &mut self,
+        fn dump(
+            &self,
             config: &Config,
-            local_repo: &mut dyn InstalledRepositoryInterface,
+            local_repo: shirabe::repository::RepositoryInterfaceHandle,
             root_package: RootPackageInterfaceHandle,
-            installation_manager: &mut dyn InstallationManagerInterface,
+            installation_manager: std::rc::Rc<std::cell::RefCell<dyn InstallationManagerInterface>>,
             target_dir: &str,
             scan_psr_packages: bool,
             suffix: Option<String>,
-            locker: Option<&'a mut dyn LockerInterface>,
+            locker: Option<std::rc::Rc<std::cell::RefCell<dyn LockerInterface>>>,
             strict_ambiguous: bool,
         ) -> anyhow::Result<ClassMap>;
         fn build_package_map(
             &self,
-            installation_manager: &mut dyn InstallationManagerInterface,
+            installation_manager: std::rc::Rc<std::cell::RefCell<dyn InstallationManagerInterface>>,
             root_package: RootPackageInterfaceHandle,
             packages: Vec<PackageInterfaceHandle>,
         ) -> anyhow::Result<Vec<(PackageInterfaceHandle, Option<String>)>>;
diff --git a/crates/shirabe/tests/installer_test.rs b/crates/shirabe/tests/installer_test.rs
index f5e84558..90dca3ca 100644
--- a/crates/shirabe/tests/installer_test.rs
+++ b/crates/shirabe/tests/installer_test.rs
@@ -34,8 +34,8 @@ use shirabe::package::{
     RootPackageInterfaceHandle,
 };
 use shirabe::repository::{
-    ArrayRepository, InstalledArrayRepository, InstalledRepositoryInterface,
-    RepositoryInterfaceHandle, RepositoryManager, RepositoryManagerInterface,
+    ArrayRepository, InstalledArrayRepository, RepositoryInterfaceHandle, RepositoryManager,
+    RepositoryManagerInterface,
 };
 use shirabe::util::http_downloader::HttpDownloader;
 use shirabe::util::r#loop::Loop;
@@ -206,34 +206,38 @@ impl EventDispatcherInterface for StubEventDispatcher {
 struct StubAutoloadGenerator;
 
 impl AutoloadGeneratorInterface for StubAutoloadGenerator {
-    fn set_dev_mode(&mut self, _dev_mode: bool) {}
-    fn set_class_map_authoritative(&mut self, _class_map_authoritative: bool) {}
-    fn set_apcu(&mut self, _apcu: bool, _apcu_prefix: Option<String>) {}
-    fn set_run_scripts(&mut self, _run_scripts: bool) {}
-    fn set_dry_run(&mut self, _dry_run: bool) {}
+    fn set_dev_mode(&self, _dev_mode: bool) {}
+    fn set_class_map_authoritative(&self, _class_map_authoritative: bool) {}
+    fn set_apcu(&self, _apcu: bool, _apcu_prefix: Option<String>) {}
+    fn set_run_scripts(&self, _run_scripts: bool) {}
+    fn set_dry_run(&self, _dry_run: bool) {}
     fn set_platform_requirement_filter(
-        &mut self,
+        &self,
         _platform_requirement_filter: std::rc::Rc<dyn PlatformRequirementFilterInterface>,
     ) {
     }
     #[allow(clippy::too_many_arguments)]
     fn dump(
-        &mut self,
+        &self,
         _config: &Config,
-        _local_repo: &mut dyn InstalledRepositoryInterface,
+        _local_repo: shirabe::repository::RepositoryInterfaceHandle,
         _root_package: RootPackageInterfaceHandle,
-        _installation_manager: &mut dyn shirabe::installer::InstallationManagerInterface,
+        _installation_manager: std::rc::Rc<
+            std::cell::RefCell<dyn shirabe::installer::InstallationManagerInterface>,
+        >,
         _target_dir: &str,
         _scan_psr_packages: bool,
         _suffix: Option<String>,
-        _locker: Option<&mut dyn LockerInterface>,
+        _locker: Option<std::rc::Rc<std::cell::RefCell<dyn LockerInterface>>>,
         _strict_ambiguous: bool,
     ) -> anyhow::Result<ClassMap> {
         Ok(ClassMap::new())
     }
     fn build_package_map(
         &self,
-        _installation_manager: &mut dyn shirabe::installer::InstallationManagerInterface,
+        _installation_manager: std::rc::Rc<
+            std::cell::RefCell<dyn shirabe::installer::InstallationManagerInterface>,
+        >,
         _root_package: RootPackageInterfaceHandle,
         _packages: Vec<PackageInterfaceHandle>,
     ) -> anyhow::Result<Vec<(PackageInterfaceHandle, Option<String>)>> {