feat: field completions

Author: Desdaemon

examples/two/test.py

@@ -6,11 +6,12 @@ class Foo(Model):
 class Bar(Model):
     _name = 'bar'
     _description = 'asd'
+    barr = Boolean()
+    bark = Char()
 
 class Baz(models.Model):
     _inherit = 'bar'
-
-    foo = Char()
+    foo = fields.Char()
 
 class Quux(models.Model):
     _name = 'quux'

examples/two/views/templates.xml

@@ -1,5 +1,5 @@
 <odoo>
-  <record id="another" model='quux'>
-    <field name='what'></field>
+  <record id="another" model='bar'>
+    <field name='barr'></field>
   </record>
 </odoo>

src/index.rs

@@ -262,17 +262,16 @@ async fn add_root_py(path: PathBuf, _: Arc<ThreadedRodeo>) -> miette::Result<Out
 					continue 'match_;
 				}
 				maybe_base = Some(String::from_utf8_lossy(&contents[name.clone()]));
-				range = Some(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()));
 				}
-			// } else if capture.index == 6 {
+			// } else if capture.index == 7 {
 			// 	// @field
 			// 	current_field = Some(capture.node.byte_range());
-			// } else if capture.index == 9 {
+			// } else if capture.index == 10 {
 			// 	// @relation
 			// 	if let Some(current_field) = current_field.take() {
 			// 		let field = String::from_utf8_lossy(&contents[current_field]);
@@ -282,7 +281,7 @@ async fn add_root_py(path: PathBuf, _: Arc<ThreadedRodeo>) -> miette::Result<Out
 			// 		let field_relation = interner.get_or_intern(field_relation.as_ref());
 			// 		fields.push((field, Field::Relational(field_relation)));
 			// 	}
-			// } else if capture.index == 11 {
+			// } else if capture.index == 12 {
 			// 	// @_Type
 			// 	if let Some(current_field) = current_field.take() {
 			// 		let field = String::from_utf8_lossy(&contents[current_field]);
@@ -297,38 +296,40 @@ async fn add_root_py(path: PathBuf, _: Arc<ThreadedRodeo>) -> miette::Result<Out
 			}
 		}
 		let Some(range) = range else { continue };
-		let range = offset_range_to_lsp_range(range.map_unit(ByteOffset), rope.clone())
-			.ok_or_else(|| diagnostic!("model out of bounds"))?;
-		let mut has_primary = false;
+		let range = range.map_unit(ByteOffset);
+		let lsp_range =
+			offset_range_to_lsp_range(range.clone(), rope.clone()).ok_or_else(|| diagnostic!("model out of bounds"))?;
+		let mut has_primary = inherits.len() == 1;
 		if !inherits.is_empty() {
 			// Rearranges the primary inherit to the first index
 			if let Some(maybe_base) = &maybe_base {
 				if let Some(position) = inherits.iter().position(|inherit| inherit == maybe_base) {
 					inherits.swap(position, 0);
 					has_primary = true;
+				} else {
+					has_primary = false;
 				}
 			}
 		}
-		let fields = vec![];
 		match (inherits.as_slice(), maybe_base) {
 			([_, ..], None) => out.push(Model {
-				model: ModelId::Inherit { inherits, has_primary },
-				range,
-				fields,
+				model: ModelId::Inherit(inherits),
+				range: lsp_range,
+				byte_range: range,
 			}),
 			([], None) => {}
 			(_, Some(base)) => {
 				if has_primary {
 					out.push(Model {
-						model: ModelId::Inherit { inherits, has_primary },
-						range,
-						fields,
+						model: ModelId::Inherit(inherits),
+						range: lsp_range,
+						byte_range: range,
 					});
 				} else {
 					out.push(Model {
 						model: ModelId::Base(base.as_ref().into()),
-						range,
-						fields,
+						range: lsp_range,
+						byte_range: range,
 					})
 				}
 			}

src/main.rs

@@ -26,6 +26,7 @@ use odoo_lsp::utils::isolate::Isolate;
 use odoo_lsp::{format_loc, utils::*};
 
 mod catch_panic;
+mod partial;
 mod python;
 mod xml;
 
@@ -695,19 +696,26 @@ impl Backend {
 		items.extend(matches);
 		Ok(())
 	}
-	fn complete_field_name(
+	async fn complete_field_name(
 		&self,
 		needle: &str,
 		range: std::ops::Range<CharOffset>,
 		model: String,
 		rope: Rope,
+		partial_token: Option<ProgressToken>,
 		items: &mut Vec<CompletionItem>,
 	) -> miette::Result<()> {
-		let Some(entry) = self.module_index.models.get(model.as_str()) else {
+		let Some(mut entry) = self.module_index.models.get_mut(model.as_str()) else {
 			return Ok(());
 		};
 		let range = char_range_to_lsp_range(range, rope).ok_or_else(|| diagnostic!("range"))?;
-		let completions = entry.fields.iter().flat_map(|(key, _)| {
+		let fields = if let Some(fields) = &entry.fields {
+			fields
+		} else {
+			let fields = self.populate_field_names(&entry, partial_token, range).await?;
+			entry.fields.insert(fields)
+		};
+		let completions = fields.iter().flat_map(|(key, _)| {
 			let field_name = self
 				.module_index
 				.interner
@@ -779,7 +787,7 @@ impl Backend {
 			.get(model)
 			.and_then(|entry| entry.base.as_ref().cloned())
 		{
-			Some(ModelLocation(base)) => Ok(Some(base.into())),
+			Some(ModelLocation(base, _)) => Ok(Some(base.into())),
 			None => Ok(None),
 		}
 	}

src/model.rs

@@ -2,24 +2,27 @@ use std::{fmt::Display, ops::Deref, sync::Arc};
 
 use dashmap::DashMap;
 use intmap::IntMap;
-use lasso::{Key, Spur};
+use lasso::Spur;
 use qp_trie::{wrapper::BString, Trie};
 use tokio::sync::RwLock;
 use tower_lsp::lsp_types::Range;
 
-use crate::{utils::MinLoc, ImStr};
+use crate::{
+	utils::{ByteOffset, MinLoc},
+	ImStr,
+};
 
 #[derive(Clone, Debug)]
 pub struct Model {
 	pub model: ModelId,
 	pub range: Range,
-	pub fields: Vec<(Spur, Field)>,
+	pub byte_range: std::ops::Range<ByteOffset>,
 }
 
 #[derive(Clone, Debug)]
 pub enum ModelId {
 	Base(ImStr),
-	Inherit { inherits: Vec<ImStr>, has_primary: bool },
+	Inherit(Vec<ImStr>),
 }
 
 #[derive(Default, Clone)]
@@ -32,7 +35,7 @@ pub struct ModelIndex {
 pub struct ModelEntry {
 	pub base: Option<ModelLocation>,
 	pub descendants: Vec<ModelLocation>,
-	pub fields: IntMap<Field>,
+	pub fields: Option<IntMap<Field>>,
 }
 
 #[derive(Clone, Debug)]
@@ -42,7 +45,7 @@ pub enum Field {
 }
 
 #[derive(Clone)]
-pub struct ModelLocation(pub MinLoc);
+pub struct ModelLocation(pub MinLoc, pub std::ops::Range<ByteOffset>);
 
 impl Display for ModelLocation {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -85,27 +88,23 @@ impl ModelIndex {
 				ModelId::Base(base) => {
 					by_prefix.insert_str(&base, base.clone());
 					let mut entry = self.entry(base.clone()).or_default();
-					entry.base = Some(ModelLocation(MinLoc {
-						path: path.clone(),
-						range: item.range,
-					}));
-					for (field, type_) in item.fields {
-						entry.fields.insert(field.into_usize() as u64, type_);
-					}
-				}
-				ModelId::Inherit { inherits, has_primary } => {
-					if has_primary {
-						let primary = &inherits[0];
-						let mut entry = self.entry(primary.clone()).or_default();
-						for (field, type_) in item.fields {
-							entry.fields.insert(field.into_usize() as u64, type_);
-						}
-					}
-					for inherit in inherits {
-						self.entry(inherit).or_default().descendants.push(ModelLocation(MinLoc {
+					entry.base = Some(ModelLocation(
+						MinLoc {
 							path: path.clone(),
 							range: item.range,
-						}));
+						},
+						item.byte_range,
+					));
+				}
+				ModelId::Inherit(inherits) => {
+					for inherit in inherits {
+						self.entry(inherit).or_default().descendants.push(ModelLocation(
+							MinLoc {
+								path: path.clone(),
+								range: item.range,
+							},
+							item.byte_range.clone(),
+						));
 					}
 				}
 			}

src/partial.rs

@@ -0,0 +1,35 @@
+use std::marker::PhantomData;
+
+use serde::{Deserialize, Serialize};
+use tower_lsp::{
+	lsp_types::{notification::Notification, CompletionResponse, ProgressToken},
+	Client,
+};
+
+#[derive(Debug)]
+pub struct Partial<T>(PhantomData<T>);
+
+impl<T> Notification for Partial<T>
+where
+	T: Serialize + for<'de> Deserialize<'de>,
+{
+	type Params = PartialParams<T>;
+	const METHOD: &'static str = "$/progress";
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct PartialParams<T> {
+	pub token: ProgressToken,
+	pub value: T,
+}
+
+pub async fn emit_partial<T, U>(client: &Client, token: ProgressToken, value: U)
+where
+	T: Notification<Params = PartialParams<U>>,
+{
+	_ = client.send_notification::<T>(PartialParams { token, value }).await;
+}
+
+/// If the first response is [CompletionResponse::List],
+/// subsequent [CompletionResponse::Array] responses add to the original list.
+pub type PartialCompletions = Partial<CompletionResponse>;