feat(js): base for js completions (#79)

* feat(js): base for js completions

support for this.orm.call #67

* feat(js): use existing methods

Author: gbrito

Cargo.lock

@@ -1,12 +1,33 @@
 use std::borrow::Cow;
 
 use tower_lsp_server::lsp_types::*;
+use tree_sitter::{QueryCursor, Tree};
 
 use crate::prelude::*;
 
 use crate::backend::Backend;
 use crate::backend::Text;
-use crate::index::JsQuery;
+use crate::index::{_G, JsQuery};
+use crate::model::PropertyKind;
+use crate::utils::{ByteOffset, MaxVec, RangeExt, span_conv};
+use tracing::instrument;
+use ts_macros::query;
+
+query! {
+	#[lang = "tree_sitter_javascript"]
+	OrmCallQuery(OrmObject, CallMethod, ModelArg, MethodArg);
+	// Match this.orm.call('model', 'method')
+	(call_expression
+		function: (member_expression
+			object: (member_expression
+				object: (this)
+				property: (property_identifier) @ORM_OBJECT (#eq? @ORM_OBJECT "orm"))
+			property: (property_identifier) @CALL_METHOD (#eq? @CALL_METHOD "call"))
+		arguments: (arguments
+			. (string) @MODEL_ARG
+			. ","
+			. (string) @METHOD_ARG))
+}
 
 impl Backend {
 	pub fn on_change_js(
@@ -116,4 +137,139 @@ impl Backend {
 
 		Ok(None)
 	}
+
+	#[instrument(skip_all)]
+	pub async fn js_completions(
+		&self,
+		params: CompletionParams,
+		ast: Tree,
+		rope: RopeSlice<'_>,
+	) -> anyhow::Result<Option<CompletionResponse>> {
+		let uri = &params.text_document_position.text_document.uri;
+		let position = params.text_document_position.position;
+		let Ok(ByteOffset(offset)) = rope_conv(position, rope) else {
+			return Err(errloc!("could not find offset for {}", uri.path().as_str()));
+		};
+
+		let contents = Cow::from(rope);
+		let contents = contents.as_bytes();
+		let query = OrmCallQuery::query();
+		let mut cursor = QueryCursor::new();
+
+		// Find the orm.call node that contains the cursor position
+		for match_ in cursor.matches(query, ast.root_node(), contents) {
+			let mut model_arg_node = None;
+			let mut method_arg_node = None;
+
+			for capture in match_.captures {
+				match OrmCallQuery::from(capture.index) {
+					Some(OrmCallQuery::ModelArg) => {
+						model_arg_node = Some(capture.node);
+					}
+					Some(OrmCallQuery::MethodArg) => {
+						method_arg_node = Some(capture.node);
+					}
+					_ => {}
+				}
+			}
+
+			// Check if cursor is within the model argument
+			if let Some(model_node) = model_arg_node {
+				let range = model_node.byte_range();
+				if range.contains(&offset) {
+					// Extract the current prefix (excluding quotes)
+					let inner_range = range.shrink(1);
+					let prefix = String::from_utf8_lossy(&contents[inner_range.start..offset]);
+					let lsp_range = span_conv(model_node.range());
+					let mut items = MaxVec::new(100);
+					self.index.complete_model(&prefix, lsp_range, &mut items)?;
+
+					return Ok(Some(CompletionResponse::List(CompletionList {
+						is_incomplete: false,
+						items: items.into_inner(),
+					})));
+				}
+			}
+
+			// Check if cursor is within the method argument
+			if let Some(method_node) = method_arg_node {
+				let range = method_node.byte_range();
+				if range.contains(&offset) {
+					// Extract the model name from the first argument
+					if let Some(model_node) = model_arg_node {
+						let model_range = model_node.byte_range().shrink(1);
+						let model_name = String::from_utf8_lossy(&contents[model_range]).to_string();
+
+						// Extract the current method prefix (excluding quotes)
+						let inner_range = range.clone().shrink(1);
+						let prefix = String::from_utf8_lossy(&contents[inner_range.start..offset]);
+
+						let byte_range = ByteOffset(range.start)..ByteOffset(range.end);
+
+						let mut items = MaxVec::new(100);
+						self.index.complete_property_name(
+							&prefix,
+							byte_range,
+							model_name,
+							rope,
+							Some(PropertyKind::Method),
+							true,
+							&mut items,
+						)?;
+
+						return Ok(Some(CompletionResponse::List(CompletionList {
+							is_incomplete: false,
+							items: items.into_inner(),
+						})));
+					}
+				}
+			}
+
+			// Check if cursor is in a position where we should start a new string argument
+			// This handles cases where the user is typing after the comma but hasn't started the string yet
+			if let Some(model_node) = model_arg_node {
+				let model_end = model_node.byte_range().end;
+				// Look for comma after model argument
+				let mut i = model_end;
+				while i < contents.len() && contents[i].is_ascii_whitespace() {
+					i += 1;
+				}
+				if i < contents.len() && contents[i] == b',' {
+					i += 1;
+					// Skip whitespace after comma
+					while i < contents.len() && contents[i].is_ascii_whitespace() {
+						i += 1;
+					}
+					// If cursor is at or after this position and before any method argument
+					if offset >= i
+						&& (method_arg_node.is_none() || offset < method_arg_node.unwrap().byte_range().start)
+					{
+						// We're completing the method name
+						let model_range = model_node.byte_range().shrink(1);
+						let model_name = String::from_utf8_lossy(&contents[model_range]).to_string();
+
+						let synthetic_range = ByteOffset(i)..ByteOffset(offset.max(i));
+
+						let mut items = MaxVec::new(100);
+						self.index.complete_property_name(
+							"",
+							synthetic_range,
+							model_name,
+							rope,
+							Some(PropertyKind::Method),
+							true,
+							&mut items,
+						)?;
+
+						return Ok(Some(CompletionResponse::List(CompletionList {
+							is_incomplete: false,
+							items: items.into_inner(),
+						})));
+					}
+				}
+			}
+		}
+
+		Ok(None)
+	}
 }

src/js.rs

@@ -417,6 +417,24 @@ impl LanguageServer for Backend {
 					Ok(None)
 				}
 			}
+		} else if ext == "js" {
+			let ast = {
+				let Some(ast) = self.ast_map.get(uri.path().as_str()) else {
+					debug!("Bug: did not build AST for {}", uri.path().as_str());
+					return Ok(None);
+				};
+				ast.value().clone()
+			};
+			let completions = self.js_completions(params, ast, rope.slice(..)).await;
+			match completions {
+				Ok(ret) => Ok(ret),
+				Err(err) => {
+					self.client
+						.show_message(MessageType::ERROR, format!("error during js completion:\n{err}"))
+						.await;
+					Ok(None)
+				}
+			}
 		} else {
 			debug!("(completion) unsupported {}", uri.path().as_str());
 			Ok(None)

src/server.rs

@@ -12,6 +12,7 @@ build = "build.rs"
 async-lsp = { version = "0.2.2", features = ["tokio", "forward"] }
 tokio-util = { version = "0.7.14", features = ["compat"] }
 tree-sitter-xml = "0.7.0"
+tree-sitter-javascript = "0.23.1"
 rstest = "0.25.0"
 ts-macros.workspace = true
 pretty_assertions.workspace = true

testing/Cargo.toml

@@ -0,0 +1,7 @@
+{
+  "module": {
+    "roots": [
+      "."
+    ]
+  }
+}

testing/fixtures/js_completion/.odoo_lsp

@@ -0,0 +1 @@
+{"name": "test_module"}

testing/fixtures/js_completion/test_module/__manifest__.py

@@ -0,0 +1,14 @@
+/** @odoo-module **/
+
+export class TestWidget extends Component {
+    static template = "test_module.TestWidget";
+
+    async onButtonClick() {
+        const result = await this.orm.call('test', 'test_method');
+        //                                  ^complete test.model
+
+        // Test method name completion
+        const result2 = await this.orm.call('test.model', 'an');
+        //                                                  ^complete another_method
+    }
+}

testing/fixtures/js_completion/test_module/javascript.js

@@ -0,0 +1,14 @@
+from odoo import models, fields, api
+
+
+class TestModel(models.Model):
+    _name = "test.model"
+    _description = "Test Model"
+
+    name = fields.Char()
+
+    def test_method(self):
+        return True
+
+    def another_method(self, param):
+        return param

testing/fixtures/js_completion/test_module/models.py

@@ -55,6 +55,7 @@ async fn fixture_test(#[files("fixtures/*")] root: PathBuf) {
 	// <!> collect expected samples
 	let mut expected = gather_expected(&root, TestLanguages::Python);
 	expected.extend(gather_expected(&root, TestLanguages::Xml));
+	expected.extend(gather_expected(&root, TestLanguages::JavaScript));
 	expected.retain(|_, expected| {
 		!expected.complete.is_empty()
 			|| !expected.diag.is_empty()
@@ -77,6 +78,7 @@ async fn fixture_test(#[files("fixtures/*")] root: PathBuf) {
 				let language_id = match path.extension().unwrap().to_string_lossy().as_ref() {
 					"py" => "python",
 					"xml" => "xml",
+					"js" => "javascript",
 					unk => panic!("unknown file extension {unk}"),
 				}
 				.to_string();
@@ -318,6 +320,21 @@ fn xml_query() -> &'static Query {
 	QUERY.get_or_init(|| Query::new(&tree_sitter_xml::LANGUAGE_XML.into(), XML_QUERY).unwrap())
 }
 
+fn js_query() -> &'static Query {
+	static QUERY: OnceLock<Query> = OnceLock::new();
+	const JS_QUERY: &str = r#"
+		((comment) @diag
+		(#match? @diag "\\^diag "))
+
+		((comment) @complete
+		(#match? @complete "\\^complete "))
+
+		((comment) @def
+		(#match? @def "\\^def"))
+	"#;
+	QUERY.get_or_init(|| Query::new(&tree_sitter_javascript::LANGUAGE.into(), JS_QUERY).unwrap())
+}
+
 #[derive(Default)]
 struct Expected {
 	diag: Vec<(Position, String)>,
@@ -329,6 +346,7 @@ struct Expected {
 enum TestLanguages {
 	Python,
 	Xml,
+	JavaScript,
 }
 
 enum InspectType {}
@@ -342,6 +360,7 @@ fn gather_expected(root: &Path, lang: TestLanguages) -> HashMap<PathBuf, Expecte
 	let (glob, query, language) = match lang {
 		TestLanguages::Python => ("**/*.py", PyExpected::query as fn() -> _, tree_sitter_python::LANGUAGE),
 		TestLanguages::Xml => ("**/*.xml", xml_query as _, tree_sitter_xml::LANGUAGE_XML),
+		TestLanguages::JavaScript => ("**/*.js", js_query as _, tree_sitter_javascript::LANGUAGE),
 	};
 
 	let path = root.join(glob).to_string_lossy().into_owned();
@@ -358,7 +377,11 @@ fn gather_expected(root: &Path, lang: TestLanguages) -> HashMap<PathBuf, Expecte
 
 		for (match_, _) in cursor.captures(query(), ast.root_node(), &contents[..]) {
 			for capture in match_.captures {
-				let skip = if matches!(lang, TestLanguages::Xml) { 4 } else { 1 };
+				let skip = match lang {
+					TestLanguages::Xml => 4,
+					TestLanguages::JavaScript => 2, // Skip "//"
+					TestLanguages::Python => 1,     // Skip "#"
+				};
 				let text = &contents[capture.node.byte_range()][skip..];
 				let Some(idx) = text.iter().position(|ch| *ch == b'^') else {
 					continue;