ref: manage memory usage

Author: Desdaemon

package.json

@@ -48,7 +48,12 @@
 				"odoo-lsp.symbols.limit": {
 					"type": "number",
 					"default": 80,
-					"description": "Maximum amount of workspace symbols to view at once."
+					"description": "Maximum amount of workspace symbols to retrieve at once."
+				},
+				"odoo-lsp.references.limit": {
+					"type": "number",
+					"default": 80,
+					"description": "Maximum amount of model/record references to retrieve at once."
 				},
 				"odoo-lsp.module.roots": {
 					"type": "array",

src/config.rs

@@ -4,6 +4,7 @@ use serde::Deserialize;
 pub struct Config {
 	pub module: Option<ModuleConfig>,
 	pub symbols: Option<SymbolsConfig>,
+	pub references: Option<ReferencesConfig>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -15,3 +16,8 @@ pub struct ModuleConfig {
 pub struct SymbolsConfig {
 	pub limit: Option<u32>,
 }
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ReferencesConfig {
+	pub limit: Option<u32>,
+}

src/index.rs

@@ -146,14 +146,7 @@ impl ModuleIndex {
 				}
 				Output::Models { path, models } => {
 					model_count += models.len();
-					let uri = match format!("file://{path}").parse() {
-						Ok(uri) => uri,
-						Err(err) => {
-							debug!("{err}");
-							continue;
-						}
-					};
-					self.models.extend_models(&uri, models).await;
+					self.models.extend_models(path, models).await;
 				}
 			}
 		}
@@ -185,7 +178,7 @@ impl ModuleIndex {
 }
 
 async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Output> {
-	let uri: Url = format!("file://{}", path.to_string_lossy()).parse().into_diagnostic()?;
+	let path_uri = ImStr::from(path.to_string_lossy().as_ref());
 	let file = tokio::fs::read(&path)
 		.await
 		.into_diagnostic()
@@ -201,7 +194,7 @@ async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Outpu
 					let record = Record::from_reader(
 						CharOffset(span.start()),
 						module_name.clone(),
-						uri.clone(),
+						path_uri.clone(),
 						&mut reader,
 						rope.clone(),
 					)?;
@@ -210,7 +203,7 @@ async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Outpu
 					let template = Record::template(
 						CharOffset(span.start()),
 						module_name.clone(),
-						uri.clone(),
+						path_uri.clone(),
 						&mut reader,
 						rope.clone(),
 					)?;
@@ -281,11 +274,11 @@ async fn add_root_py(path: PathBuf, _: ImStr) -> miette::Result<Output> {
 			.ok_or_else(|| diagnostic!("model range"))?;
 		match (inherits.as_slice(), maybe_base) {
 			([single], Some(base)) if base.as_ref() == single => out.push(Model {
-				model: ModelId::Inherit(inherits.into_boxed_slice()),
+				model: ModelId::Inherit(inherits),
 				range,
 			}),
 			(_, None) if !inherits.is_empty() => out.push(Model {
-				model: ModelId::Inherit(inherits.into_boxed_slice()),
+				model: ModelId::Inherit(inherits),
 				range,
 			}),
 			(_, Some(base)) => out.push(Model {

src/index/record.rs

@@ -56,7 +56,7 @@ impl RecordIndex {
 				.or_insert_with(DashSet::default)
 				.insert(qualified_id.clone());
 		}
-		self.inner.insert(qualified_id.into(), record);
+		self.inner.insert(qualified_id, record);
 	}
 	pub async fn extend_records(&self, prefix: Option<&mut PrefixTrie>, records: impl IntoIterator<Item = Record>) {
 		if let Some(prefix) = prefix {

src/main.rs

@@ -18,7 +18,7 @@ use tower_lsp::lsp_types::*;
 use tower_lsp::{Client, LanguageServer, LspService, Server};
 use tree_sitter::{Parser, Tree};
 
-use odoo_lsp::config::{Config, ModuleConfig, SymbolsConfig};
+use odoo_lsp::config::{Config, ModuleConfig, ReferencesConfig, SymbolsConfig};
 use odoo_lsp::index::ModuleIndex;
 use odoo_lsp::model::ModelLocation;
 use odoo_lsp::utils::isolate::Isolate;
@@ -38,6 +38,7 @@ pub struct Backend {
 	capabilities: Capabilities,
 	root_setup: AtomicBool,
 	symbols_limit: AtomicUsize,
+	references_limit: AtomicUsize,
 	isolate: Isolate,
 }
 
@@ -137,6 +138,7 @@ impl LanguageServer for Backend {
 			capabilities: _,
 			root_setup: _,
 			symbols_limit: _,
+			references_limit: _,
 			isolate: _,
 		} = self;
 		document_map.remove(path);
@@ -172,7 +174,7 @@ impl LanguageServer for Backend {
 		}
 
 		for root in self.roots.iter() {
-			match self.module_index.add_root(&root.as_str(), progress.clone()).await {
+			match self.module_index.add_root(root.as_str(), progress.clone()).await {
 				Ok(Some(results)) => {
 					info!(
 						"{} | {} modules | {} records | {} models | {:.2}s",
@@ -750,17 +752,18 @@ impl Backend {
 		}
 	}
 	fn model_references(&self, model: &str) -> miette::Result<Option<Vec<Location>>> {
-		let mut locations = match self.module_index.models.get(model) {
-			Some(entry) => entry.1.iter().map(|loc| loc.0.clone().into()).collect::<Vec<_>>(),
-			None => vec![],
-		};
-		locations.extend(
-			self.module_index
-				.records
-				.by_model(model)
-				.map(|record| record.location.clone().into()),
-		);
-		Ok(Some(locations))
+		let record_locations = self
+			.module_index
+			.records
+			.by_model(model)
+			.map(|record| record.location.clone().into());
+		let limit = self.references_limit.load(Relaxed);
+		if let Some(entry) = self.module_index.models.get(model) {
+			let inherit_locations = entry.1.iter().map(|loc| loc.0.clone().into());
+			Ok(Some(inherit_locations.chain(record_locations).take(limit).collect()))
+		} else {
+			Ok(Some(record_locations.take(limit).collect()))
+		}
 	}
 	fn record_references(
 		&self,
@@ -775,17 +778,22 @@ impl Backend {
 			debug!("No current module to resolve the XML ID {inherit_id}");
 			return Ok(None);
 		};
+		let limit = self.references_limit.load(Relaxed);
 		let locations = self
 			.module_index
 			.records
 			.by_inherit_id(&inherit_id)
-			.map(|record| record.location.clone().into());
+			.map(|record| record.location.clone().into())
+			.take(limit);
 		Ok(Some(locations.collect()))
 	}
 	async fn on_change_config(&self, config: Config) {
 		if let Some(SymbolsConfig { limit: Some(limit) }) = config.symbols {
 			self.symbols_limit.store(limit as usize, Relaxed);
 		}
+		if let Some(ReferencesConfig { limit: Some(limit) }) = config.references {
+			self.references_limit.store(limit as usize, Relaxed);
+		}
 		let Some(ModuleConfig { roots: Some(roots), .. }) = config.module else {
 			return;
 		};
@@ -830,6 +838,7 @@ async fn main() {
 		root_setup: Default::default(),
 		ast_map: DashMap::new(),
 		symbols_limit: AtomicUsize::new(100),
+		references_limit: AtomicUsize::new(100),
 		isolate: Isolate::new(),
 	})
 	.finish();

src/model.rs

@@ -3,9 +3,9 @@ use std::{fmt::Display, ops::Deref, sync::Arc};
 use dashmap::DashMap;
 use qp_trie::{wrapper::BString, Trie};
 use tokio::sync::RwLock;
-use tower_lsp::lsp_types::{Location, Range, Url};
+use tower_lsp::lsp_types::Range;
 
-use crate::utils::ImStr;
+use crate::utils::{ImStr, MinLoc};
 
 #[derive(Clone, Debug)]
 pub struct Model {
@@ -16,7 +16,7 @@ pub struct Model {
 #[derive(Clone, Debug)]
 pub enum ModelId {
 	Base(ImStr),
-	Inherit(Box<[ImStr]>),
+	Inherit(Vec<ImStr>),
 }
 
 #[derive(Default, Clone)]
@@ -26,24 +26,21 @@ pub struct ModelIndex {
 }
 
 #[derive(Clone)]
-pub struct ModelLocation(pub Location);
+pub struct ModelLocation(pub MinLoc);
 
 impl Display for ModelLocation {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		if self.0.range.start.line == self.0.range.end.line {
 			write!(
 				f,
 				"{} [{}:{}..{}]",
-				self.0.uri.path(),
-				self.0.range.start.line,
-				self.0.range.start.character,
-				self.0.range.end.character,
+				self.0.path, self.0.range.start.line, self.0.range.start.character, self.0.range.end.character,
 			)
 		} else {
 			write!(
 				f,
 				"{} [{}:{}..{}:{}]",
-				self.0.uri.path(),
+				self.0.path,
 				self.0.range.start.line,
 				self.0.range.start.character,
 				self.0.range.end.line,
@@ -62,7 +59,7 @@ impl Deref for ModelIndex {
 }
 
 impl ModelIndex {
-	pub async fn extend_models<I>(&self, uri: &Url, items: I)
+	pub async fn extend_models<I>(&self, path: ImStr, items: I)
 	where
 		I: IntoIterator<Item = Model>,
 	{
@@ -71,8 +68,8 @@ impl ModelIndex {
 			match item.model {
 				ModelId::Base(base) => {
 					by_prefix.insert_str(&base, base.clone());
-					let mut location = Some(ModelLocation(Location {
-						uri: uri.clone(),
+					let mut location = Some(ModelLocation(MinLoc {
+						path: path.clone(),
 						range: item.range,
 					}));
 					core::mem::swap(&mut self.entry(base.clone()).or_default().0, &mut location);
@@ -83,8 +80,8 @@ impl ModelIndex {
 				}
 				ModelId::Inherit(inherits) => {
 					for inherit in inherits.iter() {
-						self.entry(inherit.clone()).or_default().1.push(ModelLocation(Location {
-							uri: uri.clone(),
+						self.entry(inherit.clone()).or_default().1.push(ModelLocation(MinLoc {
+							path: path.clone(),
 							range: item.range,
 						}))
 					}

src/record.rs

@@ -3,8 +3,8 @@ use ropey::Rope;
 use tower_lsp::lsp_types::*;
 use xmlparser::{ElementEnd, Token, Tokenizer};
 
-use crate::utils::ImStr;
 use crate::utils::{char_to_position, position_to_char, CharOffset};
+use crate::utils::{ImStr, MinLoc};
 
 macro_rules! unwrap_or_none {
 	($opt:expr) => {
@@ -23,7 +23,7 @@ pub struct Record {
 	pub model: Option<ImStr>,
 	/// (inherit_module?, xml_id)
 	pub inherit_id: Option<(Option<ImStr>, ImStr)>,
-	pub location: Location,
+	pub location: MinLoc,
 }
 
 impl Record {
@@ -33,7 +33,7 @@ impl Record {
 	pub fn from_reader(
 		offset: CharOffset,
 		module: ImStr,
-		uri: Url,
+		path: ImStr,
 		reader: &mut Tokenizer,
 		rope: Rope,
 	) -> miette::Result<Option<Self>> {
@@ -144,13 +144,13 @@ impl Record {
 			module,
 			model,
 			inherit_id,
-			location: Location { uri, range },
+			location: MinLoc { path, range },
 		}))
 	}
 	pub fn template(
 		offset: CharOffset,
 		module: ImStr,
-		uri: Url,
+		path: ImStr,
 		reader: &mut Tokenizer,
 		rope: Rope,
 	) -> miette::Result<Option<Self>> {
@@ -231,7 +231,7 @@ impl Record {
 			model: Some("ir.ui.view".into()),
 			module,
 			inherit_id,
-			location: Location { uri, range },
+			location: MinLoc { path, range },
 		}))
 	}
 }
@@ -252,17 +252,11 @@ mod tests {
 		_ = reader.next();
 		let rope = Rope::from_str(&document);
 		let Record {
-			location: Location { range, .. },
+			location: MinLoc { range, .. },
 			..
-		} = Record::from_reader(
-			CharOffset(0),
-			"foo".into(),
-			"/foo".parse().unwrap(),
-			&mut reader,
-			rope.clone(),
-		)
-		.unwrap()
-		.unwrap();
+		} = Record::from_reader(CharOffset(0), "foo".into(), "/foo".into(), &mut reader, rope.clone())
+			.unwrap()
+			.unwrap();
 		let range = lsp_range_to_char_range(range, rope).unwrap();
 		assert_eq!(&document[range.map_unit(|unit| unit.0)], fragment);
 	}

src/utils.rs

@@ -14,6 +14,22 @@ pub use str::ImStr;
 
 pub type PrefixTrie = qp_trie::Trie<BString, DashSet<ImStr>>;
 
+/// A more economical version of [Location].
+#[derive(Clone, Debug)]
+pub struct MinLoc {
+	pub path: ImStr,
+	pub range: Range,
+}
+
+impl From<MinLoc> for Location {
+	fn from(value: MinLoc) -> Self {
+		Location {
+			uri: format!("file://{}", value.path).parse().unwrap(),
+			range: value.range,
+		}
+	}
+}
+
 pub fn offset_to_position(offset: usize, rope: Rope) -> Option<Position> {
 	let line = rope.try_char_to_line(offset).ok()?;
 	let first_char_of_line = rope.try_line_to_char(line).ok()?;

src/utils/str.rs

@@ -18,7 +18,7 @@ impl Deref for ImStr {
 	#[inline]
 	fn deref(&self) -> &Self::Target {
 		match &self.0 {
-			Repr::Arc(inner) => &inner,
+			Repr::Arc(inner) => inner,
 			Repr::Inline(len, bytes) => {
 				let slice = &bytes[..(*len as usize)];
 				unsafe { std::str::from_utf8_unchecked(slice) }
@@ -116,6 +116,7 @@ impl std::hash::Hash for ImStr {
 }
 
 impl ImStr {
+	#[inline]
 	pub fn as_str(&self) -> &str {
 		self.deref()
 	}