refactor(package): introduce Rc<RefCell<_>> handles for packages

PHP packages have reference semantics, so introduce shared-ownership
handles over an AnyPackage enum (PackageInterfaceHandle and friends)
and replace Box<dyn PackageInterface> throughout.

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

1 files changed, 67 insertions, 47 deletions

diff --git a/crates/shirabe/src/package/complete_alias_package.rs b/crates/shirabe/src/package/complete_alias_package.rs
index 530bd03..6a23bee 100644
--- a/crates/shirabe/src/package/complete_alias_package.rs
+++ b/crates/shirabe/src/package/complete_alias_package.rs
@@ -1,136 +1,156 @@
 //! ref: composer/src/Composer/Package/CompleteAliasPackage.php
 
+use indexmap::IndexMap;
+use shirabe_php_shim::PhpMixed;
+
 use crate::package::AliasPackage;
-use crate::package::CompletePackage;
+use crate::package::CompletePackageHandle;
 use crate::package::CompletePackageInterface;
+use crate::package::PackageHandle;
+use crate::package::handle::delegate_package_interface_to_inner;
 
 #[derive(Debug)]
 pub struct CompleteAliasPackage {
     inner: AliasPackage,
     // overrides AliasPackage::alias_of with the more specific CompletePackage type
-    pub(crate) alias_of: CompletePackage,
+    pub(crate) alias_of: CompletePackageHandle,
 }
 
 impl CompleteAliasPackage {
-    pub fn new(alias_of: CompletePackage, version: String, pretty_version: String) -> Self {
-        // TODO(phase-b): alias_of is a PHP class (shared semantics); cloning is wrong.
-        // Use a dummy BasePackage placeholder until the field is migrated to Rc<CompletePackage>.
+    pub fn new(alias_of: CompletePackageHandle, version: String, pretty_version: String) -> Self {
         let inner = AliasPackage::new(
-            todo!("share CompletePackage via Rc"),
+            PackageHandle::from(alias_of.clone()),
             version,
             pretty_version,
         );
         Self { inner, alias_of }
     }
 
-    pub fn get_alias_of(&self) -> &CompletePackage {
-        &self.alias_of
+    pub fn get_alias_of(&self) -> CompletePackageHandle {
+        self.alias_of.clone()
+    }
+
+    pub fn set_root_package_alias(&mut self, value: bool) {
+        self.inner.set_root_package_alias(value);
+    }
+
+    pub fn is_root_package_alias(&self) -> bool {
+        self.inner.is_root_package_alias()
+    }
+
+    pub fn has_self_version_requires(&self) -> bool {
+        self.inner.has_self_version_requires()
+    }
+}
+
+delegate_package_interface_to_inner!(CompleteAliasPackage, inner);
+
+impl std::fmt::Display for CompleteAliasPackage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.inner, f)
     }
+}
 
-    pub fn get_scripts(&self) -> indexmap::IndexMap<String, Vec<String>> {
+impl CompletePackageInterface for CompleteAliasPackage {
+    fn get_scripts(&self) -> IndexMap<String, Vec<String>> {
         self.alias_of.get_scripts()
     }
 
-    pub fn set_scripts(&mut self, scripts: indexmap::IndexMap<String, Vec<String>>) {
+    fn set_scripts(&mut self, scripts: IndexMap<String, Vec<String>>) {
         self.alias_of.set_scripts(scripts);
     }
 
-    pub fn get_repositories(&self) -> Vec<indexmap::IndexMap<String, shirabe_php_shim::PhpMixed>> {
+    fn get_repositories(&self) -> Vec<IndexMap<String, PhpMixed>> {
         self.alias_of.get_repositories()
     }
 
-    pub fn set_repositories(
-        &mut self,
-        repositories: Vec<indexmap::IndexMap<String, shirabe_php_shim::PhpMixed>>,
-    ) {
+    fn set_repositories(&mut self, repositories: Vec<IndexMap<String, PhpMixed>>) {
         self.alias_of.set_repositories(repositories);
     }
 
-    pub fn get_license(&self) -> Vec<String> {
+    fn get_license(&self) -> Vec<String> {
         self.alias_of.get_license()
     }
 
-    pub fn set_license(&mut self, license: Vec<String>) {
+    fn set_license(&mut self, license: Vec<String>) {
         self.alias_of.set_license(license);
     }
 
-    pub fn get_keywords(&self) -> Vec<String> {
+    fn get_keywords(&self) -> Vec<String> {
         self.alias_of.get_keywords()
     }
 
-    pub fn set_keywords(&mut self, keywords: Vec<String>) {
+    fn set_keywords(&mut self, keywords: Vec<String>) {
         self.alias_of.set_keywords(keywords);
     }
 
-    pub fn get_description(&self) -> Option<&str> {
-        self.alias_of.get_description()
+    fn get_description(&self) -> Option<&str> {
+        todo!("CompleteAliasPackage::get_description cannot return &str across the aliasOf handle")
     }
 
-    pub fn set_description(&mut self, description: Option<String>) {
-        self.alias_of
-            .set_description(description.unwrap_or_default());
+    fn set_description(&mut self, description: String) {
+        self.alias_of.set_description(description);
     }
 
-    pub fn get_homepage(&self) -> Option<&str> {
-        self.alias_of.get_homepage()
+    fn get_homepage(&self) -> Option<&str> {
+        todo!("CompleteAliasPackage::get_homepage cannot return &str across the aliasOf handle")
     }
 
-    pub fn set_homepage(&mut self, homepage: Option<String>) {
-        self.alias_of.set_homepage(homepage.unwrap_or_default());
+    fn set_homepage(&mut self, homepage: String) {
+        self.alias_of.set_homepage(homepage);
     }
 
-    pub fn get_authors(&self) -> Vec<indexmap::IndexMap<String, String>> {
+    fn get_authors(&self) -> Vec<IndexMap<String, String>> {
         self.alias_of.get_authors()
     }
 
-    pub fn set_authors(&mut self, authors: Vec<indexmap::IndexMap<String, String>>) {
+    fn set_authors(&mut self, authors: Vec<IndexMap<String, String>>) {
         self.alias_of.set_authors(authors);
     }
 
-    pub fn get_support(&self) -> indexmap::IndexMap<String, String> {
+    fn get_support(&self) -> IndexMap<String, String> {
         self.alias_of.get_support()
     }
 
-    pub fn set_support(&mut self, support: indexmap::IndexMap<String, String>) {
+    fn set_support(&mut self, support: IndexMap<String, String>) {
         self.alias_of.set_support(support);
     }
 
-    pub fn get_funding(&self) -> Vec<indexmap::IndexMap<String, shirabe_php_shim::PhpMixed>> {
+    fn get_funding(&self) -> Vec<IndexMap<String, PhpMixed>> {
         self.alias_of.get_funding()
     }
 
-    pub fn set_funding(
-        &mut self,
-        funding: Vec<indexmap::IndexMap<String, shirabe_php_shim::PhpMixed>>,
-    ) {
+    fn set_funding(&mut self, funding: Vec<IndexMap<String, PhpMixed>>) {
         self.alias_of.set_funding(funding);
     }
 
-    pub fn is_abandoned(&self) -> bool {
+    fn is_abandoned(&self) -> bool {
         self.alias_of.is_abandoned()
     }
 
-    pub fn get_replacement_package(&self) -> Option<&str> {
-        self.alias_of.get_replacement_package()
+    fn get_replacement_package(&self) -> Option<&str> {
+        todo!(
+            "CompleteAliasPackage::get_replacement_package cannot return &str across the aliasOf handle"
+        )
     }
 
-    pub fn set_abandoned(&mut self, abandoned: shirabe_php_shim::PhpMixed) {
+    fn set_abandoned(&mut self, abandoned: PhpMixed) {
         self.alias_of.set_abandoned(abandoned);
     }
 
-    pub fn get_archive_name(&self) -> Option<&str> {
-        self.alias_of.get_archive_name()
+    fn get_archive_name(&self) -> Option<&str> {
+        todo!("CompleteAliasPackage::get_archive_name cannot return &str across the aliasOf handle")
     }
 
-    pub fn set_archive_name(&mut self, name: Option<String>) {
-        self.alias_of.set_archive_name(name.unwrap_or_default());
+    fn set_archive_name(&mut self, name: String) {
+        self.alias_of.set_archive_name(name);
     }
 
-    pub fn get_archive_excludes(&self) -> Vec<String> {
+    fn get_archive_excludes(&self) -> Vec<String> {
         self.alias_of.get_archive_excludes()
     }
 
-    pub fn set_archive_excludes(&mut self, excludes: Vec<String>) {
+    fn set_archive_excludes(&mut self, excludes: Vec<String>) {
         self.alias_of.set_archive_excludes(excludes);
     }
 }