LSP: Fix VSCode doesn't recognise canonized file paths

Author: VonTum

src/compiler_top.rs

@@ -98,7 +98,9 @@ impl Linker {
             if file_path.is_dir() {
                 self.add_all_files_in_directory_recurse(&file_path);
             } else if file_path.is_file() && file_path.extension() == Some(OsStr::new("sus")) {
-                let file_identifier = UniqueFileID::from_path(&file_path).unwrap();
+                let file_identifier =
+                    UniqueFileID::from_path(&file_path, file_path.to_string_lossy().to_string())
+                        .unwrap();
                 self.add_or_update_file_from_disk(file_identifier);
             }
         }
@@ -108,7 +110,7 @@ impl Linker {
         if path.is_dir() {
             self.add_all_files_in_directory_recurse(path);
         } else {
-            match UniqueFileID::from_path(path) {
+            match UniqueFileID::from_path(path, path.to_string_lossy().to_string()) {
                 Ok(file_identifier) => {
                     self.add_or_update_file_from_disk(file_identifier);
                 }

src/dev_aid/lsp/mod.rs

@@ -86,17 +86,13 @@ fn cvt_location_list_of_lists(
 impl UniqueFileID {
     fn from_uri(uri: &Url) -> Result<UniqueFileID, String> {
         if uri.scheme() == "file" {
-            UniqueFileID::from_path(&uri.to_file_path().unwrap())
+            UniqueFileID::from_path(&uri.to_file_path().unwrap(), uri.to_string())
         } else {
             Ok(UniqueFileID::from_non_path_str(uri.to_string()))
         }
     }
     fn to_uri(&self) -> Url {
-        if self.inode.is_some() {
-            Url::from_file_path(&self.name).expect(&self.name)
-        } else {
-            Url::parse(&self.name).expect(&self.name)
-        }
+        Url::parse(&self.name).expect(&self.name)
     }
 }
 
@@ -218,6 +214,14 @@ fn initialize_all_files(linker: &mut Linker, init_params: &InitializeParams) {
             linker.add_file_or_directory(f);
         }
     }
+
+    // Convert all the Path IDs to URIs
+    for (_, f) in &mut linker.files {
+        f.file_identifier.name =
+            Url::from_file_path(std::fs::canonicalize(&f.file_identifier.name).unwrap())
+                .expect(&f.file_identifier.name)
+                .to_string();
+    }
 }
 
 fn gather_completions(linker: &Linker, position: usize) -> Vec<CompletionItem> {
@@ -562,11 +566,11 @@ fn handle_notification(
                     linker.add_or_update_file_from_disk(file_identifier);
                 } else if event.typ == FileChangeType::DELETED {
                     let uri_as_string = event.uri.to_string();
-                    // Delete URIs that don't have a file backing
-                    if let Some(existing_file_id) = linker.files.find(|_, data| {
-                        data.file_identifier.inode.is_none()
-                            && data.file_identifier.name == uri_as_string
-                    }) {
+                    // Try to delete URIs (including those that that don't have a file backing)
+                    if let Some(existing_file_id) = linker
+                        .files
+                        .find(|_, data| data.file_identifier.name == uri_as_string)
+                    {
                         linker.remove_file(existing_file_id);
                     }
                 } else {
@@ -577,7 +581,7 @@ fn handle_notification(
             let mut to_delete: Vec<FileUUID> = Vec::new();
             for (id, f) in &linker.files {
                 if f.file_identifier.inode.is_some() {
-                    match std::fs::exists(&f.file_identifier.name) {
+                    match std::fs::exists(f.file_identifier.to_uri().path()) {
                         Ok(true) => {}
                         Ok(false) | Err(_) => to_delete.push(id),
                     }

src/linker/mod.rs

@@ -158,26 +158,20 @@ pub struct UniqueFileID {
     pub name: String,
 }
 impl UniqueFileID {
-    pub fn from_path(path: &Path) -> Result<UniqueFileID, String> {
+    pub fn from_path(path: &Path, name: String) -> Result<UniqueFileID, String> {
         if !path.is_file() || path.extension() != Some(OsStr::new("sus")) {
-            return Err(format!("{} is not a .sus file!", path.to_string_lossy()));
+            return Err(format!("{name} is not a .sus file!"));
         }
-        match path.canonicalize() {
-            Ok(absolute_path) => Ok(UniqueFileID {
-                inode: Some(same_file::Handle::from_path(path).unwrap()),
-                name: absolute_path.to_string_lossy().to_string(),
+        match same_file::Handle::from_path(path) {
+            Ok(inode) => Ok(UniqueFileID {
+                inode: Some(inode),
+                name,
             }),
-            Err(err) => Err(format!(
-                "'{}' is not an existing file? {err}",
-                path.to_string_lossy()
-            )),
+            Err(err) => Err(format!("'{name}' is not an existing file? {err}",)),
         }
     }
-    pub fn from_non_path_str(identifier: String) -> UniqueFileID {
-        UniqueFileID {
-            inode: None,
-            name: identifier,
-        }
+    pub fn from_non_path_str(name: String) -> UniqueFileID {
+        UniqueFileID { inode: None, name }
     }
 }
 impl Display for UniqueFileID {