[autofix.ci] apply automated fixes

Author: autofix-ci[bot]

src/cache/cache_impl.rs

@@ -108,46 +108,42 @@ impl<Fs: FileSystem> Cache<Fs> {
         ctx: &mut Ctx,
     ) -> Result<Option<Arc<PackageJson>>, ResolveError> {
         // Change to `std::sync::OnceLock::get_or_try_init` when it is stable.
-        let index_result = path
-            .package_json
-            .get_or_try_init(|| {
-                let package_json_path = path.path.join("package.json");
-                let Ok(package_json_bytes) = self.fs.read(&package_json_path) else {
-                    return Ok(None);
-                };
+        let index_result = path.package_json.get_or_try_init(|| {
+            let package_json_path = path.path.join("package.json");
+            let Ok(package_json_bytes) = self.fs.read(&package_json_path) else {
+                return Ok(None);
+            };
 
-                let real_path = if options.symlinks {
-                    self.canonicalize(path)?.join("package.json")
-                } else {
-                    package_json_path.clone()
-                };
-                PackageJson::parse(&self.fs, package_json_path, real_path, package_json_bytes)
-                    .map(|package_json| {
-                        let arc = Arc::new(package_json);
-                        // Acquire write lock to push to arena
-                        let mut arena = self.package_json_arena.write();
-                        let index = arena.len();
-                        arena.push(arc);
-                        Some(index)
-                    })
-                    .map_err(ResolveError::Json)
-            });
+            let real_path = if options.symlinks {
+                self.canonicalize(path)?.join("package.json")
+            } else {
+                package_json_path.clone()
+            };
+            PackageJson::parse(&self.fs, package_json_path, real_path, package_json_bytes)
+                .map(|package_json| {
+                    let arc = Arc::new(package_json);
+                    // Acquire write lock to push to arena
+                    let mut arena = self.package_json_arena.write();
+                    let index = arena.len();
+                    arena.push(arc);
+                    Some(index)
+                })
+                .map_err(ResolveError::Json)
+        });
 
         // Lookup the Arc from the arena using the stored index
         let result = index_result.and_then(|index_opt| {
             match index_opt {
                 Some(index) => {
                     // Get the Arc from the arena
                     let arena = self.package_json_arena.read();
-                    arena.get(*index)
-                        .map(|arc| Ok(Some(Arc::clone(arc))))
-                        .unwrap_or_else(|| {
-                            // Index out of bounds (e.g., after cache clear)
-                            // Return None to indicate package.json not found
-                            Ok(None)
-                        })
+                    arena.get(*index).map(|arc| Ok(Some(Arc::clone(arc)))).unwrap_or_else(|| {
+                        // Index out of bounds (e.g., after cache clear)
+                        // Return None to indicate package.json not found
+                        Ok(None)
+                    })
                 }
-                None => Ok(None)
+                None => Ok(None),
             }
         });