3 files changed, 53 insertions, 9 deletions

diff --git a/crates/vfs/src/anchored_path.rs b/crates/vfs/src/anchored_path.rs
new file mode 100644
index 000000000..02720a32e
--- /dev/null
+++ b/crates/vfs/src/anchored_path.rs
@@ -0,0 +1,39 @@
+//! Analysis-level representation of file-system paths.
+//!
+//! The primary goal of this is to losslessly represent paths like
+//!
+//! ```
+//! #[path = "./bar.rs"]
+//! mod foo;
+//! ```
+//!
+//! The first approach one might reach for is to use `PathBuf`. The problem here
+//! is that `PathBuf` depends on host target (windows or linux), but
+//! rust-analyzer should be capable to process `#[path = r"C:\bar.rs"]` on Unix.
+//!
+//! The second try is to use a `String`. This also fails, however. Consider a
+//! hypothetical scenario, where rust-analyzer operates in a
+//! networked/distributed mode. There's one global instance of rust-analyzer,
+//! which processes requests from different machines. Now, the semantics of
+//! `#[path = "/abs/path.rs"]` actually depends on which file-system we are at!
+//! That is, even absolute paths exist relative to a file system!
+//!
+//! A more realistic scenario here is virtual VFS paths we use for testing. More
+//! generally, there can be separate "universes" of VFS paths.
+//!
+//! That's why we use anchored representation -- each path carries an info about
+//! a file this path originates from. We can fetch fs/"universe" information
+//! from the anchor than.
+use crate::FileId;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct AnchoredPathBuf {
+    pub anchor: FileId,
+    pub path: String,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct AnchoredPath<'a> {
+    pub anchor: FileId,
+    pub path: &'a str,
+}
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index 9093fbd97..49ca593ac 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -7,7 +7,7 @@ use std::fmt;
 use fst::{IntoStreamer, Streamer};
 use rustc_hash::FxHashMap;
 
-use crate::{FileId, Vfs, VfsPath};
+use crate::{AnchoredPath, FileId, Vfs, VfsPath};
 
 #[derive(Default, Clone, Eq, PartialEq)]
 pub struct FileSet {
@@ -19,10 +19,10 @@ impl FileSet {
     pub fn len(&self) -> usize {
         self.files.len()
     }
-    pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
-        let mut base = self.paths[&anchor].clone();
+    pub fn resolve_path(&self, path: AnchoredPath<'_>) -> Option<FileId> {
+        let mut base = self.paths[&path.anchor].clone();
         base.pop();
-        let path = base.join(path)?;
+        let path = base.join(path.path)?;
         self.files.get(&path).copied()
     }
 
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
index cdf6f1fd0..9cf2afd33 100644
--- a/crates/vfs/src/lib.rs
+++ b/crates/vfs/src/lib.rs
@@ -36,6 +36,7 @@
 //! have a single `FileSet` which unions the two sources.
 mod vfs_path;
 mod path_interner;
+mod anchored_path;
 pub mod file_set;
 pub mod loader;
 
@@ -43,7 +44,10 @@ use std::{fmt, mem};
 
 use crate::path_interner::PathInterner;
 
-pub use crate::vfs_path::VfsPath;
+pub use crate::{
+    anchored_path::{AnchoredPath, AnchoredPathBuf},
+    vfs_path::VfsPath,
+};
 pub use paths::{AbsPath, AbsPathBuf};
 
 #[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
@@ -99,18 +103,19 @@ impl Vfs {
                 (file_id, path)
             })
     }
-    pub fn set_file_contents(&mut self, path: VfsPath, contents: Option<Vec<u8>>) {
+    pub fn set_file_contents(&mut self, path: VfsPath, contents: Option<Vec<u8>>) -> bool {
         let file_id = self.alloc_file_id(path);
         let change_kind = match (&self.get(file_id), &contents) {
-            (None, None) => return,
+            (None, None) => return false,
             (None, Some(_)) => ChangeKind::Create,
             (Some(_), None) => ChangeKind::Delete,
-            (Some(old), Some(new)) if old == new => return,
+            (Some(old), Some(new)) if old == new => return false,
             (Some(_), Some(_)) => ChangeKind::Modify,
         };
 
         *self.get_mut(file_id) = contents;
-        self.changes.push(ChangedFile { file_id, change_kind })
+        self.changes.push(ChangedFile { file_id, change_kind });
+        true
     }
     pub fn has_changes(&self) -> bool {
         !self.changes.is_empty()