fix: foo

Author: sapphi-red

src/cache/cache_impl.rs

@@ -234,51 +234,54 @@ impl<Fs: FileSystem> Cache<Fs> {
             return Err(io::Error::new(io::ErrorKind::NotFound, "Circular symlink").into());
         }
 
-        if let Some(res) = path.canonicalized.get().map(|res| {
-            res.as_ref().map_err(Clone::clone).and_then(|weak| {
-                weak.upgrade().map(CachedPath).ok_or_else(|| {
-                    ResolveError::from(io::Error::other("Canonicalized path was dropped"))
-                })
-            })
-        }) {
-            return res;
-        }
-
-        path.canonicalizing.store(tid, Ordering::Release);
-        let res = path.parent().map_or_else(
-            || Ok(path.normalize_root(self)),
-            |parent| {
-                self.canonicalize_impl(&parent).and_then(|parent_canonical| {
-                    let normalized = parent_canonical
-                        .normalize_with(path.path().strip_prefix(parent.path()).unwrap(), self);
+        #[expect(clippy::collection_is_never_read)]
+        let mut _temp = None;
 
-                    if self.fs.symlink_metadata(path.path()).is_ok_and(|m| m.is_symlink) {
-                        let link = self.fs.read_link(normalized.path())?;
-                        if link.is_absolute() {
-                            return self.canonicalize_impl(&self.value(&link.normalize()));
-                        } else if let Some(dir) = normalized.parent() {
-                            // Symlink is relative `../../foo.js`, use the path directory
-                            // to resolve this symlink.
-                            return self.canonicalize_impl(&dir.normalize_with(&link, self));
-                        }
-                        debug_assert!(
-                            false,
-                            "Failed to get path parent for {}.",
-                            normalized.path().display()
-                        );
-                    }
+        path.canonicalized
+            .get_or_init(|| {
+                path.canonicalizing.store(tid, Ordering::Release);
 
-                    Ok(normalized)
-                })
-            },
-        );
+                let res = path.parent().map_or_else(
+                    || Ok(path.normalize_root(self)),
+                    |parent| {
+                        self.canonicalize_impl(&parent).and_then(|parent_canonical| {
+                            let normalized = parent_canonical.normalize_with(
+                                path.path().strip_prefix(parent.path()).unwrap(),
+                                self,
+                            );
 
-        path.canonicalizing.store(0, Ordering::Release);
+                            if self.fs.symlink_metadata(path.path()).is_ok_and(|m| m.is_symlink) {
+                                let link = self.fs.read_link(normalized.path())?;
+                                if link.is_absolute() {
+                                    return self.canonicalize_impl(&self.value(&link.normalize()));
+                                } else if let Some(dir) = normalized.parent() {
+                                    // Symlink is relative `../../foo.js`, use the path directory
+                                    // to resolve this symlink.
+                                    return self
+                                        .canonicalize_impl(&dir.normalize_with(&link, self));
+                                }
+                                debug_assert!(
+                                    false,
+                                    "Failed to get path parent for {}.",
+                                    normalized.path().display()
+                                );
+                            }
 
-        // Convert to Weak reference for storage
-        let weak_res = res.as_ref().map_err(Clone::clone).map(|cp| Arc::downgrade(&cp.0));
-        path.canonicalized.set(weak_res).expect("checked by path.canonicalizing");
+                            Ok(normalized)
+                        })
+                    },
+                );
 
-        res
+                path.canonicalizing.store(0, Ordering::Release);
+                _temp = res.as_ref().ok().map(|cp| Arc::clone(&cp.0));
+                res.map(|cp| Arc::downgrade(&cp.0))
+            })
+            .as_ref()
+            .map_err(Clone::clone)
+            .and_then(|weak| {
+                weak.upgrade().map(CachedPath).ok_or_else(|| {
+                    ResolveError::from(io::Error::other("Canonicalized path was dropped"))
+                })
+            })
     }
 }