feat: goto definitions for python fields

Author: Desdaemon

Cargo.lock

@@ -46,7 +46,6 @@ qp-trie = "0.8.1"
 lasso = { version = "0.7.2", features = ["multi-threaded"] }
 intmap = "2.0.0"
 libflate = "2.0.0"
-async-recursion = "1.0.4"
 
 [dev-dependencies]
 pretty_assertions = "1.4.0"

Cargo.toml

@@ -23,5 +23,5 @@ class Moo(models.Model):
 
     what = fields.Many2one(comodel_name='bar')
     def foo(self):
-        self.env['moo']
+        self.env['moo'].what
         request.render('generic_tax_report')

examples/two/test.py

@@ -1,6 +1,6 @@
 use std::{borrow::Borrow, collections::HashMap, sync::OnceLock};
 
-use async_recursion::async_recursion;
+use futures::executor::block_on;
 use log::debug;
 use tree_sitter::{Node, Query, QueryCursor};
 
@@ -82,7 +82,7 @@ fn field_completion() -> &'static Query {
 }
 
 impl Backend {
-	pub async fn model_of_range(
+	pub fn model_of_range(
 		&self,
 		node: Node<'_>,
 		range: ByteRange,
@@ -149,15 +149,15 @@ impl Backend {
 					let rhs = child.named_child(1)?;
 					if lhs.kind() == "identifier" {
 						let lhs = String::from_utf8_lossy(&contents[lhs.byte_range()]);
-						let type_ = self.type_of(rhs, &scope, contents).await?;
+						let type_ = self.type_of(rhs, &scope, contents)?;
 						scope.insert(lhs.into_owned(), type_);
 					}
 				}
 				"for_statement" => {
 					let iteratee = child.named_child(0)?;
 					let src = child.named_child(1)?;
 					if iteratee.kind() == "identifier" {
-						let type_ = self.type_of(src, &scope, contents).await?;
+						let type_ = self.type_of(src, &scope, contents)?;
 						if let Some(next) = children.peek().cloned() {
 							stack.push(next);
 						}
@@ -186,7 +186,7 @@ impl Backend {
 		// Phase 3: Determine type of cursor expression using recursive ascent
 		let mut descendant = Some(target?.descendant_for_byte_range(range.start.0, range.end.0)?);
 		while let Some(descendant_) = descendant {
-			match self.type_of(descendant_, &scope, contents).await {
+			match self.type_of(descendant_, &scope, contents) {
 				Some(Type::Model(model)) => {
 					return interner().get(model).map(Into::into);
 				}
@@ -204,9 +204,8 @@ impl Backend {
 		}
 		None
 	}
-	#[async_recursion(?Send)]
-	async fn type_of(&self, mut node: Node<'async_recursion>, scope: &Scope, contents: &[u8]) -> Option<Type> {
-		debug!("type_of {}", String::from_utf8_lossy(&contents[node.byte_range()]));
+	fn type_of(&self, mut node: Node, scope: &Scope, contents: &[u8]) -> Option<Type> {
+		// debug!("type_of {}", String::from_utf8_lossy(&contents[node.byte_range()]));
 		// What creates local scope, but doesn't contribute to method scope?
 		// 1. For-statements: only within the block
 		// 2. List comprehension: only within the object
@@ -230,23 +229,22 @@ impl Backend {
 		// 1. foo.bar;
 		//    foo: Model('t) => bar: Model('t).field('bar')
 		let interner = interner();
-		match normalize(&mut node).kind() {
+		let kind = normalize(&mut node).kind();
+		match kind {
 			"subscript" => {
 				let rhs = node.named_child(1)?;
+				let rhs_range = rhs.byte_range().contract(1);
 				if rhs.kind() != "string" {
 					return None;
 				}
-				let obj_ty = self.type_of(node.child(0)?, scope, contents).await?;
-				matches!(obj_ty, Type::Env).then(|| {
-					Type::Model(
-						String::from_utf8_lossy(&contents[rhs.byte_range().contract(1)])
-							.as_ref()
-							.into(),
-					)
-				})
+				let lhs = node.named_child(0)?;
+				let obj_ty = self.type_of(lhs, scope, contents)?;
+				matches!(obj_ty, Type::Env)
+					.then(|| Type::Model(String::from_utf8_lossy(&contents[rhs_range]).as_ref().into()))
 			}
 			"attribute" => {
-				let lhs = self.type_of(node.named_child(0)?, scope, contents).await?;
+				let lhs = node.named_child(0)?;
+				let lhs = self.type_of(lhs, scope, contents)?;
 				let rhs = node.named_child(1)?;
 				match &contents[rhs.byte_range()] {
 					b"env" if matches!(lhs, Type::Model(..) | Type::Record(..)) => Some(Type::Env),
@@ -276,7 +274,7 @@ impl Backend {
 						let ident = String::from_utf8_lossy(ident);
 						let ident = interner.get_or_intern(ident.as_ref());
 						let mut entry = self.index.models.get_mut(&model.into())?;
-						let fields = self.populate_field_names(&mut entry).await;
+						let fields = block_on(self.populate_field_names(&mut entry));
 						let field = fields.ok()?.get(&ident.into())?;
 						match field.kind {
 							FieldKind::Relational(model) => Some(Type::Model(interner.resolve(&model).into())),
@@ -292,11 +290,11 @@ impl Backend {
 			}
 			"assignment" => {
 				let rhs = node.named_child(1)?;
-				self.type_of(rhs, scope, contents).await
+				self.type_of(rhs, scope, contents)
 			}
 			"call" => {
 				let func = node.named_child(0)?;
-				let func = self.type_of(func, scope, contents).await?;
+				let func = self.type_of(func, scope, contents)?;
 				match func {
 					Type::RefFn => {
 						// (call (_) @func (argument_list . (string) @xml_id))

src/analyze.rs

@@ -5,6 +5,7 @@ use std::sync::atomic::{AtomicBool, AtomicUsize};
 
 use catch_panic::CatchPanic;
 use dashmap::{DashMap, DashSet};
+use futures::executor::block_on;
 use globwalk::FileType;
 use lasso::{Key, Spur};
 use log::{debug, error, info};
@@ -350,6 +351,7 @@ impl LanguageServer for Backend {
 		} else if ext == "py" {
 			location = self
 				.python_jump_def(params, document.value().clone())
+				.await
 				.map_err(|err| error!("Error retrieving references:\n{err}"))
 				.ok()
 				.flatten();
@@ -867,11 +869,11 @@ impl Backend {
 			None => Ok(None),
 		}
 	}
-	async fn jump_def_field_name(&self, field: &str, model: &str) -> miette::Result<Option<Location>> {
+	fn jump_def_field_name(&self, field: &str, model: &str) -> miette::Result<Option<Location>> {
 		let model = interner().get_or_intern(model);
 		let mut entry = some!(self.index.models.get_mut(&model.into()));
 		let field = some!(interner().get(field));
-		let fields = self.populate_field_names(&mut entry).await?;
+		let fields = block_on(self.populate_field_names(&mut entry))?;
 		let field = some!(fields.get(&field.into()));
 		Ok(Some(field.location.clone().into()))
 	}

src/main.rs

@@ -170,10 +170,12 @@ impl Backend {
 							break 'match_;
 						};
 						let lhs = some!(capture.node.prev_named_sibling());
-						let model = some!(
-							self.model_of_range(ast.root_node(), lhs.byte_range().map_unit(ByteOffset), None, &bytes)
-								.await
-						);
+						let model = some!(self.model_of_range(
+							ast.root_node(),
+							lhs.byte_range().map_unit(ByteOffset),
+							None,
+							&bytes
+						));
 						let model = interner().resolve(&model);
 						let needle = Cow::from(slice.byte_slice(..offset - range.start));
 						let range = range.map_unit(|unit| CharOffset(rope.byte_to_char(unit)));
@@ -189,7 +191,7 @@ impl Backend {
 		}
 		Ok(None)
 	}
-	pub fn python_jump_def(&self, params: GotoDefinitionParams, rope: Rope) -> miette::Result<Option<Location>> {
+	pub async fn python_jump_def(&self, params: GotoDefinitionParams, rope: Rope) -> miette::Result<Option<Location>> {
 		let uri = &params.text_document_position_params.text_document.uri;
 		let ast = self
 			.ast_map
@@ -232,6 +234,17 @@ impl Backend {
 						let slice = Cow::from(slice);
 						return self.jump_def_model(&slice);
 					}
+				} else if capture.index == 10 {
+					// @access
+					let range = capture.node.byte_range();
+					if range.contains(&offset) || range.end == offset {
+						let lhs = some!(capture.node.prev_named_sibling());
+						let lhs = lhs.byte_range().map_unit(ByteOffset);
+						let model = some!(self.model_of_range(ast.root_node(), lhs, None, &bytes));
+						let field = String::from_utf8_lossy(&bytes[range]);
+						let model = interner().resolve(&model);
+						return self.jump_def_field_name(&field, model);
+					}
 				}
 			}
 		}

src/python.rs

@@ -237,7 +237,7 @@ impl Backend {
 			Some(RefKind::Model) => self.jump_def_model(&cursor_value),
 			Some(RefKind::FieldName) => {
 				let model = some!(model_filter);
-				self.jump_def_field_name(&cursor_value, &model).await
+				self.jump_def_field_name(&cursor_value, &model)
 			}
 			Some(RefKind::Id) | None => Ok(None),
 		}