Add Loc2IdMap

6 files changed, 84 insertions, 0 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 18aac79ab..c6ed5107c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -600,6 +600,7 @@ version = "0.1.0"
 dependencies = [
  "fst 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_editor 0.1.0",
  "ra_syntax 0.1.0",
  "rayon 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index 908ee1c81..b4a1a09b5 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -11,6 +11,7 @@ rayon = "1.0.2"
 fst = "0.3.1"
 salsa = "0.8.0"
 rustc-hash = "1.0"
+parking_lot = "0.6.4"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 194f1a6b0..baf6d915a 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,5 +1,7 @@
 use std::sync::Arc;
 
+use parking_lot::Mutex;
+
 use ra_editor::LineIndex;
 use ra_syntax::{SourceFileNode, SyntaxNode};
 use salsa::{self, Database};
@@ -9,15 +11,19 @@ use crate::{
     descriptors::{
         DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleScopeQuery, ModuleTreeQuery,
         SubmodulesQuery,
+        module::{ModuleSource, ModuleId},
     },
+    input::SourceRootId,
     symbol_index::SymbolIndex,
     syntax_ptr::SyntaxPtr,
+    loc2id::Loc2IdMap,
     Cancelable, Canceled, FileId,
 };
 
 #[derive(Debug)]
 pub(crate) struct RootDatabase {
     runtime: salsa::Runtime<RootDatabase>,
+    loc2id: Arc<Mutex<Loc2IdMap<(SourceRootId, ModuleSource), ModuleId>>>,
 }
 
 impl salsa::Database for RootDatabase {
@@ -30,6 +36,7 @@ impl Default for RootDatabase {
     fn default() -> RootDatabase {
         let mut db = RootDatabase {
             runtime: Default::default(),
+            loc2id: Default::default(),
         };
         db.query_mut(crate::input::SourceRootQuery)
             .set(crate::input::WORKSPACE, Default::default());
@@ -53,6 +60,7 @@ impl salsa::ParallelDatabase for RootDatabase {
     fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
         salsa::Snapshot::new(RootDatabase {
             runtime: self.runtime.snapshot(self),
+            loc2id: Arc::clone(&self.loc2id),
         })
     }
 }
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
index bc1148b22..055a56b54 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -58,6 +58,15 @@ enum ModuleSourceNode {
 #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
 pub(crate) struct ModuleId(u32);
 
+impl crate::loc2id::NumericId for ModuleId {
+    fn from_u32(id: u32) -> Self {
+        ModuleId(id)
+    }
+    fn to_u32(self) -> u32 {
+        self.0
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct LinkId(u32);
 
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index ab0e3cb0c..eccda84a7 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -10,6 +10,7 @@ extern crate rustc_hash;
 extern crate salsa;
 
 mod db;
+mod loc2id;
 mod input;
 mod imp;
 mod completion;
diff --git a/crates/ra_analysis/src/loc2id.rs b/crates/ra_analysis/src/loc2id.rs
new file mode 100644
index 000000000..a53ce8348
--- /dev/null
+++ b/crates/ra_analysis/src/loc2id.rs
@@ -0,0 +1,64 @@
+use std::hash::Hash;
+
+use rustc_hash::FxHashMap;
+
+/// There are two principle ways to refer to things:
+///   - by their locatinon (module in foo/bar/baz.rs at line 42)
+///   - by their numeric id (module `ModuleId(42)`)
+///
+/// The first one is more powerful (you can actually find the thing in question
+/// by id), but the second one is so much more compact.
+///
+/// `Loc2IdMap` allows us to have a cake an eat it as well: by maintaining a
+/// bidirectional mapping between positional and numeric ids, we can use compact
+/// representation wich still allows us to get the actual item
+#[derive(Debug)]
+pub(crate) struct Loc2IdMap<L, ID>
+where
+    ID: NumericId,
+    L: Clone + Eq + Hash,
+{
+    loc2id: FxHashMap<L, ID>,
+    id2loc: FxHashMap<ID, L>,
+}
+
+impl<L, ID> Default for Loc2IdMap<L, ID>
+where
+    ID: NumericId,
+    L: Clone + Eq + Hash,
+{
+    fn default() -> Self {
+        Loc2IdMap {
+            loc2id: FxHashMap::default(),
+            id2loc: FxHashMap::default(),
+        }
+    }
+}
+
+impl<L, ID> Loc2IdMap<L, ID>
+where
+    ID: NumericId,
+    L: Clone + Eq + Hash,
+{
+    pub fn loc2id(&mut self, loc: &L) -> ID {
+        match self.loc2id.get(loc) {
+            Some(id) => return id.clone(),
+            None => (),
+        }
+        let id = self.loc2id.len();
+        assert!(id < u32::max_value() as usize);
+        let id = ID::from_u32(id as u32);
+        self.loc2id.insert(loc.clone(), id.clone());
+        self.id2loc.insert(id.clone(), loc.clone());
+        id
+    }
+
+    pub fn id2loc(&self, id: &ID) -> L {
+        self.id2loc[id].clone()
+    }
+}
+
+pub(crate) trait NumericId: Clone + Eq + Hash {
+    fn from_u32(id: u32) -> Self;
+    fn to_u32(self) -> u32;
+}