Last commit before issuing a draft

Author: alibektas

crates/base-db/src/change.rs

@@ -25,7 +25,8 @@ impl fmt::Debug for Change {
             d.field("roots", roots);
         }
         if !self.files_changed.is_empty() {
-            d.field("files_changed", &self.files_changed.len());
+            d.field("files_changed", &self.files_changed);
+            // d.field("files_changed", &self.files_changed.len());
         }
         if self.crate_graph.is_some() {
             d.field("crate_graph", &self.crate_graph);

crates/base-db/src/input.rs

@@ -21,33 +21,36 @@ use vfs::{file_set::FileSet, AbsPathBuf, AnchoredPath, FileId, VfsPath};
 pub type ProcMacroPaths = FxHashMap<CrateId, Result<(Option<String>, AbsPathBuf), String>>;
 pub type ProcMacros = FxHashMap<CrateId, ProcMacroLoadResult>;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct SourceRootId(pub u32);
+
 /// Files are grouped into source roots. A source root is a directory on the
 /// file systems which is watched for changes. Typically it corresponds to a
 /// Rust crate. Source roots *might* be nested: in this case, a file belongs to
 /// the nearest enclosing source root. Paths to files are always relative to a
 /// source root, and the analyzer does not know the root path of the source root at
 /// all. So, a file from one source root can't refer to a file in another source
 /// root by path.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct SourceRootId(pub u32);
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct SourceRoot {
     /// Sysroot or crates.io library.
     ///
     /// Libraries are considered mostly immutable, this assumption is used to
     /// optimize salsa's query structure
     pub is_library: bool,
+    cargo_file_id: Option<FileId>,
+    ratoml_file_id: Option<FileId>,
     file_set: FileSet,
 }
 
 impl SourceRoot {
     pub fn new_local(file_set: FileSet) -> SourceRoot {
-        SourceRoot { is_library: false, file_set }
+        eprintln!("{:#?}", file_set);
+        SourceRoot { is_library: false, file_set, cargo_file_id: None, ratoml_file_id: None }
     }
 
     pub fn new_library(file_set: FileSet) -> SourceRoot {
-        SourceRoot { is_library: true, file_set }
+        SourceRoot { is_library: true, file_set, cargo_file_id: None, ratoml_file_id: None }
     }
 
     pub fn path_for_file(&self, file: &FileId) -> Option<&VfsPath> {
@@ -65,6 +68,16 @@ impl SourceRoot {
     pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
         self.file_set.iter()
     }
+
+    /// Get `FileId` of the `Cargo.toml` if one present in `SourceRoot`
+    pub fn cargo_toml(&self) -> Option<FileId> {
+        self.cargo_file_id
+    }
+
+    /// Get `FileId` of the `rust-analyzer.toml` if one present in `SourceRoot`
+    pub fn ratoml(&self) -> Option<FileId> {
+        self.ratoml_file_id
+    }
 }
 
 /// `CrateGraph` is a bit of information which turns a set of text files into a

crates/load-cargo/src/lib.rs

@@ -208,6 +208,7 @@ impl ProjectFolders {
             let entry = {
                 let mut dirs = vfs::loader::Directories::default();
                 dirs.extensions.push("rs".into());
+                dirs.extensions.push("toml".into());
                 dirs.include.extend(root.include);
                 dirs.exclude.extend(root.exclude);
                 for excl in global_excludes {

crates/rust-analyzer/src/global_state.rs

@@ -330,7 +330,6 @@ impl GlobalState {
             }
             (change, changed_files, workspace_structure_change)
         };
-
         self.analysis_host.apply_change(change);
 
         {

crates/rust-analyzer/src/main_loop.rs

@@ -131,6 +131,7 @@ impl GlobalState {
                 Event::Lsp(lsp_server::Message::Notification(Notification { method, .. }))
                 if method == lsp_types::notification::Exit::METHOD
             ) {
+                dbg!("EXIT");
                 return Ok(());
             }
             self.handle_event(event)?;
@@ -159,6 +160,11 @@ impl GlobalState {
                         scheme: None,
                         pattern: Some("**/Cargo.lock".into()),
                     },
+                    lsp_types::DocumentFilter {
+                        language: None,
+                        scheme: None,
+                        pattern: Some("**/.rust-analyzer.toml".into()),
+                    },
                 ]),
             },
         };

crates/rust-analyzer/src/reload.rs

@@ -172,7 +172,8 @@ impl GlobalState {
             }
         }
 
-        if let Err(_) = self.fetch_workspace_error() {
+        if let Err(k) = self.fetch_workspace_error() {
+            dbg!(&k);
             status.health = lsp_ext::Health::Error;
             message.push_str("Failed to load workspaces.\n\n");
         }
@@ -414,6 +415,8 @@ impl GlobalState {
                                 format!("{it}/**/*.rs"),
                                 format!("{it}/**/Cargo.toml"),
                                 format!("{it}/**/Cargo.lock"),
+                                // FIXME @alibektas : WS may not have to be local for RATOML to be included.
+                                format!("{it}/**/.rust-analyzer.toml"),
                             ]
                         })
                     })
@@ -526,6 +529,7 @@ impl GlobalState {
         change.set_crate_graph(crate_graph);
         self.analysis_host.apply_change(change);
         self.crate_graph_file_dependencies = crate_graph_file_dependencies;
+        eprintln!("Recreate crate graph");
         self.process_changes();
 
         self.reload_flycheck();

crates/rust-analyzer/tests/slow-tests/main.rs

@@ -1131,3 +1131,42 @@ version = "0.0.0"
 
     server.request::<WorkspaceSymbolRequest>(Default::default(), json!([]));
 }
+
+#[test]
+fn test_ratoml_exists() {
+    if skip_slow_tests() {
+        return;
+    }
+
+    let server = Project::with_fixture(
+        r#"
+//- /foo/Cargo.toml
+[package]
+name = "foo"
+version = "0.0.0"
+
+[dependencies]
+bar.path = "./bar"
+
+//- /foo/src/lib.rs
+pub fn foo() {}
+
+//- /foo/src/abc/mod.rs
+pub fn bar() {}
+
+//- /foo/.rust-analyzer.toml
+ABC
+
+//- /foo/bar/Cargo.toml
+[package]
+name = "bar"
+version = "0.0.0"
+
+//- /foo/bar/src/lib.rs
+pub fn bar() {}
+"#,
+    )
+    .root("foo")
+    .server()
+    .wait_until_workspace_is_loaded();
+}

crates/vfs/src/file_set.rs

@@ -11,7 +11,7 @@ use rustc_hash::FxHashMap;
 use crate::{AnchoredPath, FileId, Vfs, VfsPath};
 
 /// A set of [`VfsPath`]s identified by [`FileId`]s.
-#[derive(Default, Clone, Eq, PartialEq)]
+#[derive(Default, Debug, Clone, Eq, PartialEq)]
 pub struct FileSet {
     files: FxHashMap<VfsPath, FileId>,
     paths: IntMap<FileId, VfsPath>,
@@ -59,11 +59,11 @@ impl FileSet {
     }
 }
 
-impl fmt::Debug for FileSet {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FileSet").field("n_files", &self.files.len()).finish()
-    }
-}
+// impl fmt::Debug for FileSet {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         f.debug_struct("FileSet").field("n_files", &self.files.len()).finish()
+//     }
+// }
 
 /// This contains path prefixes to partition a [`Vfs`] into [`FileSet`]s.
 ///