fix(compile): fix more random compile errors

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

5 files changed, 92 insertions, 103 deletions

diff --git a/crates/shirabe/src/io/base_io.rs b/crates/shirabe/src/io/base_io.rs
index d4e8f73..6e6e7d0 100644
--- a/crates/shirabe/src/io/base_io.rs
+++ b/crates/shirabe/src/io/base_io.rs
@@ -54,37 +54,29 @@ pub trait BaseIO: IOInterface {
         self.authentications_mut().insert(repository_name, auth);
     }
 
-    fn write_raw(&self, messages: PhpMixed, newline: bool, verbosity: i64) {
-        self.write(messages, newline, verbosity);
-    }
-
-    fn write_error_raw(&self, messages: PhpMixed, newline: bool, verbosity: i64) {
-        self.write_error(messages, newline, verbosity);
-    }
-
     fn check_and_set_authentication(
         &mut self,
         repository_name: String,
         username: String,
         password: Option<String>,
     ) {
-        if self.has_authentication(&repository_name) {
-            let auth = self.get_authentication(&repository_name);
+        if BaseIO::has_authentication(self, &repository_name) {
+            let auth = BaseIO::get_authentication(self, &repository_name);
             if auth.get("username").and_then(|v| v.as_deref()) == Some(username.as_str())
                 && *auth.get("password").unwrap_or(&None) == password
             {
                 return;
             }
-            self.write_error(
-                PhpMixed::String(format!(
+            self.write_error3(
+                &format!(
                     "<warning>Warning: You should avoid overwriting already defined auth settings for {}.</warning>",
                     repository_name
-                )),
+                ),
                 true,
                 io_interface::NORMAL,
             );
         }
-        self.set_authentication(repository_name, username, password);
+        BaseIO::set_authentication(self, repository_name, username, password);
     }
 
     fn load_configuration(&mut self, config: &mut Config) -> anyhow::Result<()> {
@@ -358,14 +350,10 @@ pub trait BaseIO: IOInterface {
                     }
 
                     if !ssl_options.contains_key("local_cert") {
-                        self.write_error(
-                            PhpMixed::String(format!(
-                                "<warning>Warning: Client certificate configuration is missing key `local_cert` for {}.</warning>",
-                                domain
-                            )),
-                            true,
-                            io_interface::NORMAL,
-                        );
+                        self.write_error3(&format!(
+                            "<warning>Warning: Client certificate configuration is missing key `local_cert` for {}.</warning>",
+                            domain
+                        ), true, io_interface::NORMAL);
                         continue;
                     }
 
@@ -481,31 +469,31 @@ pub trait BaseIO: IOInterface {
             ]),
             false,
         ) {
-            self.write_error(
-                PhpMixed::String(format!("<error>{}</error>", message_str)),
+            self.write_error3(
+                &format!("<error>{}</error>", message_str),
                 true,
                 io_interface::NORMAL,
             );
         } else if level_str == LogLevel::WARNING {
-            self.write_error(
-                PhpMixed::String(format!("<warning>{}</warning>", message_str)),
+            self.write_error3(
+                &format!("<warning>{}</warning>", message_str),
                 true,
                 io_interface::NORMAL,
             );
         } else if level_str == LogLevel::NOTICE {
-            self.write_error(
-                PhpMixed::String(format!("<info>{}</info>", message_str)),
+            self.write_error3(
+                &format!("<info>{}</info>", message_str),
                 true,
                 io_interface::VERBOSE,
             );
         } else if level_str == LogLevel::INFO {
-            self.write_error(
-                PhpMixed::String(format!("<info>{}</info>", message_str)),
+            self.write_error3(
+                &format!("<info>{}</info>", message_str),
                 true,
                 io_interface::VERY_VERBOSE,
             );
         } else {
-            self.write_error(PhpMixed::String(message_str), true, io_interface::DEBUG);
+            self.write_error3(&message_str, true, io_interface::DEBUG);
         }
     }
 }
diff --git a/crates/shirabe/src/io/buffer_io.rs b/crates/shirabe/src/io/buffer_io.rs
index aa1d970..79fa9c3 100644
--- a/crates/shirabe/src/io/buffer_io.rs
+++ b/crates/shirabe/src/io/buffer_io.rs
@@ -56,15 +56,26 @@ impl BufferIO {
 
         let output = Preg::replace_callback(
             r"{(?<=^|\n|\x08)(.+?)(\x08+)}",
-            |matches: &[String]| -> String {
-                let pre = strip_tags(&matches[1]);
+            |matches: &indexmap::IndexMap<
+                shirabe_external_packages::composer::pcre::preg::CaptureKey,
+                String,
+            >|
+             -> String {
+                let empty = String::new();
+                let g1 = matches
+                    .get(&shirabe_external_packages::composer::pcre::preg::CaptureKey::ByIndex(1))
+                    .unwrap_or(&empty);
+                let g2 = matches
+                    .get(&shirabe_external_packages::composer::pcre::preg::CaptureKey::ByIndex(2))
+                    .unwrap_or(&empty);
+                let pre = strip_tags(g1);
 
-                if pre.len() == matches[2].len() {
+                if pre.len() == g2.len() {
                     return String::new();
                 }
 
                 // TODO reverse parse the string, skipping span tags and \033\[([0-9;]+)m(.*?)\033\[0m style blobs
-                format!("{}\n", matches[1].trim_end())
+                format!("{}\n", g1.trim_end())
             },
             &output,
         );
diff --git a/crates/shirabe/src/io/console_io.rs b/crates/shirabe/src/io/console_io.rs
index 6f17a3e..39099c4 100644
--- a/crates/shirabe/src/io/console_io.rs
+++ b/crates/shirabe/src/io/console_io.rs
@@ -11,7 +11,9 @@ use shirabe_external_packages::symfony::component::console::helper::progress_bar
 use shirabe_external_packages::symfony::component::console::helper::table::Table;
 use shirabe_external_packages::symfony::component::console::input::input_interface::InputInterface;
 use shirabe_external_packages::symfony::component::console::output::console_output_interface::ConsoleOutputInterface;
-use shirabe_external_packages::symfony::component::console::output::output_interface::OutputInterface;
+use shirabe_external_packages::symfony::component::console::output::output_interface::{
+    self as output_interface, OutputInterface,
+};
 use shirabe_external_packages::symfony::component::console::question::choice_question::ChoiceQuestion;
 use shirabe_external_packages::symfony::component::console::question::question::Question;
 use shirabe_php_shim::{
@@ -19,6 +21,7 @@ use shirabe_php_shim::{
     is_array, is_string, mb_check_encoding, mb_convert_encoding, microtime, sprintf, str_repeat,
     strip_tags, strlen,
 };
+use std::cell::RefCell;
 
 use crate::io::base_io::BaseIO;
 use crate::io::io_interface::IOInterface;
@@ -33,8 +36,8 @@ pub struct ConsoleIO {
     pub(crate) input: Box<dyn InputInterface>,
     pub(crate) output: Box<dyn OutputInterface>,
     pub(crate) helper_set: HelperSet,
-    pub(crate) last_message: String,
-    pub(crate) last_message_err: String,
+    pub(crate) last_message: RefCell<String>,
+    pub(crate) last_message_err: RefCell<String>,
 
     /// @var float
     start_time: Option<f64>,
@@ -54,21 +57,21 @@ impl ConsoleIO {
         helper_set: HelperSet,
     ) -> Self {
         let mut verbosity_map = IndexMap::new();
-        verbosity_map.insert(io_interface::QUIET, OutputInterface::VERBOSITY_QUIET);
-        verbosity_map.insert(io_interface::NORMAL, OutputInterface::VERBOSITY_NORMAL);
-        verbosity_map.insert(io_interface::VERBOSE, OutputInterface::VERBOSITY_VERBOSE);
+        verbosity_map.insert(io_interface::QUIET, output_interface::VERBOSITY_QUIET);
+        verbosity_map.insert(io_interface::NORMAL, output_interface::VERBOSITY_NORMAL);
+        verbosity_map.insert(io_interface::VERBOSE, output_interface::VERBOSITY_VERBOSE);
         verbosity_map.insert(
             io_interface::VERY_VERBOSE,
-            OutputInterface::VERBOSITY_VERY_VERBOSE,
+            output_interface::VERBOSITY_VERY_VERBOSE,
         );
-        verbosity_map.insert(io_interface::DEBUG, OutputInterface::VERBOSITY_DEBUG);
+        verbosity_map.insert(io_interface::DEBUG, output_interface::VERBOSITY_DEBUG);
         Self {
             authentications: indexmap![],
             input,
             output,
             helper_set,
-            last_message: String::new(),
-            last_message_err: String::new(),
+            last_message: RefCell::new(String::new()),
+            last_message_err: RefCell::new(String::new()),
             start_time: None,
             verbosity_map,
         }
@@ -79,21 +82,14 @@ impl ConsoleIO {
     }
 
     /// @param string[]|string $messages
-    fn do_write(
-        &mut self,
-        messages: PhpMixed,
-        newline: bool,
-        stderr: bool,
-        verbosity: i64,
-        raw: bool,
-    ) {
+    fn do_write(&self, messages: PhpMixed, newline: bool, stderr: bool, verbosity: i64, raw: bool) {
         let mut sf_verbosity = *self.verbosity_map.get(&verbosity).unwrap_or(&0);
         if sf_verbosity > self.output.get_verbosity() {
             return;
         }
 
         if raw {
-            sf_verbosity |= OutputInterface::OUTPUT_RAW;
+            sf_verbosity |= output_interface::OUTPUT_RAW;
         }
 
         let messages = if let Some(start_time) = self.start_time {
@@ -137,9 +133,9 @@ impl ConsoleIO {
                 todo!("downcast self.output to ConsoleOutputInterface");
             console_output
                 .get_error_output()
-                .write(messages.clone(), newline, sf_verbosity);
+                .write3(messages.clone(), newline, sf_verbosity);
             // PHP: implode($newline ? "\n" : '', (array) $messages)
-            self.last_message_err = implode(
+            *self.last_message_err.borrow_mut() = implode(
                 if newline { "\n" } else { "" },
                 &Self::to_string_list(&messages),
             );
@@ -147,8 +143,8 @@ impl ConsoleIO {
             return;
         }
 
-        self.output.write(messages.clone(), newline, sf_verbosity);
-        self.last_message = implode(
+        self.output.write3(messages.clone(), newline, sf_verbosity);
+        *self.last_message.borrow_mut() = implode(
             if newline { "\n" } else { "" },
             &Self::to_string_list(&messages),
         );
@@ -156,7 +152,7 @@ impl ConsoleIO {
 
     /// @param string[]|string $messages
     fn do_overwrite(
-        &mut self,
+        &self,
         messages: PhpMixed,
         newline: bool,
         size: Option<i64>,
@@ -173,9 +169,9 @@ impl ConsoleIO {
         let size = size.unwrap_or_else(|| {
             // removing possible formatting of lastMessage with strip_tags
             strlen(&strip_tags(if stderr {
-                &self.last_message_err
+                &self.last_message_err.borrow()
             } else {
-                &self.last_message
+                &self.last_message.borrow()
             }))
         });
         // ...let's fill its length with backspaces
@@ -230,9 +226,9 @@ impl ConsoleIO {
         }
 
         if stderr {
-            self.last_message_err = messages_str;
+            *self.last_message_err.borrow_mut() = messages_str;
         } else {
-            self.last_message = messages_str;
+            *self.last_message.borrow_mut() = messages_str;
         }
     }
 
@@ -420,37 +416,31 @@ impl IOInterface for ConsoleIO {
         self.output.is_decorated()
     }
 
-    fn write3(&mut self, message: &str, newline: bool, verbosity: i64) {
+    fn write3(&self, message: &str, newline: bool, verbosity: i64) {
         let message = Self::sanitize(message, true);
 
         self.do_write(message, newline, false, verbosity, false);
     }
 
-    fn write_error3(&mut self, message: &str, newline: bool, verbosity: i64) {
+    fn write_error3(&self, message: &str, newline: bool, verbosity: i64) {
         let message = Self::sanitize(message, true);
 
         self.do_write(message, newline, true, verbosity, false);
     }
 
-    fn write_raw3(&mut self, message: &str, newline: bool, verbosity: i64) {
+    fn write_raw3(&self, message: &str, newline: bool, verbosity: i64) {
         self.do_write(message, newline, false, verbosity, true);
     }
 
-    fn write_error_raw3(&mut self, message: &str, newline: bool, verbosity: i64) {
+    fn write_error_raw3(&self, message: &str, newline: bool, verbosity: i64) {
         self.do_write(message, newline, true, verbosity, true);
     }
 
-    fn overwrite4(&mut self, message: &str, newline: bool, size: Option<i64>, verbosity: i64) {
+    fn overwrite4(&self, message: &str, newline: bool, size: Option<i64>, verbosity: i64) {
         self.do_overwrite(message, newline, size, false, verbosity);
     }
 
-    fn overwrite_error4(
-        &mut self,
-        message: &str,
-        newline: bool,
-        size: Option<i64>,
-        verbosity: i64,
-    ) {
+    fn overwrite_error4(&self, message: &str, newline: bool, size: Option<i64>, verbosity: i64) {
         self.do_overwrite(message, newline, size, true, verbosity);
     }
 
diff --git a/crates/shirabe/src/io/io_interface.rs b/crates/shirabe/src/io/io_interface.rs
index e78b608..d9092b1 100644
--- a/crates/shirabe/src/io/io_interface.rs
+++ b/crates/shirabe/src/io/io_interface.rs
@@ -22,65 +22,65 @@ pub trait IOInterface: LoggerInterface + std::fmt::Debug {
 
     fn is_decorated(&self) -> bool;
 
-    fn write(&mut self, message: &str) {
+    fn write(&self, message: &str) {
         self.write3(message, true, NORMAL)
     }
-    fn write2(&mut self, message: &str, newline: bool) {
+    fn write2(&self, message: &str, newline: bool) {
         self.write3(message, newline, NORMAL)
     }
-    fn write_no_newline(&mut self, message: &str) {
+    fn write_no_newline(&self, message: &str) {
         self.write3(message, false, NORMAL)
     }
-    fn write3(&mut self, message: &str, newline: bool, verbosity: i64);
+    fn write3(&self, message: &str, newline: bool, verbosity: i64);
 
-    fn write_error(&mut self, message: &str) {
+    fn write_error(&self, message: &str) {
         self.write_error3(message, true, NORMAL)
     }
-    fn write_error2(&mut self, message: &str, newline: bool) {
+    fn write_error2(&self, message: &str, newline: bool) {
         self.write_error3(message, newline, NORMAL)
     }
-    fn write_error_no_newline(&mut self, message: &str) {
+    fn write_error_no_newline(&self, message: &str) {
         self.write_error3(message, false, NORMAL)
     }
-    fn write_error3(&mut self, message: &str, newline: bool, verbosity: i64);
+    fn write_error3(&self, message: &str, newline: bool, verbosity: i64);
 
-    fn write_raw(&mut self, message: &str) {
+    fn write_raw(&self, message: &str) {
         self.write_raw3(message, true, NORMAL)
     }
-    fn write_raw2(&mut self, message: &str, newline: bool) {
+    fn write_raw2(&self, message: &str, newline: bool) {
         self.write_raw3(message, newline, NORMAL)
     }
-    fn write_raw3(&mut self, message: &str, newline: bool, verbosity: i64);
+    fn write_raw3(&self, message: &str, newline: bool, verbosity: i64);
 
-    fn write_error_raw(&mut self, message: &str) {
+    fn write_error_raw(&self, message: &str) {
         self.write_error_raw3(message, true, NORMAL)
     }
-    fn write_error_raw2(&mut self, message: &str, newline: bool) {
+    fn write_error_raw2(&self, message: &str, newline: bool) {
         self.write_error_raw3(message, newline, NORMAL)
     }
-    fn write_error_raw3(&mut self, message: &str, newline: bool, verbosity: i64);
+    fn write_error_raw3(&self, message: &str, newline: bool, verbosity: i64);
 
-    fn overwrite(&mut self, message: &str) {
+    fn overwrite(&self, message: &str) {
         self.overwrite4(message, true, None, NORMAL)
     }
-    fn overwrite2(&mut self, message: &str, newline: bool) {
+    fn overwrite2(&self, message: &str, newline: bool) {
         self.overwrite4(message, newline, None, NORMAL)
     }
-    fn overwrite3(&mut self, message: &str, newline: bool, size: Option<i64>) {
+    fn overwrite3(&self, message: &str, newline: bool, size: Option<i64>) {
         self.overwrite4(message, newline, size, NORMAL)
     }
-    fn overwrite4(&mut self, message: &str, newline: bool, size: Option<i64>, verbosity: i64);
+    fn overwrite4(&self, message: &str, newline: bool, size: Option<i64>, verbosity: i64);
 
-    fn overwrite_error(&mut self, message: &str) {
+    fn overwrite_error(&self, message: &str) {
         self.overwrite_error4(message, true, None, NORMAL)
     }
-    fn overwrite_error2(&mut self, message: &str, newline: bool) {
+    fn overwrite_error2(&self, message: &str, newline: bool) {
         self.overwrite_error4(message, newline, None, NORMAL)
     }
-    fn overwrite_error3(&mut self, message: &str, newline: bool, size: Option<i64>) {
+    fn overwrite_error3(&self, message: &str, newline: bool, size: Option<i64>) {
         self.overwrite_error4(message, newline, size, NORMAL)
     }
-    fn overwrite_error4(&mut self, message: &str, newline: bool, size: Option<i64>, verbosity: i64);
+    fn overwrite_error4(&self, message: &str, newline: bool, size: Option<i64>, verbosity: i64);
 
     fn ask(&mut self, question: String, default: PhpMixed) -> PhpMixed;
 
diff --git a/crates/shirabe/src/io/null_io.rs b/crates/shirabe/src/io/null_io.rs
index 4ec5be0..2536ad0 100644
--- a/crates/shirabe/src/io/null_io.rs
+++ b/crates/shirabe/src/io/null_io.rs
@@ -39,18 +39,18 @@ impl IOInterface for NullIO {
         false
     }
 
-    fn write3(&mut self, _message: &str, _newline: bool, _verbosity: i64) {}
+    fn write3(&self, _message: &str, _newline: bool, _verbosity: i64) {}
 
-    fn write_error3(&mut self, _message: &str, _newline: bool, _verbosity: i64) {}
+    fn write_error3(&self, _message: &str, _newline: bool, _verbosity: i64) {}
 
-    fn write_raw3(&mut self, _message: &str, _newline: bool, _verbosity: i64) {}
+    fn write_raw3(&self, _message: &str, _newline: bool, _verbosity: i64) {}
 
-    fn write_error_raw3(&mut self, _message: &str, _newline: bool, _verbosity: i64) {}
+    fn write_error_raw3(&self, _message: &str, _newline: bool, _verbosity: i64) {}
 
-    fn overwrite4(&mut self, _message: &str, _newline: bool, _size: Option<i64>, _verbosity: i64) {}
+    fn overwrite4(&self, _message: &str, _newline: bool, _size: Option<i64>, _verbosity: i64) {}
 
     fn overwrite_error4(
-        &mut self,
+        &self,
         _message: &str,
         _newline: bool,
         _size: Option<i64>,