Add as_path() method on FilePath

Author: lionel-

crates/aether_path/src/file_path.rs

@@ -89,6 +89,11 @@ impl FilePath {
         }
     }
 
+    /// Borrow the filesystem path for the `File` arm. `None` for `Virtual`.
+    pub fn as_path(&self) -> Option<&Utf8Path> {
+        self.as_file().map(AbsPathBuf::as_path)
+    }
+
     /// Borrow the inner [`VirtualUri`] for the `Virtual` arm.
     pub fn as_virtual(&self) -> Option<&VirtualUri> {
         match self {
@@ -102,8 +107,7 @@ impl std::fmt::Display for FilePath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // `File` arms format as a `file:` URL so the output matches
         // what we'd send on the wire, not as a bare path. The path
-        // form is reachable via `as_file().map(|p| p.as_path())` for
-        // callers that want it.
+        // form is reachable via `as_path()` for callers that want it.
         match self {
             Self::File(p) => p.to_url().fmt(f),
             Self::Virtual(u) => u.fmt(f),

crates/ark/src/dap/dap_state.rs

@@ -316,7 +316,7 @@ impl BreakpointMap {
 /// Returns `None` for non-`file:` URLs (`ark://`, `untitled:`, ...), when
 /// the file isn't on disk, and (rare) when the canonical path isn't UTF-8.
 fn canonical_path(path: &FilePath) -> Option<Utf8PathBuf> {
-    let canonical = std::fs::canonicalize(path.as_file()?.as_path()).ok()?;
+    let canonical = std::fs::canonicalize(path.as_path()?).ok()?;
     Utf8PathBuf::from_path_buf(canonical).ok()
 }
 
@@ -1136,7 +1136,7 @@ mod tests {
 
         // Rebuilding the path from the key would hand the frontend different
         // bytes, since the key dropped the `..`.
-        assert_ne!(path.as_file().unwrap().as_path().as_str(), sent);
+        assert_ne!(path.as_path().unwrap().as_str(), sent);
     }
 
     #[test]

crates/oak_db/src/file.rs

@@ -172,12 +172,12 @@ impl File {
 /// [`File::root`] (for files without a registered package).
 fn root_by_path(db: &dyn Db, path: &FilePath) -> Option<Root> {
     // Virtual documents (e.g. untitled scheme) don't have roots
-    let path = path.as_file()?.as_path();
+    let path = path.as_path()?;
     db.workspace_roots()
         .roots(db)
         .iter()
         .filter_map(|root| {
-            let root_path = root.path(db).as_file()?.as_path();
+            let root_path = root.path(db).as_path()?;
             path.starts_with(root_path).then_some((root_path, *root))
         })
         .max_by_key(|(root_path, _)| root_path.components().count())

crates/oak_db/src/imports.rs

@@ -85,10 +85,10 @@ fn anchor_dir(db: &dyn Db, calling_file: File) -> Option<Utf8PathBuf> {
         .filter(|r| r.kind(db) == RootKind::Workspace)
     {
         // Workspace roots are file URLs by construction.
-        return root.path(db).as_file().map(|f| f.as_path().to_path_buf());
+        return root.path(db).as_path().map(Utf8Path::to_path_buf);
     }
 
-    let parent = calling_file.path(db).as_file()?.as_path().parent()?;
+    let parent = calling_file.path(db).as_path()?.parent()?;
     Some(parent.to_path_buf())
 }
 

crates/oak_scan/src/scheduler.rs

@@ -55,6 +55,7 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 
 use aether_path::FilePath;
+use camino::Utf8Path;
 use camino::Utf8PathBuf;
 use oak_db::Db;
 use oak_db::DbInputs;
@@ -191,7 +192,7 @@ impl ScanScheduler {
             .iter()
             .filter_map(|path| {
                 let path = FilePath::from_path_buf(path.clone())?;
-                let scan_path = path.as_file()?.as_path().to_path_buf();
+                let scan_path = path.as_path()?.to_path_buf();
                 Some((scan_path, path))
             })
             .collect();
@@ -264,7 +265,7 @@ impl ScanScheduler {
         // instead of applying surgically against a transient world.
         let mut description_roots: HashSet<Root> = HashSet::new();
         for event in &events {
-            let Some(path) = event.path.as_file().map(|f| f.as_path().to_path_buf()) else {
+            let Some(path) = event.path.as_path().map(Utf8Path::to_path_buf) else {
                 continue;
             };
             if path.file_name().is_some_and(|name| name == "DESCRIPTION") {
@@ -285,7 +286,7 @@ impl ScanScheduler {
 
         // Pass 2: R-file events.
         for event in events {
-            let Some(path) = event.path.as_file().map(|f| f.as_path().to_path_buf()) else {
+            let Some(path) = event.path.as_path().map(Utf8Path::to_path_buf) else {
                 continue;
             };
             if path.file_name().is_some_and(|name| name == "DESCRIPTION") {
@@ -364,7 +365,7 @@ impl ScanScheduler {
                 // would stay pending forever. On success the buffer rides along
                 // and replays when the requeued scan finishes. On failure we
                 // fall back to the idle drain.
-                let scan_path = root.path(db).as_file().map(|f| f.as_path().to_path_buf());
+                let scan_path = root.path(db).as_path().map(Utf8Path::to_path_buf);
                 match scan_path {
                     Some(path) => {
                         self.state.insert(root, ScanState::Scanning);
@@ -417,11 +418,11 @@ impl ScanScheduler {
             },
             Some(ScanState::ScanningWithRescanQueued) => None,
             None => {
-                let Some(abs) = root.path(db).as_file() else {
+                let Some(path) = root.path(db).as_path() else {
                     log::warn!("Skipping rescan: root path is not a filesystem path");
                     return None;
                 };
-                let path = abs.as_path().to_path_buf();
+                let path = path.to_path_buf();
                 self.state.insert(root, ScanState::Scanning);
                 Some(ScanRequest { root, path })
             },
@@ -455,11 +456,11 @@ fn workspace_root_paths<DB: Db + DbInputs>(db: &DB) -> Vec<(Utf8PathBuf, Root)>
         .roots(db)
         .iter()
         .filter_map(|root| {
-            let Some(abs) = root.path(db).as_file() else {
+            let Some(path) = root.path(db).as_path() else {
                 log::warn!("Skipping workspace root: path is not a filesystem path");
                 return None;
             };
-            Some((abs.as_path().to_path_buf(), *root))
+            Some((path.to_path_buf(), *root))
         })
         .collect()
 }

crates/oak_scan/src/tests/scheduler.rs

@@ -266,12 +266,7 @@ fn test_set_workspace_paths_inserts_empty_root_immediately() {
     // `FilePath` construction is lexical, so the stored path is the one
     // we handed in, byte for byte.
     assert_eq!(
-        roots[0]
-            .path(&db)
-            .as_file()
-            .unwrap()
-            .as_path()
-            .as_std_path(),
+        roots[0].path(&db).as_path().unwrap().as_std_path(),
         tmp.path()
     );
 }

crates/oak_scan/src/tests/watch.rs

@@ -72,7 +72,7 @@ fn remove_watched_file(db: &mut OakDatabase, url: FilePath) {
 /// Sync helper: force a fresh full rescan of `root`. Equivalent to the
 /// production trigger of a DESCRIPTION watcher event hitting the root.
 fn rescan_workspace_root(db: &mut OakDatabase, root: Root) {
-    let path = root.path(db).as_file().unwrap().as_path().to_path_buf();
+    let path = root.path(db).as_path().unwrap().to_path_buf();
     let result = ScanRequest { root, path }.run();
     let mut scheduler = ScanScheduler::new();
     let reqs = scheduler.apply_scan_completed(db, result, &HashSet::new());

crates/oak_scan/src/watch.rs

@@ -56,12 +56,12 @@ pub(crate) fn add_watched_file<DB: Db + DbInputs>(db: &mut DB, path: FilePath, c
         return;
     }
 
-    let Some(abs) = path.as_file() else {
+    let Some(fs_path) = path.as_path() else {
         log::warn!("Skipping add_watched_file: URL is not a file path");
         return;
     };
 
-    let Some(placement) = classify(db, abs.as_path()) else {
+    let Some(placement) = classify(db, fs_path) else {
         // Either the URL falls outside every workspace, or it lives
         // inside a package subdir we don't track (tests/, inst/, ...).
         return;
@@ -147,7 +147,7 @@ fn classify<DB: Db + DbInputs>(db: &DB, path: &Utf8Path) -> Option<Placement> {
     }
 
     let root = workspace_root_containing(db, path)?;
-    let root_path = root.path(db).as_file()?.as_path();
+    let root_path = root.path(db).as_path()?;
 
     // Find the nearest ancestor (within `root_path`) that contains a
     // `DESCRIPTION`. None means no package above the file, so it's a
@@ -180,8 +180,8 @@ fn workspace_root_containing<DB: Db + DbInputs>(db: &DB, path: &Utf8Path) -> Opt
     db.workspace_roots()
         .roots(db)
         .iter()
-        .find(|root| match root.path(db).as_file() {
-            Some(root_path) => path.starts_with(root_path.as_path()),
+        .find(|root| match root.path(db).as_path() {
+            Some(root_path) => path.starts_with(root_path),
             None => false,
         })
         .copied()