feat(solver): surface SolverProblemsException via two-layer Result

solve() previously dropped the SolverProblemsException and returned a
placeholder anyhow error, because its Rc<RefCell<Rule>> payload is not
Send+Sync and cannot ride anyhow::Error. Return
anyhow::Result<Result<LockTransaction, SolverProblemsException>> instead,
keeping fatal errors on the outer Result and the recoverable exception on
the inner one.

This lets the three Installer callsites port their PHP catch handlers
faithfully (pretty-string output, GithubActionError emit, getCode-based
exit codes) and lets solver_test.rs assert getProblems/getCode/
getPrettyString. The four ported assertion tests stay ignored: their
pretty-string path still reaches unimplemented todo!()s downstream.

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

2 files changed, 85 insertions, 24 deletions

diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index 52c4580..cd00757 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -230,7 +230,7 @@ impl Solver {
         &mut self,
         request: &Request,
         platform_requirement_filter: Option<Rc<dyn PlatformRequirementFilterInterface>>,
-    ) -> anyhow::Result<LockTransaction> {
+    ) -> anyhow::Result<Result<LockTransaction, SolverProblemsException>> {
         let platform_requirement_filter = platform_requirement_filter
             .unwrap_or_else(|| PlatformRequirementFilterFactory::ignore_nothing());
 
@@ -272,27 +272,25 @@ impl Solver {
         );
 
         if !self.problems.is_empty() {
-            // TODO(phase-c): SolverProblemsException stores `Rc<RefCell<Rule>>` which is not
-            // `Send + Sync`, so it cannot satisfy `anyhow::Error`'s bounds. Returning a
-            // placeholder error preserves control flow until the solver error path is reworked to
-            // a dedicated (non-anyhow) error type or the exception drops its dyn Rule payload.
-            let _ = SolverProblemsException::new(
+            // SolverProblemsException stores `Rc<RefCell<Rule>>` which is not `Send + Sync`, so it
+            // cannot satisfy `anyhow::Error`'s bounds. It is the recoverable exception PHP callers
+            // `catch`, so it rides the inner `Result` while fatal errors stay on the outer one.
+            return Ok(Err(SolverProblemsException::new(
                 std::mem::take(&mut self.problems),
                 std::mem::take(&mut self.learned_pool),
-            );
-            return Err(anyhow::anyhow!("solver problems"));
+            )));
         }
 
         // LockTransaction stores PackageInterfaceHandle maps; widen the request's BasePackageHandle
         // maps into them.
         let present_map = request.get_present_map(false)?.into_iter().collect();
         let unlockable_map = request.get_fixed_packages_map().into_iter().collect();
-        Ok(LockTransaction::new(
+        Ok(Ok(LockTransaction::new(
             &self.pool.borrow(),
             present_map,
             unlockable_map,
             &self.decisions,
-        ))
+        )))
     }
 
     /// Makes a decision and propagates it to all rules.
diff --git a/crates/shirabe/src/installer.rs b/crates/shirabe/src/installer.rs
index 8149b05..d1e839d 100644
--- a/crates/shirabe/src/installer.rs
+++ b/crates/shirabe/src/installer.rs
@@ -680,7 +680,7 @@ impl Installer {
         match solver
             .as_mut()
             .unwrap()
-            .solve(&request, Some(self.platform_requirement_filter.clone()))
+            .solve(&request, Some(self.platform_requirement_filter.clone()))?
         {
             Ok(t) => {
                 lock_transaction = t;
@@ -688,11 +688,34 @@ impl Installer {
                 solver = None;
             }
             Err(e) => {
-                // TODO(phase-c): SolverProblemsException contains dyn Rule which isn't Send+Sync
-                // so anyhow::Error::downcast_ref can't extract it. Skipping detection until the
-                // solver error path moves off anyhow (see solver.rs).
-                let _ = (&repository_set, &request, &pool);
-                return Err(e);
+                let err =
+                    "Your requirements could not be resolved to an installable set of packages.";
+                let pretty_problem = e.get_pretty_string(
+                    &repository_set,
+                    &request,
+                    &mut pool.borrow_mut(),
+                    self.io.is_verbose(),
+                    false,
+                )?;
+
+                self.io.write_error3(
+                    &format!("<error>{}</error>", err),
+                    true,
+                    io_interface::QUIET,
+                );
+                self.io.write_error(&pretty_problem);
+                if !self.dev_mode {
+                    self.io.write_error3(
+                        "<warning>Running update with --no-dev does not mean require-dev is ignored, it just means the packages will not be installed. If dev requirements are blocking the update you have to resolve those problems.</warning>",
+                        true,
+                        io_interface::QUIET,
+                    );
+                }
+
+                let mut ghe = GithubActionError::new(self.io.clone());
+                ghe.emit(&format!("{}\n{}", err, pretty_problem), None, None);
+
+                return Ok(std::cmp::max(Self::ERROR_GENERIC_FAILURE, e.get_code()));
             }
         }
         let _ = solver;
@@ -967,16 +990,39 @@ impl Installer {
         match solver
             .as_mut()
             .unwrap()
-            .solve(&request, Some(self.platform_requirement_filter.clone()))
+            .solve(&request, Some(self.platform_requirement_filter.clone()))?
         {
             Ok(t) => {
                 non_dev_lock_transaction = t;
                 solver = None;
             }
             Err(e) => {
-                // TODO(phase-c): SolverProblemsException can't be downcast (dyn Rule not Send+Sync); see solver.rs
-                let _ = (&repository_set, &request, &pool);
-                return Err(e);
+                let err = "Unable to find a compatible set of packages based on your non-dev requirements alone.";
+                let pretty_problem = e.get_pretty_string(
+                    &repository_set,
+                    &request,
+                    &mut pool.borrow_mut(),
+                    self.io.is_verbose(),
+                    true,
+                )?;
+
+                self.io.write_error3(
+                    &format!("<error>{}</error>", err),
+                    true,
+                    io_interface::QUIET,
+                );
+                self.io.write_error(
+                    "Your requirements can be resolved successfully when require-dev packages are present.",
+                );
+                self.io.write_error(
+                    "You may need to move packages from require-dev or some of their dependencies to require.",
+                );
+                self.io.write_error(&pretty_problem);
+
+                let mut ghe = GithubActionError::new(self.io.clone());
+                ghe.emit(&format!("{}\n{}", err, pretty_problem), None, None);
+
+                return Ok(e.get_code());
             }
         }
         let _ = solver;
@@ -1111,7 +1157,7 @@ impl Installer {
             match solver
                 .as_mut()
                 .unwrap()
-                .solve(&request, Some(self.platform_requirement_filter.clone()))
+                .solve(&request, Some(self.platform_requirement_filter.clone()))?
             {
                 Ok(lock_transaction) => {
                     solver = None;
@@ -1128,9 +1174,26 @@ impl Installer {
                     }
                 }
                 Err(e) => {
-                    // TODO(phase-c): SolverProblemsException can't be downcast (dyn Rule not Send+Sync); see solver.rs
-                    let _ = (&repository_set, &request, &pool);
-                    return Err(e);
+                    let err = "Your lock file does not contain a compatible set of packages. Please run composer update.";
+                    let pretty_problem = e.get_pretty_string(
+                        &repository_set,
+                        &request,
+                        &mut pool.borrow_mut(),
+                        self.io.is_verbose(),
+                        false,
+                    )?;
+
+                    self.io.write_error3(
+                        &format!("<error>{}</error>", err),
+                        true,
+                        io_interface::QUIET,
+                    );
+                    self.io.write_error(&pretty_problem);
+
+                    let mut ghe = GithubActionError::new(self.io.clone());
+                    ghe.emit(&format!("{}\n{}", err, pretty_problem), None, None);
+
+                    return Ok(std::cmp::max(Self::ERROR_GENERIC_FAILURE, e.get_code()));
                 }
             }
             let _ = solver;