feat: multi-inheritance

Author: Desdaemon

examples/two/test.py

@@ -13,4 +13,7 @@ class Quux(models.Model):
     _name = 'quux'
     _inherit = 'bar'
 
-    what = fields.Many2one(comodel_name='bar')
+    what = fields.Many2one(comodel_name='bar')
+
+class Moo(models.Model):
+    _inherit = ['bar', 'quux']

src/index.rs

@@ -13,7 +13,7 @@ use tree_sitter::{Query, QueryCursor};
 use xmlparser::{Token, Tokenizer};
 
 use crate::format_loc;
-use crate::model::{Model, ModelIndex};
+use crate::model::{Model, ModelId, ModelIndex};
 use crate::record::Record;
 use crate::utils::{offset_range_to_lsp_range, ByteOffset, CharOffset, ImStr, RangeExt};
 
@@ -185,7 +185,7 @@ impl ModuleIndex {
 }
 
 async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Output> {
-	let path_uri = path.to_string_lossy();
+	let uri: Url = format!("file://{}", path.to_string_lossy()).parse().into_diagnostic()?;
 	let file = tokio::fs::read(&path)
 		.await
 		.into_diagnostic()
@@ -201,7 +201,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(),
-						&path_uri,
+						uri.clone(),
 						&mut reader,
 						rope.clone(),
 					)?;
@@ -210,7 +210,7 @@ async fn add_root_xml(path: PathBuf, module_name: ImStr) -> miette::Result<Outpu
 					let template = Record::template(
 						CharOffset(span.start()),
 						module_name.clone(),
-						&path_uri,
+						uri.clone(),
 						&mut reader,
 						rope.clone(),
 					)?;
@@ -238,72 +238,62 @@ fn model_query() -> &'static Query {
 }
 
 async fn add_root_py(path: PathBuf, _: ImStr) -> miette::Result<Output> {
-	let file = tokio::fs::read(&path)
+	let contents = tokio::fs::read(&path)
 		.await
 		.into_diagnostic()
 		.with_context(|| format_loc!("Could not read {}", path.display()))?;
 
 	let mut parser = tree_sitter::Parser::new();
 	parser.set_language(tree_sitter_python::language()).into_diagnostic()?;
 
-	let ast = parser.parse(&file, None).ok_or_else(|| diagnostic!("AST not parsed"))?;
+	let ast = parser
+		.parse(&contents, None)
+		.ok_or_else(|| diagnostic!("AST not parsed"))?;
 	let query = model_query();
 	let mut cursor = QueryCursor::new();
 
 	let mut out = vec![];
-	let rope = Rope::from_str(&String::from_utf8_lossy(&file));
-	let eq_slice = |range: std::ops::Range<usize>, slice: &[u8]| &file[range] == slice;
-	for match_ in cursor.matches(query, ast.root_node(), file.as_slice()) {
-		let mut captures = match_.captures;
-		let tail = match captures {
-			[models, _, tail @ ..] if eq_slice(models.node.byte_range(), b"models") => tail,
-			[_model, tail @ ..] => {
-				debug_assert!(matches!(&file[_model.node.byte_range()], b"Model" | b"TransientModel"));
-				tail
-			}
-			unk => Err(diagnostic!(
-				"Bug: Unknown pattern {:?}",
-				unk.iter()
-					.map(|capture| String::from_utf8_lossy(&file[capture.node.byte_range()]))
-					.collect::<Vec<_>>()
-			))?,
-		};
-		captures = tail;
-		let mut model = None;
-		while !captures.is_empty() {
-			match captures {
-				[_name, name, tail @ ..] if eq_slice(_name.node.byte_range(), b"_name") => {
-					captures = tail;
-					let name = name.node.byte_range().contract(1);
-					if name.is_empty() {
-						break;
-					}
-					model = Some(Model {
-						model: String::from_utf8_lossy(&file[name.clone()]).to_string(),
-						range: offset_range_to_lsp_range(name.map_unit(ByteOffset), rope.clone())
-							.ok_or_else(|| diagnostic!("name range"))?,
-						inherit: false,
-					});
+	let rope = Rope::from_str(&String::from_utf8_lossy(&contents));
+	'match_: for match_ in cursor.matches(query, ast.root_node(), contents.as_slice()) {
+		let mut inherits = vec![];
+		let mut range = None;
+		let mut maybe_base = None;
+		for capture in match_.captures {
+			if capture.index == 3 && maybe_base.is_none() {
+				// @name
+				let name = capture.node.byte_range().contract(1);
+				if name.is_empty() {
+					continue 'match_;
 				}
-				[_inherit, inherit, tail @ ..] if eq_slice(_inherit.node.byte_range(), b"_inherit") => {
-					captures = tail;
-					let inherit = inherit.node.byte_range().contract(1);
-					if inherit.is_empty() {
-						continue;
-					}
-					if model.is_none() {
-						model = Some(Model {
-							model: String::from_utf8_lossy(&file[inherit.clone()]).to_string(),
-							range: offset_range_to_lsp_range(inherit.map_unit(ByteOffset), rope.clone())
-								.ok_or_else(|| diagnostic!("inherit range"))?,
-							inherit: true,
-						});
-					}
+				maybe_base = Some(String::from_utf8_lossy(&contents[name]));
+			} else if capture.index == 5 {
+				// @inherit
+				let inherit = capture.node.byte_range().contract(1);
+				if !inherit.is_empty() {
+					inherits.push(ImStr::from(String::from_utf8_lossy(&contents[inherit]).as_ref()));
 				}
-				unk => Err(diagnostic!("Bug: Leftover captures: {unk:?}"))?,
+			} else if capture.index == 6 {
+				// @model
+				range = Some(capture.node.byte_range());
 			}
 		}
-		out.extend(model);
+		let range = offset_range_to_lsp_range(range.unwrap().map_unit(ByteOffset), rope.clone())
+			.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()),
+				range,
+			}),
+			(_, None) if !inherits.is_empty() => out.push(Model {
+				model: ModelId::Inherit(inherits.into_boxed_slice()),
+				range,
+			}),
+			(_, Some(base)) => out.push(Model {
+				model: ModelId::Base(base.as_ref().into()),
+				range,
+			}),
+			_ => {}
+		}
 	}
 
 	Ok(Output::Models {

src/main.rs

@@ -495,11 +495,11 @@ impl LanguageServer for Backend {
 		let models = models_by_prefix.iter_prefix(query.as_bytes()).flat_map(|(_, key)| {
 			self.module_index.models.get(key).into_iter().flat_map(|entry| {
 				entry.0.as_ref().map(|loc| SymbolInformation {
-					name: entry.key().clone(),
+					name: entry.key().to_string(),
 					kind: SymbolKind::CONSTANT,
 					tags: None,
 					deprecated: None,
-					location: loc.0.clone(),
+					location: loc.0.clone().into(),
 					container_name: None,
 				})
 			})
@@ -511,7 +511,7 @@ impl LanguageServer for Backend {
 				kind: SymbolKind::VARIABLE,
 				tags: None,
 				deprecated: None,
-				location: record.location.clone(),
+				location: record.location.clone().into(),
 				container_name: None,
 			}
 		}
@@ -579,7 +579,7 @@ impl Backend {
 				.await?;
 		}
 		self.client
-			.publish_diagnostics(params.uri.clone(), diagnostics, Some(params.version))
+			.publish_diagnostics(params.uri, diagnostics, Some(params.version))
 			.await;
 
 		Ok(())
@@ -736,7 +736,7 @@ impl Backend {
 				return Ok(None);
 			}
 		}
-		return Ok((self.module_index.records.get(value.as_ref())).map(|entry| entry.location.clone()));
+		return Ok((self.module_index.records.get(value.as_ref())).map(|entry| entry.location.clone().into()));
 	}
 	fn jump_def_model(&self, cursor_value: &str) -> miette::Result<Option<Location>> {
 		match self
@@ -745,20 +745,20 @@ impl Backend {
 			.get(cursor_value)
 			.and_then(|entry| entry.0.as_ref().cloned())
 		{
-			Some(ModelLocation(base)) => Ok(Some(base)),
+			Some(ModelLocation(base)) => Ok(Some(base.into())),
 			None => Ok(None),
 		}
 	}
 	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()).collect::<Vec<_>>(),
+			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()),
+				.map(|record| record.location.clone().into()),
 		);
 		Ok(Some(locations))
 	}
@@ -779,7 +779,7 @@ impl Backend {
 			.module_index
 			.records
 			.by_inherit_id(&inherit_id)
-			.map(|record| record.location.clone());
+			.map(|record| record.location.clone().into());
 		Ok(Some(locations.collect()))
 	}
 	async fn on_change_config(&self, config: Config) {

src/model.rs

@@ -1,22 +1,28 @@
 use std::{fmt::Display, ops::Deref, sync::Arc};
 
 use dashmap::DashMap;
-use log::warn;
 use qp_trie::{wrapper::BString, Trie};
 use tokio::sync::RwLock;
 use tower_lsp::lsp_types::{Location, Range, Url};
 
+use crate::utils::ImStr;
+
 #[derive(Clone, Debug)]
 pub struct Model {
-	pub model: String,
+	pub model: ModelId,
 	pub range: Range,
-	pub inherit: bool,
+}
+
+#[derive(Clone, Debug)]
+pub enum ModelId {
+	Base(ImStr),
+	Inherit(Box<[ImStr]>),
 }
 
 #[derive(Default, Clone)]
 pub struct ModelIndex {
-	inner: DashMap<String, (Option<ModelLocation>, Vec<ModelLocation>)>,
-	pub by_prefix: Arc<RwLock<Trie<BString, String>>>,
+	inner: DashMap<ImStr, (Option<ModelLocation>, Vec<ModelLocation>)>,
+	pub by_prefix: Arc<RwLock<Trie<BString, ImStr>>>,
 }
 
 #[derive(Clone)]
@@ -48,7 +54,7 @@ impl Display for ModelLocation {
 }
 
 impl Deref for ModelIndex {
-	type Target = DashMap<String, (Option<ModelLocation>, Vec<ModelLocation>)>;
+	type Target = DashMap<ImStr, (Option<ModelLocation>, Vec<ModelLocation>)>;
 
 	fn deref(&self) -> &Self::Target {
 		&self.inner
@@ -62,21 +68,27 @@ impl ModelIndex {
 	{
 		let mut by_prefix = self.by_prefix.write().await;
 		for item in items {
-			let mut entry = self.entry(item.model.to_string()).or_default();
-			if item.inherit {
-				by_prefix.insert_str(&item.model, item.model.to_string());
-				entry.1.push(ModelLocation(Location {
-					uri: uri.clone(),
-					range: item.range,
-				}));
-			} else if let Some(base) = &entry.0 {
-				warn!("{} already defined at {base}", entry.key());
-			} else {
-				by_prefix.insert_str(&item.model, item.model.to_string());
-				entry.0 = Some(ModelLocation(Location {
-					uri: uri.clone(),
-					range: item.range,
-				}))
+			match item.model {
+				ModelId::Base(base) => {
+					by_prefix.insert_str(&base, base.clone());
+					let mut location = Some(ModelLocation(Location {
+						uri: uri.clone(),
+						range: item.range,
+					}));
+					core::mem::swap(&mut self.entry(base.clone()).or_default().0, &mut location);
+					#[cfg(debug_assertions)]
+					if let Some(leftover) = location {
+						log::debug!("leftover base class {leftover}");
+					}
+				}
+				ModelId::Inherit(inherits) => {
+					for inherit in inherits.iter() {
+						self.entry(inherit.clone()).or_default().1.push(ModelLocation(Location {
+							uri: uri.clone(),
+							range: item.range,
+						}))
+					}
+				}
 			}
 		}
 	}

src/queries/model.scm

@@ -9,8 +9,9 @@
         (string) @name)?
       (assignment
         (identifier) @_inherit
-        (string) @inherit)?)))
-  (#eq? @_models "models")
-  (#match? @_Model "^(Transient)?Model$")
-  (#eq? @_name "_name")
-  (#eq? @_inherit "_inherit"))
+        [(string) @inherit
+         (list (string) @inherit)])?))) @model
+ (#eq? @_models "models")
+ (#match? @_Model "^(Transient)?Model$")
+ (#eq? @_name "_name")
+ (#eq? @_inherit "_inherit"))

src/queries/py_completions.scm

@@ -16,7 +16,8 @@
     (expression_statement
       (assignment
         (identifier) @_inherit
-        (string) @model))))
+        [(string) @model
+         (list (string) @model)]))))
  (#eq? @_inherit "_inherit"))
 
 ((call
@@ -25,6 +26,6 @@
   [(argument_list . (string) @model)
    (argument_list
     (keyword_argument (identifier) @_comodel_name (string) @model))])
-  (#eq? @_fields "fields")
-  (#eq? @_comodel_name "comodel_name")
-  (#match? @_Field "^(Many2one|One2many|Many2many)$"))
+ (#eq? @_fields "fields")
+ (#eq? @_comodel_name "comodel_name")
+ (#match? @_Field "^(Many2one|One2many|Many2many)$"))

src/queries/py_references.scm

@@ -16,16 +16,16 @@
     (expression_statement
       (assignment
         (identifier) @_field
-        (string) @model))))
-  (#match? @_field "^_(name|inherit)$"))
+        [(string) @model
+         (list (string) @model)]))))
+ (#match? @_field "^_(name|inherit)$"))
 
 ((call
   [(identifier) @_Field
    (attribute (identifier) @_fields (identifier) @_Field)]
   [(argument_list . (string) @model)
    (argument_list
     (keyword_argument (identifier) @_comodel_name (string) @model))])
-  (#eq? @_fields "fields")
-  (#eq? @_comodel_name "comodel_name")
-  (#match? @_Field "^(Many2one|One2many|Many2many)$"))
-
+ (#eq? @_fields "fields")
+ (#eq? @_comodel_name "comodel_name")
+ (#match? @_Field "^(Many2one|One2many|Many2many)$"))