Rust: create single Semantics object for each workspace

Author: aibaars

rust/extractor/src/main.rs

@@ -1,6 +1,7 @@
 use anyhow::Context;
 use archive::Archiver;
 use log::info;
+use ra_ap_hir::Semantics;
 use ra_ap_ide_db::line_index::{LineCol, LineIndex};
 use ra_ap_project_model::ProjectManifest;
 use rust_analyzer::{ParseResult, RustAnalyzer};
@@ -29,7 +30,6 @@ fn extract(
         text,
         errors,
         file_id,
-        semantics,
     } = rust_analyzer.parse(file);
     let line_index = LineIndex::new(text.as_ref());
     let display_path = file.to_string_lossy();
@@ -41,7 +41,7 @@ fn extract(
         label,
         line_index,
         file_id,
-        semantics,
+        rust_analyzer.semantics(),
     );
 
     for err in errors {
@@ -112,14 +112,20 @@ fn main() -> anyhow::Result<()> {
         if files.is_empty() {
             break;
         }
-        let mut rust_analyzer = RustAnalyzer::new(manifest, &cfg.scratch_dir);
-        for file in files {
-            extract(&mut rust_analyzer, &archiver, &traps, file);
+        if let Some((ref db, ref vfs)) = RustAnalyzer::load_workspace(manifest, &cfg.scratch_dir) {
+            let semantics = Semantics::new(db);
+            let rust_analyzer = RustAnalyzer::new(db, vfs, semantics);
+            for file in files {
+                extract(&rust_analyzer, &archiver, &traps, file);
+            }
+        } else {
+            for file in files {
+                extract(&RustAnalyzer::WithoutDatabase(), &archiver, &traps, file);
+            }
         }
     }
-    let mut rust_analyzer = RustAnalyzer::WithoutDatabase();
     for file in other_files {
-        extract(&mut rust_analyzer, &archiver, &traps, file);
+        extract(&RustAnalyzer::WithoutDatabase(), &archiver, &traps, file);
     }
 
     Ok(())

rust/extractor/src/rust_analyzer.rs

@@ -20,19 +20,25 @@ use ra_ap_vfs::VfsPath;
 use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 use triomphe::Arc;
-pub enum RustAnalyzer {
-    WithDatabase { db: RootDatabase, vfs: Vfs },
+pub enum RustAnalyzer<'a> {
+    WithDatabase {
+        db: &'a RootDatabase,
+        vfs: &'a Vfs,
+        semantics: Semantics<'a, RootDatabase>,
+    },
     WithoutDatabase(),
 }
-pub struct ParseResult<'a> {
+pub struct ParseResult {
     pub ast: SourceFile,
     pub text: Arc<str>,
     pub errors: Vec<SyntaxError>,
     pub file_id: Option<EditionedFileId>,
-    pub semantics: Option<Semantics<'a, RootDatabase>>,
 }
-impl RustAnalyzer {
-    pub fn new(project: &ProjectManifest, scratch_dir: &Path) -> Self {
+impl<'a> RustAnalyzer<'a> {
+    pub fn load_workspace(
+        project: &ProjectManifest,
+        scratch_dir: &Path,
+    ) -> Option<(RootDatabase, Vfs)> {
         let config = CargoConfig {
             sysroot: Some(RustLibSource::Discover),
             target_dir: ra_ap_paths::Utf8PathBuf::from_path_buf(scratch_dir.to_path_buf())
@@ -49,52 +55,64 @@ impl RustAnalyzer {
         let manifest = project.manifest_path();
 
         match load_workspace_at(manifest.as_ref(), &config, &load_config, &progress) {
-            Ok((db, vfs, _macro_server)) => RustAnalyzer::WithDatabase { db, vfs },
+            Ok((db, vfs, _macro_server)) => Some((db, vfs)),
             Err(err) => {
                 log::error!("failed to load workspace for {}: {}", manifest, err);
-                RustAnalyzer::WithoutDatabase()
+                None
             }
         }
     }
-    pub fn parse(&self, path: &Path) -> ParseResult<'_> {
-        let mut errors = Vec::new();
-        let input = match std::fs::read(path) {
-            Ok(data) => data,
-            Err(e) => {
-                errors.push(SyntaxError::new(
-                    format!("Could not read {}: {}", path.to_string_lossy(), e),
-                    TextRange::empty(TextSize::default()),
-                ));
-                vec![]
-            }
-        };
-        let (input, err) = from_utf8_lossy(&input);
-
-        if let RustAnalyzer::WithDatabase { vfs, db } = self {
+    pub fn new(db: &'a RootDatabase, vfs: &'a Vfs, semantics: Semantics<'a, RootDatabase>) -> Self {
+        RustAnalyzer::WithDatabase { db, vfs, semantics }
+    }
+    pub fn semantics(&'a self) -> Option<&'a Semantics<'a, RootDatabase>> {
+        match self {
+            RustAnalyzer::WithDatabase {
+                db: _,
+                vfs: _,
+                semantics,
+            } => Some(semantics),
+            RustAnalyzer::WithoutDatabase() => None,
+        }
+    }
+    pub fn parse(&self, path: &Path) -> ParseResult {
+        if let RustAnalyzer::WithDatabase { vfs, db, semantics } = self {
             if let Some(file_id) = Utf8PathBuf::from_path_buf(path.to_path_buf())
                 .ok()
                 .and_then(|x| AbsPathBuf::try_from(x).ok())
                 .map(VfsPath::from)
                 .and_then(|x| vfs.file_id(&x))
             {
-                let semantics = Semantics::new(db);
-
+                let input: Arc<str> = db.file_text(file_id);
                 let file_id = EditionedFileId::current_edition(file_id);
                 let source_file = semantics.parse(file_id);
-                errors.extend(
-                    db.parse_errors(file_id)
-                        .into_iter()
-                        .flat_map(|x| x.to_vec()),
-                );
+                let errors = db
+                    .parse_errors(file_id)
+                    .into_iter()
+                    .flat_map(|x| x.to_vec())
+                    .collect();
+
                 return ParseResult {
                     ast: source_file,
-                    text: input.as_ref().into(),
+                    text: input,
                     errors,
                     file_id: Some(file_id),
-                    semantics: Some(semantics),
                 };
             }
         }
+        let mut errors = Vec::new();
+        let input = match std::fs::read(path) {
+            Ok(data) => data,
+            Err(e) => {
+                errors.push(SyntaxError::new(
+                    format!("Could not read {}: {}", path.to_string_lossy(), e),
+                    TextRange::empty(TextSize::default()),
+                ));
+                vec![]
+            }
+        };
+        let (input, err) = from_utf8_lossy(&input);
+
         let parse = ra_ap_syntax::ast::SourceFile::parse(&input, Edition::CURRENT);
         errors.extend(parse.errors());
         errors.extend(err);
@@ -103,7 +121,6 @@ impl RustAnalyzer {
             text: input.as_ref().into(),
             errors,
             file_id: None,
-            semantics: None,
         }
     }
 }

rust/extractor/src/translate/base.rs

@@ -82,7 +82,7 @@ pub struct Translator<'a> {
     label: trap::Label,
     line_index: LineIndex,
     file_id: Option<EditionedFileId>,
-    pub semantics: Option<Semantics<'a, RootDatabase>>,
+    pub semantics: Option<&'a Semantics<'a, RootDatabase>>,
 }
 
 impl<'a> Translator<'a> {
@@ -92,7 +92,7 @@ impl<'a> Translator<'a> {
         label: trap::Label,
         line_index: LineIndex,
         file_id: Option<EditionedFileId>,
-        semantics: Option<Semantics<'a, RootDatabase>>,
+        semantics: Option<&'a Semantics<'a, RootDatabase>>,
     ) -> Translator<'a> {
         Translator {
             trap,