halide-cache: return Found::Hit/Miss from restore_outputs

retrieve_both returned a bool, so `if retrieve_both(..)?` read like a
condition on retrieving both rather than "was it a hit". Rename it and
return a named result, matching Lookup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TVxsuu7ZCt2cdfn99fuXaA

Author: RMPR

halide-cache/src/main.rs

@@ -320,7 +320,7 @@ fn lookup(
     remote: Option<&remote::Remote>,
     outputs: &Outputs,
 ) -> anyhow::Result<Lookup> {
-    if retrieve_both(lager, outputs)? {
+    if let Found::Hit = restore_outputs(lager, outputs)? {
         return Ok(Lookup::LocalHit);
     }
     let Some(remote) = remote else {
@@ -329,12 +329,12 @@ fn lookup(
     if !fetch_from_remote(remote, lager, outputs) {
         return Ok(Lookup::Miss);
     }
-    match retrieve_both(lager, outputs) {
-        Ok(true) => {
+    match restore_outputs(lager, outputs) {
+        Ok(Found::Hit) => {
             println!("Remote cache hits for Halide target {}", outputs.target());
             Ok(Lookup::RemoteHit)
         }
-        Ok(false) => Ok(Lookup::Miss),
+        Ok(Found::Miss) => Ok(Lookup::Miss),
         Err(e) => {
             // The server handed us something that does not extract.
             warn(format!("discarding corrupt remote entries: {e:#}"));
@@ -450,18 +450,24 @@ fn collect_zivid_env() -> Vec<String> {
     v
 }
 
-/// Extracts both outputs from the local cache. `Ok(false)` when neither is
-/// there; a lone entry or a broken one is an error, since the two are always
-/// stored together.
-fn retrieve_both(lager: &Lager, outputs: &Outputs) -> anyhow::Result<bool> {
+/// Whether the outputs were in the local cache.
+enum Found {
+    Hit,
+    Miss,
+}
+
+/// Extracts the object and the header from the local cache. `Found::Miss`
+/// when neither is there; a lone entry or a broken one is an error, since the
+/// two are always stored together.
+fn restore_outputs(lager: &Lager, outputs: &Outputs) -> anyhow::Result<Found> {
     let object = lager.retrieve(&outputs.object.address, &outputs.object.path);
     let header = lager.retrieve(&outputs.header.address, &outputs.header.path);
     match (object, header) {
         (Ok(()), Ok(())) => {
             println!("Cache hits for Halide target {}", outputs.target());
-            Ok(true)
+            Ok(Found::Hit)
         }
-        (Err(lager::Error::NotFound { .. }), Err(lager::Error::NotFound { .. })) => Ok(false),
+        (Err(lager::Error::NotFound { .. }), Err(lager::Error::NotFound { .. })) => Ok(Found::Miss),
         (Err(oe), Err(he)) => Err(anyhow::anyhow!(oe).context(he)),
         (Ok(()), Err(e)) => Err(anyhow::anyhow!(e).context("Retrieving the object was successful")),
         (Err(e), Ok(())) => Err(anyhow::anyhow!(e).context("Retrieving the header was successful")),