Merge #765

765: Jettison `imp` module r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

crates/ra_ide_api/src/call_info.rs

@@ -20,7 +20,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     let name_ref = calling_node.name_ref()?;
 
     // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
-    let file_symbols = db.index_resolve(name_ref);
+    let file_symbols = crate::symbol_index::index_resolve(db, name_ref);
     let symbol = file_symbols
         .into_iter()
         .find(|it| it.ptr.kind() == FN_DEF)?;

crates/ra_ide_api/src/change.rs

@@ -0,0 +1,255 @@
+use std::{
+    fmt, time,
+    sync::Arc,
+};
+
+use rustc_hash::FxHashMap;
+use ra_db::{
+    SourceRootId, FileId, CrateGraph, SourceDatabase, SourceRoot,
+    salsa::{Database, SweepStrategy},
+};
+use ra_syntax::SourceFile;
+use relative_path::RelativePathBuf;
+use rayon::prelude::*;
+
+use crate::{
+    db::RootDatabase,
+    symbol_index::{SymbolIndex, SymbolsDatabase},
+    status::syntax_tree_stats,
+};
+
+#[derive(Default)]
+pub struct AnalysisChange {
+    new_roots: Vec<(SourceRootId, bool)>,
+    roots_changed: FxHashMap<SourceRootId, RootChange>,
+    files_changed: Vec<(FileId, Arc<String>)>,
+    libraries_added: Vec<LibraryData>,
+    crate_graph: Option<CrateGraph>,
+}
+
+impl fmt::Debug for AnalysisChange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let mut d = fmt.debug_struct("AnalysisChange");
+        if !self.new_roots.is_empty() {
+            d.field("new_roots", &self.new_roots);
+        }
+        if !self.roots_changed.is_empty() {
+            d.field("roots_changed", &self.roots_changed);
+        }
+        if !self.files_changed.is_empty() {
+            d.field("files_changed", &self.files_changed.len());
+        }
+        if !self.libraries_added.is_empty() {
+            d.field("libraries_added", &self.libraries_added.len());
+        }
+        if !self.crate_graph.is_some() {
+            d.field("crate_graph", &self.crate_graph);
+        }
+        d.finish()
+    }
+}
+
+impl AnalysisChange {
+    pub fn new() -> AnalysisChange {
+        AnalysisChange::default()
+    }
+
+    pub fn add_root(&mut self, root_id: SourceRootId, is_local: bool) {
+        self.new_roots.push((root_id, is_local));
+    }
+
+    pub fn add_file(
+        &mut self,
+        root_id: SourceRootId,
+        file_id: FileId,
+        path: RelativePathBuf,
+        text: Arc<String>,
+    ) {
+        let file = AddFile {
+            file_id,
+            path,
+            text,
+        };
+        self.roots_changed
+            .entry(root_id)
+            .or_default()
+            .added
+            .push(file);
+    }
+
+    pub fn change_file(&mut self, file_id: FileId, new_text: Arc<String>) {
+        self.files_changed.push((file_id, new_text))
+    }
+
+    pub fn remove_file(&mut self, root_id: SourceRootId, file_id: FileId, path: RelativePathBuf) {
+        let file = RemoveFile { file_id, path };
+        self.roots_changed
+            .entry(root_id)
+            .or_default()
+            .removed
+            .push(file);
+    }
+
+    pub fn add_library(&mut self, data: LibraryData) {
+        self.libraries_added.push(data)
+    }
+
+    pub fn set_crate_graph(&mut self, graph: CrateGraph) {
+        self.crate_graph = Some(graph);
+    }
+}
+
+#[derive(Debug)]
+struct AddFile {
+    file_id: FileId,
+    path: RelativePathBuf,
+    text: Arc<String>,
+}
+
+#[derive(Debug)]
+struct RemoveFile {
+    file_id: FileId,
+    path: RelativePathBuf,
+}
+
+#[derive(Default)]
+struct RootChange {
+    added: Vec<AddFile>,
+    removed: Vec<RemoveFile>,
+}
+
+impl fmt::Debug for RootChange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AnalysisChange")
+            .field("added", &self.added.len())
+            .field("removed", &self.removed.len())
+            .finish()
+    }
+}
+
+pub struct LibraryData {
+    root_id: SourceRootId,
+    root_change: RootChange,
+    symbol_index: SymbolIndex,
+}
+
+impl fmt::Debug for LibraryData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("LibraryData")
+            .field("root_id", &self.root_id)
+            .field("root_change", &self.root_change)
+            .field("n_symbols", &self.symbol_index.len())
+            .finish()
+    }
+}
+
+impl LibraryData {
+    pub fn prepare(
+        root_id: SourceRootId,
+        files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
+    ) -> LibraryData {
+        let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, _, text)| {
+            let file = SourceFile::parse(text);
+            (*file_id, file)
+        }));
+        let mut root_change = RootChange::default();
+        root_change.added = files
+            .into_iter()
+            .map(|(file_id, path, text)| AddFile {
+                file_id,
+                path,
+                text,
+            })
+            .collect();
+        LibraryData {
+            root_id,
+            root_change,
+            symbol_index,
+        }
+    }
+}
+
+const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
+
+impl RootDatabase {
+    pub(crate) fn apply_change(&mut self, change: AnalysisChange) {
+        log::info!("apply_change {:?}", change);
+        if !change.new_roots.is_empty() {
+            let mut local_roots = Vec::clone(&self.local_roots());
+            for (root_id, is_local) in change.new_roots {
+                self.set_source_root(root_id, Default::default());
+                if is_local {
+                    local_roots.push(root_id);
+                }
+            }
+            self.set_local_roots(Arc::new(local_roots));
+        }
+
+        for (root_id, root_change) in change.roots_changed {
+            self.apply_root_change(root_id, root_change);
+        }
+        for (file_id, text) in change.files_changed {
+            self.set_file_text(file_id, text)
+        }
+        if !change.libraries_added.is_empty() {
+            let mut libraries = Vec::clone(&self.library_roots());
+            for library in change.libraries_added {
+                libraries.push(library.root_id);
+                self.set_source_root(library.root_id, Default::default());
+                self.set_constant_library_symbols(library.root_id, Arc::new(library.symbol_index));
+                self.apply_root_change(library.root_id, library.root_change);
+            }
+            self.set_library_roots(Arc::new(libraries));
+        }
+        if let Some(crate_graph) = change.crate_graph {
+            self.set_crate_graph(Arc::new(crate_graph))
+        }
+    }
+
+    fn apply_root_change(&mut self, root_id: SourceRootId, root_change: RootChange) {
+        let mut source_root = SourceRoot::clone(&self.source_root(root_id));
+        for add_file in root_change.added {
+            self.set_file_text(add_file.file_id, add_file.text);
+            self.set_file_relative_path(add_file.file_id, add_file.path.clone());
+            self.set_file_source_root(add_file.file_id, root_id);
+            source_root.files.insert(add_file.path, add_file.file_id);
+        }
+        for remove_file in root_change.removed {
+            self.set_file_text(remove_file.file_id, Default::default());
+            source_root.files.remove(&remove_file.path);
+        }
+        self.set_source_root(root_id, Arc::new(source_root));
+    }
+
+    pub(crate) fn maybe_collect_garbage(&mut self) {
+        if self.last_gc_check.elapsed() > GC_COOLDOWN {
+            self.last_gc_check = time::Instant::now();
+            let retained_trees = syntax_tree_stats(self).retained;
+            if retained_trees > 100 {
+                log::info!(
+                    "automatic garbadge collection, {} retained trees",
+                    retained_trees
+                );
+                self.collect_garbage();
+            }
+        }
+    }
+
+    pub(crate) fn collect_garbage(&mut self) {
+        self.last_gc = time::Instant::now();
+
+        let sweep = SweepStrategy::default()
+            .discard_values()
+            .sweep_all_revisions();
+
+        self.query(ra_db::ParseQuery).sweep(sweep);
+
+        self.query(hir::db::HirParseQuery).sweep(sweep);
+        self.query(hir::db::FileItemsQuery).sweep(sweep);
+        self.query(hir::db::FileItemQuery).sweep(sweep);
+
+        self.query(hir::db::LowerModuleQuery).sweep(sweep);
+        self.query(hir::db::LowerModuleSourceMapQuery).sweep(sweep);
+        self.query(hir::db::BodySyntaxMappingQuery).sweep(sweep);
+    }
+}

crates/ra_ide_api/src/diagnostics.rs

@@ -0,0 +1,69 @@
+use hir::{Problem, source_binder};
+use ra_ide_api_light::Severity;
+use ra_db::SourceDatabase;
+
+use crate::{Diagnostic, FileId, FileSystemEdit, SourceChange, db::RootDatabase};
+
+pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic> {
+    let syntax = db.parse(file_id);
+
+    let mut res = ra_ide_api_light::diagnostics(&syntax)
+        .into_iter()
+        .map(|d| Diagnostic {
+            range: d.range,
+            message: d.msg,
+            severity: d.severity,
+            fix: d.fix.map(|fix| SourceChange::from_local_edit(file_id, fix)),
+        })
+        .collect::<Vec<_>>();
+    if let Some(m) = source_binder::module_from_file_id(db, file_id) {
+        for (name_node, problem) in m.problems(db) {
+            let source_root = db.file_source_root(file_id);
+            let diag = match problem {
+                Problem::UnresolvedModule { candidate } => {
+                    let create_file = FileSystemEdit::CreateFile {
+                        source_root,
+                        path: candidate.clone(),
+                    };
+                    let fix = SourceChange {
+                        label: "create module".to_string(),
+                        source_file_edits: Vec::new(),
+                        file_system_edits: vec![create_file],
+                        cursor_position: None,
+                    };
+                    Diagnostic {
+                        range: name_node.range(),
+                        message: "unresolved module".to_string(),
+                        severity: Severity::Error,
+                        fix: Some(fix),
+                    }
+                }
+                Problem::NotDirOwner { move_to, candidate } => {
+                    let move_file = FileSystemEdit::MoveFile {
+                        src: file_id,
+                        dst_source_root: source_root,
+                        dst_path: move_to.clone(),
+                    };
+                    let create_file = FileSystemEdit::CreateFile {
+                        source_root,
+                        path: move_to.join(candidate),
+                    };
+                    let fix = SourceChange {
+                        label: "move file and create module".to_string(),
+                        source_file_edits: Vec::new(),
+                        file_system_edits: vec![move_file, create_file],
+                        cursor_position: None,
+                    };
+                    Diagnostic {
+                        range: name_node.range(),
+                        message: "can't declare module at this location".to_string(),
+                        severity: Severity::Error,
+                        fix: Some(fix),
+                    }
+                }
+            };
+            res.push(diag)
+        }
+    };
+    res
+}

crates/ra_ide_api/src/goto_definition.rs

@@ -118,8 +118,7 @@ pub(crate) fn reference_definition(
         }
     }
     // If that fails try the index based approach.
-    let navs = db
-        .index_resolve(name_ref)
+    let navs = crate::symbol_index::index_resolve(db, name_ref)
         .into_iter()
         .map(NavigationTarget::from_symbol)
         .collect();