style: cargo fmt (fs fast paths, types --install, its test)

Formatting-only: rustfmt the let-chains in system_fs's small-file fast paths
(un-formatted since they were added) and the new install_types/update_tsconfig
code and its test.

Author: Thanga-Ganapathy

crates/default-providers/src/system_fs.rs

@@ -136,11 +136,12 @@ impl FileSystem for SystemFileSystem {
         let resolved = self.jailed(&path);
         if let Ok(p) = &resolved
             && let Ok(md) = std::fs::metadata(p)
-                && md.len() < 64 * 1024 {
-                    return Box::pin(std::future::ready(
-                        std::fs::read(p).map_err(|e| other(&path, e)),
-                    ));
-                }
+            && md.len() < 64 * 1024
+        {
+            return Box::pin(std::future::ready(
+                std::fs::read(p).map_err(|e| other(&path, e)),
+            ));
+        }
         Box::pin(async move {
             let p = resolved?;
             tokio::fs::read(&p).await.map_err(|e| other(&path, e))
@@ -157,24 +158,25 @@ impl FileSystem for SystemFileSystem {
         let len = data.len() as u64;
 
         if let Ok(p) = &resolved
-            && len < 64 * 1024 {
-                let res = (|| -> std::io::Result<()> {
-                    let mut opts = std::fs::OpenOptions::new();
-                    opts.write(true).create(true);
-                    if append {
-                        opts.append(true);
-                    } else {
-                        opts.truncate(true);
-                    }
-                    use std::io::Write;
-                    let mut f = opts.open(p)?;
-                    f.write_all(&data)?;
-                    Ok(())
-                })();
-                return Box::pin(std::future::ready(
-                    res.map(|_| len).map_err(|e| other(&path, e)),
-                ));
-            }
+            && len < 64 * 1024
+        {
+            let res = (|| -> std::io::Result<()> {
+                let mut opts = std::fs::OpenOptions::new();
+                opts.write(true).create(true);
+                if append {
+                    opts.append(true);
+                } else {
+                    opts.truncate(true);
+                }
+                use std::io::Write;
+                let mut f = opts.open(p)?;
+                f.write_all(&data)?;
+                Ok(())
+            })();
+            return Box::pin(std::future::ready(
+                res.map(|_| len).map_err(|e| other(&path, e)),
+            ));
+        }
         Box::pin(async move {
             let p = resolved?;
             let mut opts = tokio::fs::OpenOptions::new();
@@ -193,18 +195,19 @@ impl FileSystem for SystemFileSystem {
     fn stat(&self, path: String) -> BoxFuture<Result<FileStat, ProviderError>> {
         let resolved = self.jailed(&path);
         if let Ok(p) = &resolved
-            && let Ok(md) = std::fs::metadata(p) {
-                let is_symlink = std::fs::symlink_metadata(p)
-                    .map(|m| m.file_type().is_symlink())
-                    .unwrap_or(false);
-                return Box::pin(std::future::ready(Ok(FileStat {
-                    size: md.len(),
-                    is_file: md.is_file(),
-                    is_dir: md.is_dir(),
-                    is_symlink,
-                    mtime_ms: mtime_ms(&md),
-                })));
-            }
+            && let Ok(md) = std::fs::metadata(p)
+        {
+            let is_symlink = std::fs::symlink_metadata(p)
+                .map(|m| m.file_type().is_symlink())
+                .unwrap_or(false);
+            return Box::pin(std::future::ready(Ok(FileStat {
+                size: md.len(),
+                is_file: md.is_file(),
+                is_dir: md.is_dir(),
+                is_symlink,
+                mtime_ms: mtime_ms(&md),
+            })));
+        }
         Box::pin(async move {
             let p = resolved?;
             let md = tokio::fs::metadata(&p).await.map_err(|e| other(&path, e))?;

crates/runtime-cli/src/main.rs

@@ -172,15 +172,17 @@ fn update_tsconfig() -> Result<String, Box<dyn std::error::Error>> {
             "tsconfig.json is not a JSON object — left it untouched.\n{manual}"
         ));
     };
-    let co = obj
-        .entry("compilerOptions")
-        .or_insert_with(|| json!({}));
+    let co = obj.entry("compilerOptions").or_insert_with(|| json!({}));
     let Some(co) = co.as_object_mut() else {
         return Ok(format!(
             "tsconfig.json compilerOptions is not an object — left it untouched.\n{manual}"
         ));
     };
-    merge_str_array(co, "typeRoots", &["node_modules/@types", "node_modules/@opentf"]);
+    merge_str_array(
+        co,
+        "typeRoots",
+        &["node_modules/@types", "node_modules/@opentf"],
+    );
     merge_str_array(co, "types", &["esrun"]);
     fs::write(path, format!("{}\n", serde_json::to_string_pretty(&cfg)?))?;
     Ok("Updated tsconfig.json (typeRoots + types).".into())

crates/runtime-cli/tests/modules.rs

@@ -432,11 +432,18 @@ fn types_install_writes_package_and_wires_tsconfig() {
     let dts = dir.join("node_modules/@opentf/esrun/index.d.ts");
     assert!(dts.exists(), "index.d.ts not written");
     assert!(dir.join("node_modules/@opentf/esrun/package.json").exists());
-    assert!(std::fs::read_to_string(&dts).unwrap().contains("declare module \"runtime:fs\""));
+    assert!(
+        std::fs::read_to_string(&dts)
+            .unwrap()
+            .contains("declare module \"runtime:fs\"")
+    );
 
     // tsconfig.json is created and wired up (typeRoots + types).
     let ts = std::fs::read_to_string(dir.join("tsconfig.json")).unwrap();
-    assert!(ts.contains("node_modules/@opentf"), "typeRoots missing:\n{ts}");
+    assert!(
+        ts.contains("node_modules/@opentf"),
+        "typeRoots missing:\n{ts}"
+    );
     assert!(ts.contains("\"esrun\""), "types entry missing:\n{ts}");
 
     // Re-running is idempotent — `esrun` isn't duplicated in `types`.
@@ -448,7 +455,11 @@ fn types_install_writes_package_and_wires_tsconfig() {
         .expect("spawn esrun");
     assert!(out2.status.success());
     let ts2 = std::fs::read_to_string(dir.join("tsconfig.json")).unwrap();
-    assert_eq!(ts2.matches("\"esrun\"").count(), 1, "esrun duplicated:\n{ts2}");
+    assert_eq!(
+        ts2.matches("\"esrun\"").count(),
+        1,
+        "esrun duplicated:\n{ts2}"
+    );
 
     let _ = std::fs::remove_dir_all(&dir);
 }