More FilePath naming alignment

Author: lionel-

crates/ark/src/console/console_annotate.rs

@@ -933,14 +933,14 @@ pub unsafe extern "C-unwind" fn ps_annotate_source(
     // R source references may flow back to the frontend, which expects its
     // own URI representation.
     let uri = Url::parse(&uri)?;
-    let uri_id = FilePath::from_url(&uri);
+    let path = FilePath::from_url(&uri);
 
     let mut dap_guard = Console::get().debug_dap.lock().unwrap();
 
     // If there are no breakpoints for this file, return NULL to signal no
     // annotation needed. Scope the mutable borrow so we can re-borrow after.
     let annotated = {
-        let Some(entry) = dap_guard.breakpoints.get_mut(&uri_id) else {
+        let Some(entry) = dap_guard.breakpoints.get_mut(&path) else {
             return Ok(harp::r_null());
         };
         let breakpoints = &mut entry.breakpoints;
@@ -956,12 +956,12 @@ pub unsafe extern "C-unwind" fn ps_annotate_source(
     };
 
     // Notify frontend about any breakpoints marked invalid during annotation
-    dap_guard.notify_invalid_breakpoints(&uri_id);
+    dap_guard.notify_invalid_breakpoints(&path);
 
     // Remove disabled breakpoints. Their verification state is now stale since
     // they weren't injected during this annotation. If the user re-enables
     // them, they'll be treated as new unverified breakpoints.
-    if let Some(entry) = dap_guard.breakpoints.get_mut(&uri_id) {
+    if let Some(entry) = dap_guard.breakpoints.get_mut(&path) {
         entry
             .breakpoints
             .retain(|bp| !matches!(bp.state, BreakpointState::Disabled));

crates/ark/src/console/console_repl.rs

@@ -1513,27 +1513,27 @@ impl Console {
                 // Keep the DAP lock while we are updating breakpoints
                 let mut dap_guard = self.debug_dap.lock().unwrap();
 
-                let uri_id = loc.as_ref().map(crate::url::file_path_from_code_location);
+                let path = loc.as_ref().map(crate::url::file_path_from_code_location);
 
                 // For notebook cells (`cellId` present in metadata), synthesize
                 // a `CodeLocation` pointing to the temp file that `dumpCell`
                 // wrote. This gives `annotate_input()` the file URI it needs
                 // for the `#line` directive and breakpoint injection.
-                let (uri_id, loc) = if cell_id.is_some() {
+                let (path, loc) = if cell_id.is_some() {
                     match dap_notebook::notebook_code_location(&code) {
                         Some(notebook_loc) => {
                             let id = FilePath::from_url(&notebook_loc.uri);
                             (Some(id), Some(notebook_loc))
                         },
-                        None => (uri_id, loc),
+                        None => (path, loc),
                     }
                 } else {
-                    (uri_id, loc)
+                    (path, loc)
                 };
 
-                let breakpoints = uri_id
+                let breakpoints = path
                     .as_ref()
-                    .and_then(|uri_id| dap_guard.breakpoints.get_mut(uri_id))
+                    .and_then(|path| dap_guard.breakpoints.get_mut(path))
                     .map(|entry| entry.breakpoints.as_mut_slice());
 
                 match PendingInputs::read(&code, loc, breakpoints) {
@@ -1552,9 +1552,9 @@ impl Console {
 
                 // Notify frontend about any breakpoints marked invalid during annotation.
                 // Remove disabled breakpoints.
-                if let Some(uri_id) = &uri_id {
-                    dap_guard.notify_invalid_breakpoints(uri_id);
-                    dap_guard.remove_disabled_breakpoints(uri_id);
+                if let Some(path) = &path {
+                    dap_guard.notify_invalid_breakpoints(path);
+                    dap_guard.remove_disabled_breakpoints(path);
                 }
 
                 drop(dap_guard);

crates/ark/src/dap/dap_state.rs

@@ -962,7 +962,7 @@ mod tests {
 
     use super::*;
 
-    fn url_id(s: &str) -> FilePath {
+    fn file_path(s: &str) -> FilePath {
         FilePath::from_url(&Url::parse(s).unwrap())
     }
 
@@ -997,7 +997,7 @@ mod tests {
     fn test_did_change_document_removes_breakpoints() {
         let (mut dap, rx) = create_test_dap();
 
-        let uri = url_id("file:///test.R");
+        let uri = file_path("file:///test.R");
         let hash = blake3::hash(b"test content");
 
         dap.breakpoints.insert(uri.clone(), BreakpointEntry {
@@ -1034,7 +1034,7 @@ mod tests {
     fn test_did_change_document_no_breakpoints_is_noop() {
         let (mut dap, rx) = create_test_dap();
 
-        let uri = url_id("file:///test.R");
+        let uri = file_path("file:///test.R");
 
         dap.did_change_document(&uri);
 
@@ -1045,8 +1045,8 @@ mod tests {
     fn test_did_change_document_only_affects_target_uri() {
         let (mut dap, rx) = create_test_dap();
 
-        let uri1 = url_id("file:///test1.R");
-        let uri2 = url_id("file:///test2.R");
+        let uri1 = file_path("file:///test1.R");
+        let uri2 = file_path("file:///test2.R");
         let hash1 = blake3::hash(b"content 1");
         let hash2 = blake3::hash(b"content 2");
 
@@ -1099,7 +1099,7 @@ mod tests {
             shared_self: None,
         };
 
-        let uri = url_id("file:///test.R");
+        let uri = file_path("file:///test.R");
         let hash = blake3::hash(b"test content");
 
         dap.breakpoints.insert(uri.clone(), BreakpointEntry {

crates/ark/src/lsp/state_handlers.rs

@@ -274,8 +274,8 @@ pub(crate) fn did_open(
     lsp_state.parsers.insert(uri.clone(), parser);
     state.documents.insert(uri.clone(), document.clone());
 
-    let url_id = FilePath::from_url(&uri);
-    state.db.upsert_editor(url_id, contents.to_string());
+    let path = FilePath::from_url(&uri);
+    state.db.upsert_editor(path, contents.to_string());
 
     // NOTE: Do we need to call `update_config()` here?
     // update_config(vec![uri]).await;
@@ -302,8 +302,8 @@ pub(crate) fn did_change(
     document.on_did_change(parser, &params);
 
     let new_contents = document.contents.to_string();
-    let url_id = FilePath::from_url(uri);
-    state.db.upsert_editor(url_id, new_contents);
+    let path = FilePath::from_url(uri);
+    state.db.upsert_editor(path, new_contents);
 
     lsp::main_loop::index_update(vec![uri.clone()], state.clone());
 
@@ -339,8 +339,8 @@ pub(crate) fn did_close(
         .remove(&uri)
         .ok_or(anyhow!("Failed to remove parser for URI: {uri}"))?;
 
-    let url_id = FilePath::from_url(&uri);
-    state.db.close_editor(&url_id);
+    let path = FilePath::from_url(&uri);
+    state.db.close_editor(&path);
 
     lsp::log_info!("did_close(): closed document with URI: '{uri}'.");
 

crates/ark/src/lsp/tests/state_handlers.rs

@@ -252,8 +252,8 @@ fn test_r_file_created_routes_through_add_file() {
 
     let root = state.db.workspace_roots().roots(&state.db)[0];
     assert_eq!(root.scripts(&state.db).len(), 1);
-    let url = FilePath::from_path_buf(path.clone()).unwrap();
-    let file = state.db.file_by_path(&url).unwrap();
+    let file_path = FilePath::from_path_buf(path.clone()).unwrap();
+    let file = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file.contents(&state.db), "x <- 1\n");
 }
 
@@ -272,10 +272,10 @@ fn test_r_file_changed_for_editor_open_file_is_skipped() {
         .documents
         .insert(url.clone(), Document::new("editor_v2\n", None));
     // Pretend the editor pushed its content into oak too.
-    let url_id = FilePath::from_url(&url);
+    let file_path = FilePath::from_url(&url);
     state
         .db
-        .upsert_editor(url_id.clone(), "editor_v2\n".to_string());
+        .upsert_editor(file_path.clone(), "editor_v2\n".to_string());
 
     // Now disk-side `Changed` fires with stale disk content.
     fs::write(&path, "disk_v3\n").unwrap();
@@ -284,7 +284,7 @@ fn test_r_file_changed_for_editor_open_file_is_skipped() {
     };
     did_change_watched_files(params, &mut state).unwrap();
 
-    let file = state.db.file_by_path(&url_id).unwrap();
+    let file = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file.contents(&state.db), "editor_v2\n");
 }
 
@@ -296,15 +296,15 @@ fn test_r_file_deleted_routes_through_remove_file() {
     let mut state = workspace_state(tmp.path());
 
     let path = tmp.path().join("a.R");
-    let url_id = FilePath::from_path_buf(path.clone()).unwrap();
+    let file_path = FilePath::from_path_buf(path.clone()).unwrap();
     let params = DidChangeWatchedFilesParams {
         changes: vec![event(&path, FileChangeType::DELETED)],
     };
     did_change_watched_files(params, &mut state).unwrap();
 
     let root = state.db.workspace_roots().roots(&state.db)[0];
     assert_eq!(root.scripts(&state.db).len(), 1);
-    assert!(state.db.file_by_path(&url_id).is_none());
+    assert!(state.db.file_by_path(&file_path).is_none());
 }
 
 #[test]
@@ -317,9 +317,13 @@ fn test_r_file_changed_for_unopened_file_updates_contents() {
     fs::write(&path, "v1\n").unwrap();
     let mut state = workspace_state(tmp.path());
 
-    let url_id = FilePath::from_path_buf(path.clone()).unwrap();
+    let file_path = FilePath::from_path_buf(path.clone()).unwrap();
     assert_eq!(
-        state.db.file_by_path(&url_id).unwrap().contents(&state.db),
+        state
+            .db
+            .file_by_path(&file_path)
+            .unwrap()
+            .contents(&state.db),
         "v1\n"
     );
 
@@ -330,7 +334,11 @@ fn test_r_file_changed_for_unopened_file_updates_contents() {
     did_change_watched_files(params, &mut state).unwrap();
 
     assert_eq!(
-        state.db.file_by_path(&url_id).unwrap().contents(&state.db),
+        state
+            .db
+            .file_by_path(&file_path)
+            .unwrap()
+            .contents(&state.db),
         "v2\n"
     );
 }
@@ -352,18 +360,18 @@ fn test_r_file_deleted_for_editor_open_file_is_skipped() {
     state
         .documents
         .insert(url.clone(), Document::new("editor_v2\n", None));
-    let url_id = FilePath::from_url(&url);
+    let file_path = FilePath::from_url(&url);
     state
         .db
-        .upsert_editor(url_id.clone(), "editor_v2\n".to_string());
+        .upsert_editor(file_path.clone(), "editor_v2\n".to_string());
 
     fs::remove_file(&path).unwrap();
     let params = DidChangeWatchedFilesParams {
         changes: vec![event(&path, FileChangeType::DELETED)],
     };
     did_change_watched_files(params, &mut state).unwrap();
 
-    let file = state.db.file_by_path(&url_id).unwrap();
+    let file = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file.contents(&state.db), "editor_v2\n");
 }
 
@@ -393,8 +401,8 @@ fn test_description_deleted_demotes_package_to_scripts() {
     assert!(root.packages(&state.db).is_empty());
     assert_eq!(root.scripts(&state.db).len(), 1);
 
-    let a_url = FilePath::from_path_buf(tmp.path().join("pkg/R/a.R")).unwrap();
-    let file = state.db.file_by_path(&a_url).unwrap();
+    let file_path = FilePath::from_path_buf(tmp.path().join("pkg/R/a.R")).unwrap();
+    let file = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file.package(&state.db), None);
 }
 
@@ -568,23 +576,23 @@ fn test_did_change_workspace_folders_preserves_open_buffer_across_churn() {
     // Simulate `didOpen` on the package file with editor-side content.
     let r_path = tmp.path().join("pkg/R/a.R");
     let url = Url::from_file_path(&r_path).unwrap();
-    let url_id = FilePath::from_url(&url);
+    let file_path = FilePath::from_url(&url);
     state
         .documents
         .insert(url.clone(), Document::new("editor <- 2\n", None));
     state
         .db
-        .upsert_editor(url_id.clone(), "editor <- 2\n".to_string());
+        .upsert_editor(file_path.clone(), "editor <- 2\n".to_string());
 
-    let file_before = state.db.file_by_path(&url_id).unwrap();
+    let file_before = state.db.file_by_path(&file_path).unwrap();
 
     // Remove the workspace folder. The handler builds the editor_owned set
     // from state.documents.keys() and passes it to oak; the buffer's file
     // routes to OrphanRoot rather than StaleRoot.
     let params = folders_change(vec![], vec![folder_for(tmp.path())]);
     did_change_workspace_folders(params, &mut state).unwrap();
 
-    let after_remove = state.db.file_by_path(&url_id).unwrap();
+    let after_remove = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file_before, after_remove);
     assert_eq!(after_remove.package(&state.db), None);
     assert!(state
@@ -600,7 +608,7 @@ fn test_did_change_workspace_folders_preserves_open_buffer_across_churn() {
     let params = folders_change(vec![folder_for(tmp.path())], vec![]);
     did_change_workspace_folders(params, &mut state).unwrap();
 
-    let after_readd = state.db.file_by_path(&url_id).unwrap();
+    let after_readd = state.db.file_by_path(&file_path).unwrap();
     assert_eq!(file_before, after_readd);
     assert!(after_readd.package(&state.db).is_some());
     assert_eq!(after_readd.contents(&state.db), "editor <- 2\n");
@@ -625,7 +633,7 @@ fn test_did_close_releases_orphan_file_to_stale() {
 
     let r_path = tmp.path().join("pkg/R/a.R");
     let url = Url::from_file_path(&r_path).unwrap();
-    let url_id = FilePath::from_url(&url);
+    let file_path = FilePath::from_url(&url);
 
     // Simulate `didOpen` via state mutation (matches the rest of the file's
     // pattern).
@@ -637,15 +645,15 @@ fn test_did_close_releases_orphan_file_to_stale() {
         .insert(url.clone(), tree_sitter::Parser::new());
     state
         .db
-        .upsert_editor(url_id.clone(), "edited\n".to_string());
+        .upsert_editor(file_path.clone(), "edited\n".to_string());
 
     // Remove the workspace folder; file goes to orphan (editor-owned).
     did_change_workspace_folders(
         folders_change(vec![], vec![folder_for(tmp.path())]),
         &mut state,
     )
     .unwrap();
-    let file = state.db.file_by_path(&url_id).unwrap();
+    let file = state.db.file_by_path(&file_path).unwrap();
     assert!(state.db.orphan_root().files(&state.db).contains(&file));
 
     // Init the aux channel here, after the workspace-folders churn: the

crates/ark_test/src/dummy_frontend.rs

@@ -1834,8 +1834,8 @@ impl SourceFile {
         // symlinks (e.g. macOS `/var/...` -> `/private/var/...`). To match that
         // in tests, we also canonicalize here.
         let canonical = file.path().canonicalize().unwrap();
-        let url = FilePath::from_path_buf(canonical.clone()).unwrap();
-        let uri_id = url.to_string();
+        let file_path = FilePath::from_path_buf(canonical.clone()).unwrap();
+        let uri_id = file_path.to_string();
 
         // Extract file name
         let filename = file

crates/oak_db/src/db.rs

@@ -42,17 +42,17 @@ pub trait DbInputs: salsa::Database {
 /// so salsa records dep edges through those.
 ///
 /// Each concrete db type provides its own forwarding `impl Db`, which is
-/// what lets `db.file_by_path(url)` work on both `&dyn Db` (via the trait
+/// what lets `db.file_by_path(path)` work on both `&dyn Db` (via the trait
 /// method) and concrete db references (via the type's impl).
 #[salsa::db]
 pub trait Db: DbInputs {
-    /// Look up the `File` interned at `url`, if any.
+    /// Look up the `File` interned at `path`, if any.
     ///
     /// Walks the per-root URL indices in workspace-then-library order,
     /// then falls back to the orphan bucket. The walk short-circuits
     /// on the first hit, so callers depend only on the index maps
     /// actually visited.
-    fn file_by_path(&self, url: &FilePath) -> Option<File>;
+    fn file_by_path(&self, path: &FilePath) -> Option<File>;
 
     /// Look up the `Package` named `name`, applying the following precedence:
     /// - Workspace packages shadow installed ones
@@ -108,13 +108,13 @@ pub(crate) fn live_roots_query(db: &dyn Db) -> Vec<LiveRoot> {
 /// entity), but every step is: each [`root_path_index`] call returns a
 /// cached map, so adding a file to one root invalidates only that
 /// root's index.
-pub(crate) fn file_by_path_query(db: &dyn Db, url: &FilePath) -> Option<File> {
+pub(crate) fn file_by_path_query(db: &dyn Db, path: &FilePath) -> Option<File> {
     for &root in db.live_roots() {
         let hit = match root {
             LiveRoot::Workspace(r) | LiveRoot::Library(r) => {
-                root_path_index(db, r).get(url).copied()
+                root_path_index(db, r).get(path).copied()
             },
-            LiveRoot::Orphan(_) => orphan_path_index(db).get(url).copied(),
+            LiveRoot::Orphan(_) => orphan_path_index(db).get(path).copied(),
         };
         if hit.is_some() {
             return hit;