ref: replace FastStr with ImStr

Author: Desdaemon

Cargo.lock

@@ -34,8 +34,6 @@ tower-lsp = { version = "0.20.0", features = ["proposed"] }
 serde = { version = "1.0", features = ["derive"] }
 dashmap = "5.1.0"
 log = "0.4.14"
-im-rc = "15.0.0"
-faststr = "0.2.11"
 globwalk = "0.8.1"
 miette = { version = "5.10.0", features = ["fancy"] }
 futures = "0.3.28"

Cargo.toml

@@ -41,7 +41,7 @@ Alternatively, you can grab the latest nightly builds from [Releases].
 
 See [.helix/languages.toml](./examples/.helix/languages.toml)
 
-1. Ensure that you have `odoo-lsp` on your path (or define the SERVER_PATH environment variable pointing to one)
+1. Ensure that you have `odoo-lsp` on your path
 2. Determine your Helix runtime folder, e.g. `~/.config/helix/` on Linux
 3. Modify `languages.toml` in your Helix runtime folder (create one if none exists) to include these lines:
 
@@ -53,9 +53,14 @@ odoo-lsp.command = "odoo-lsp"
 [[language]]
 name = "xml"
 language-servers = ["odoo-lsp"]
+roots = [".odoo_lsp", ".odoo_lsp.json"]
 
 [[language]]
 name = "python"
+roots = [
+   ".odoo_lsp", ".odoo_lsp.json",
+   # add the default roots here
+]
 # Order is important here
 language-servers = [
    "odoo-lsp",

README.md

@@ -3,7 +3,6 @@ use std::sync::OnceLock;
 use std::time::Duration;
 
 use dashmap::DashSet;
-use faststr::FastStr;
 use globwalk::FileType;
 use log::{debug, warn};
 use miette::{diagnostic, Context, IntoDiagnostic};
@@ -16,21 +15,21 @@ use xmlparser::{Token, Tokenizer};
 use crate::format_loc;
 use crate::model::{Model, ModelIndex};
 use crate::record::Record;
-use crate::utils::{offset_range_to_lsp_range, ByteOffset, CharOffset, RangeExt};
+use crate::utils::{offset_range_to_lsp_range, ByteOffset, CharOffset, ImStr, RangeExt};
 
 mod record;
 
 #[derive(Default)]
 pub struct ModuleIndex {
-	pub roots: DashSet<String>,
-	pub modules: DashSet<String>,
+	pub roots: DashSet<ImStr>,
+	pub modules: DashSet<ImStr>,
 	pub records: record::RecordIndex,
 	pub models: ModelIndex,
 }
 
 enum Output {
 	Records(Vec<Record>),
-	Models { path: FastStr, models: Vec<Model> },
+	Models { path: ImStr, models: Vec<Model> },
 }
 
 pub struct AddRootResults {
@@ -49,7 +48,7 @@ impl ModuleIndex {
 		root: &str,
 		progress: Option<(&tower_lsp::Client, ProgressToken)>,
 	) -> miette::Result<Option<AddRootResults>> {
-		if !self.roots.insert(root.to_string()) {
+		if !self.roots.insert(root.into()) {
 			return Ok(None);
 		}
 
@@ -83,8 +82,8 @@ impl ModuleIndex {
 					})
 					.await;
 			}
-			let module_name = FastStr::from(module_name);
-			if !self.modules.insert(module_name.to_string()) {
+			let module_name = ImStr::from(module_name);
+			if !self.modules.insert(module_name.clone()) {
 				debug!("duplicate module {module_name}");
 				continue;
 			}
@@ -173,7 +172,7 @@ impl ModuleIndex {
 			}
 		}
 	}
-	pub fn module_of_path(&self, path: &Path) -> Option<dashmap::setref::one::Ref<String>> {
+	pub fn module_of_path(&self, path: &Path) -> Option<dashmap::setref::one::Ref<ImStr>> {
 		let mut path = Some(path);
 		while let Some(path_) = &path {
 			if let Some(module) = self.modules.get(path_.file_name()?.to_string_lossy().as_ref()) {
@@ -185,7 +184,7 @@ impl ModuleIndex {
 	}
 }
 
-async fn add_root_xml(path: PathBuf, module_name: FastStr) -> miette::Result<Output> {
+async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Output> {
 	let path_uri = path.to_string_lossy();
 	let file = tokio::fs::read(&path)
 		.await
@@ -238,7 +237,7 @@ fn model_query() -> &'static Query {
 	})
 }
 
-async fn add_root_py(path: PathBuf, _: FastStr) -> miette::Result<Output> {
+async fn add_root_py(path: PathBuf, _: ImStr) -> miette::Result<Output> {
 	let file = tokio::fs::read(&path)
 		.await
 		.into_diagnostic()

src/index.rs

@@ -1,79 +1,89 @@
 use std::{ops::Deref, sync::Arc};
 
 use dashmap::{mapref::one::Ref, DashMap, DashSet};
+use qp_trie::wrapper::BString;
 use tokio::sync::RwLock;
 
-use crate::{record::Record, utils::PrefixTrie};
+use crate::{
+	record::Record,
+	utils::{ImStr, PrefixTrie},
+};
 
 #[derive(Default)]
 pub struct RecordIndex {
-	inner: DashMap<String, Record>,
-	by_model: DashMap<String, DashSet<String>>,
-	by_inherit_id: DashMap<String, DashSet<String>>,
+	inner: DashMap<ImStr, Record>,
+	by_model: DashMap<ImStr, DashSet<ImStr>>,
+	by_inherit_id: DashMap<ImStr, DashSet<ImStr>>,
 	pub by_prefix: Arc<RwLock<PrefixTrie>>,
 }
 
 impl Deref for RecordIndex {
-	type Target = DashMap<String, Record>;
+	type Target = DashMap<ImStr, Record>;
 	#[inline]
 	fn deref(&self) -> &Self::Target {
 		&self.inner
 	}
 }
 
 impl RecordIndex {
-	pub async fn insert(&self, qualified_id: String, record: Record, prefix: Option<&mut PrefixTrie>) {
+	pub async fn insert(&self, qualified_id: ImStr, record: Record, prefix: Option<&mut PrefixTrie>) {
 		if let Some(model) = &record.model {
 			self.by_model
-				.entry(model.to_string())
+				.entry(model.clone())
 				.or_default()
-				.insert(qualified_id.to_string());
+				.insert(qualified_id.clone());
 		}
 		if let Some(inherit_id) = &record.inherit_id {
 			let inherit_id = match inherit_id {
 				(Some(module), xml_id) => format!("{module}.{xml_id}"),
 				(None, xml_id) => format!("{}.{xml_id}", record.module),
 			};
 			self.by_inherit_id
-				.entry(inherit_id)
+				.entry(inherit_id.into())
 				.or_default()
-				.insert(qualified_id.to_string());
+				.insert(qualified_id.clone());
 		}
 		if let Some(prefix) = prefix {
-			prefix.insert_str(&qualified_id, qualified_id.to_string());
+			prefix
+				.entry(BString::from(record.id.as_str()))
+				.or_insert_with(DashSet::default)
+				.insert(qualified_id.clone());
 		} else {
 			self.by_prefix
 				.write()
 				.await
-				.insert_str(&qualified_id, qualified_id.to_string());
+				.entry(BString::from(record.id.as_str()))
+				.or_insert_with(DashSet::default)
+				.insert(qualified_id.clone());
 		}
-		self.inner.insert(qualified_id, record);
+		self.inner.insert(qualified_id.into(), record);
 	}
 	pub async fn extend_records(&self, prefix: Option<&mut PrefixTrie>, records: impl IntoIterator<Item = Record>) {
 		if let Some(prefix) = prefix {
 			for record in records {
-				self.insert(record.qualified_id(), record, Some(prefix)).await;
+				self.insert(record.qualified_id().into(), record, Some(prefix)).await;
 			}
 		} else {
 			let mut prefix = self.by_prefix.write().await;
 			for record in records {
-				self.insert(record.qualified_id(), record, Some(&mut prefix)).await;
+				self.insert(record.qualified_id().into(), record, Some(&mut prefix))
+					.await;
 			}
 		}
 	}
-	pub fn by_model(&self, model: &str) -> impl Iterator<Item = Ref<String, Record>> {
+	pub fn by_model(&self, model: &str) -> impl Iterator<Item = Ref<ImStr, Record>> {
 		self.by_model
 			.get(model)
 			.into_iter()
 			.flat_map(|ids| self.resolve_references(ids))
 	}
-	pub fn by_inherit_id(&self, inherit_id: &str) -> impl Iterator<Item = Ref<String, Record>> {
+	pub fn by_inherit_id(&self, inherit_id: &str) -> impl Iterator<Item = Ref<ImStr, Record>> {
 		self.by_inherit_id
 			.get(inherit_id)
 			.into_iter()
 			.flat_map(|ids| self.resolve_references(ids))
 	}
-	fn resolve_references(&self, ids: Ref<String, DashSet<String>>) -> impl IntoIterator<Item = Ref<String, Record>> {
+	fn resolve_references(&self, ids: Ref<ImStr, DashSet<ImStr>>) -> impl IntoIterator<Item = Ref<ImStr, Record>> {
 		ids.value()
 			.iter()
 			.flat_map(|id| self.get(id.key()).into_iter())