feat(ls): show information about fields when hovering over them.

plusvic · plusvic · commit 62736b6ea614 · 2026-04-13T15:55:50.000+02:00
diff --git a/ls/src/features/completion.rs b/ls/src/features/completion.rs
@@ -18,7 +18,7 @@ use crate::utils::cst_traversal::{
     rule_containing_token, token_at_position,
 };
 
-use crate::utils::modules::{get_struct, ty_to_string};
+use crate::utils::modules::{get_type, ty_to_string};
 
 const PATTERN_MODS: &[(SyntaxKind, &[&str])] = &[
     (
@@ -380,7 +380,7 @@ fn field_suggestions(token: &Token<Immutable>) -> Option<Vec<CompletionItem>> {
         _ => None,
     }?;
 
-    let current_struct = match get_struct(&token)? {
+    let current_struct = match get_type(&token)? {
         Type::Struct(s) => s,
         _ => return None,
     };
diff --git a/ls/src/features/hover.rs b/ls/src/features/hover.rs
@@ -4,16 +4,16 @@ use async_lsp::lsp_types::{
     HoverContents, MarkupContent, MarkupKind, Position, Url,
 };
 use itertools::Itertools;
-
+use yara_x::mods::reflect::Type;
 use yara_x_parser::cst::{Immutable, Node, NodeOrToken, SyntaxKind, Utf8};
 
 use crate::documents::storage::DocumentStorage;
 use crate::utils::cst_traversal::{
-    find_declaration, pattern_from_ident, rule_containing_token,
-    token_at_position,
+    find_declaration, pattern_from_ident, prev_non_trivia_token,
+    rule_containing_token, token_at_position,
 };
 
-use crate::utils::modules::{get_struct, ty_to_string};
+use crate::utils::modules::{get_type, ty_to_string};
 
 /// Builder for hover Markdown representation of a rule.
 struct RuleHoverBuilder {
@@ -106,37 +106,71 @@ pub fn hover(
         }
         // Other identifiers.
         SyntaxKind::IDENT => {
-            if let Some(yara_x::mods::reflect::Type::Func(func)) =
-                get_struct(&token)
-            {
-                let documentation = func
-                    .signatures
-                    .iter()
-                    .filter_map(|signature| {
-                        signature.doc().map(|doc| {
-                            format!(
-                                "### `{}({}) -> {}`\n\n***\n\n{}\n\n***\n\n",
-                                token.text(),
-                                signature
-                                    .args()
-                                    .map(|(name, ty)| format!(
-                                        "{}: {}",
-                                        name,
-                                        ty_to_string(ty)
-                                    ))
-                                    .join(", "),
-                                ty_to_string(signature.ret_type()),
-                                doc
-                            )
-                        })
-                    })
-                    .join("\n");
-
-                return Some(HoverContents::Markup(MarkupContent {
-                    kind: MarkupKind::Markdown,
-                    value: documentation,
-                }));
+            let structure = prev_non_trivia_token(&token)
+                .filter(|token| token.kind() == SyntaxKind::DOT)
+                .and_then(|token| prev_non_trivia_token(&token))
+                .and_then(|token| get_type(&token))
+                .and_then(|ty| {
+                    if let Type::Struct(s) = ty { Some(s) } else { None }
+                });
+
+            let field = structure
+                .as_ref()
+                .and_then(|s| s.fields().find(|f| f.name() == token.text()));
+
+            if let Some(field) = field {
+                match field.ty() {
+                    Type::Func(func) => {
+                        let documentation = func
+                                .signatures
+                                .iter()
+                                .filter_map(|signature| {
+                                    signature.doc().map(|doc| {
+                                        format!(
+                                            "### `{}({}) -> {}`\n\n***\n\n{}\n\n***\n\n",
+                                            token.text(),
+                                            signature
+                                                .args()
+                                                .map(|(arg_name, arg_ty)| format!(
+                                                    "{}: {}",
+                                                    arg_name,
+                                                    ty_to_string(arg_ty)
+                                                ))
+                                                .join(", "),
+                                            ty_to_string(signature.ret_type()),
+                                            doc
+                                        )
+                                    })
+                                })
+                                .join("\n");
+
+                        if !documentation.is_empty() {
+                            return Some(HoverContents::Markup(
+                                MarkupContent {
+                                    kind: MarkupKind::Markdown,
+                                    value: documentation,
+                                },
+                            ));
+                        }
+                    }
+                    ty => {
+                        let mut value = format!(
+                            "### `{}: {}`",
+                            token.text(),
+                            ty_to_string(&ty)
+                        );
+                        if let Some(d) = field.doc() {
+                            value
+                                .push_str(&format!("\n\n***\n\n{}\n\n***", d));
+                        }
+                        return Some(HoverContents::Markup(MarkupContent {
+                            kind: MarkupKind::Markdown,
+                            value,
+                        }));
+                    }
+                }
             }
+
             if let Some((_, n)) = find_declaration(&token) {
                 let text = n
                     .children_with_tokens()
diff --git a/ls/src/features/signature_help.rs b/ls/src/features/signature_help.rs
@@ -4,7 +4,7 @@ use crate::{
     documents::storage::DocumentStorage,
     utils::{
         cst_traversal::{prev_non_trivia_token, token_at_position},
-        modules::{get_struct, ty_to_string},
+        modules::{get_type, ty_to_string},
     },
 };
 use async_lsp::lsp_types::{
@@ -54,7 +54,7 @@ pub fn signature_help(
 
     let last_ident = curr?;
 
-    let func = match get_struct(&last_ident) {
+    let func = match get_type(&last_ident) {
         Some(Type::Func(func)) => Some(func),
         _ => None,
     }?;
diff --git a/ls/src/tests/mod.rs b/ls/src/tests/mod.rs
@@ -296,6 +296,7 @@ async fn hover() {
     test_lsp_request::<_, HoverRequest>("hover8.yar").await;
     test_lsp_request::<_, HoverRequest>("hover9.yar").await;
     test_lsp_request::<_, HoverRequest>("hover10.yar").await;
+    test_lsp_request::<_, HoverRequest>("hover11.yar").await;
 }
 
 #[tokio::test]
diff --git a/ls/src/tests/testdata/hover11.request.json b/ls/src/tests/testdata/hover11.request.json
@@ -0,0 +1,9 @@
+{
+  "textDocument": {
+    "uri": "${test_dir}/hover11.yar"
+  },
+  "position": {
+    "line": 4,
+    "character": 9
+  }
+}
diff --git a/ls/src/tests/testdata/hover11.response.json b/ls/src/tests/testdata/hover11.response.json
@@ -0,0 +1,6 @@
+{
+  "contents": {
+    "kind": "markdown",
+    "value": "### `is_pe: bool`\n\n***\n\nTrue if the file is a valid PE binary.\n\n***"
+  }
+}
diff --git a/ls/src/tests/testdata/hover11.yar b/ls/src/tests/testdata/hover11.yar
@@ -0,0 +1,6 @@
+import "pe"
+
+rule test {
+  condition:
+    pe.is_pe
+}
diff --git a/ls/src/utils/modules.rs b/ls/src/utils/modules.rs
@@ -24,10 +24,10 @@ pub enum Segment {
 ///
 /// Returns an `Option<Type>` representing the type of the structure or field
 /// identified by the token. Returns `None` if the type cannot be determined.
-pub fn get_struct(token: &Token<Immutable>) -> Option<Type> {
+pub fn get_type(token: &Token<Immutable>) -> Option<Type> {
     let mut path = Vec::new();
-
     let mut curr = Some(token.clone());
+
     while let Some(token) = curr {
         match token.kind() {
             SyntaxKind::IDENT => {
@@ -40,7 +40,6 @@ pub fn get_struct(token: &Token<Immutable>) -> Option<Type> {
                         path.into_iter().rev(),
                     );
                 }
-
                 path.push(Segment::Field(token.text().to_string()));
                 // Look for previous DOT
                 if let Some(prev) = prev_non_trivia_token(&token)
@@ -106,6 +105,7 @@ pub fn get_struct(token: &Token<Immutable>) -> Option<Type> {
             }
         }
     }
+
     Some(current_kind)
 }
 
@@ -143,7 +143,7 @@ pub fn get_type_from_declaration(
                     continue;
                 }
 
-                let mut current_type = get_struct(&with_decl.last_token()?)?;
+                let mut current_type = get_type(&with_decl.last_token()?)?;
 
                 for segment in path {
                     match segment {
@@ -177,8 +177,7 @@ pub fn get_type_from_declaration(
                 .into_token()?;
 
             let iterable_last_token = prev_non_trivia_token(&colon)?;
-
-            let iterable_type = get_struct(&iterable_last_token)?;
+            let iterable_type = get_type(&iterable_last_token)?;
 
             let mut current_type = match iterable_type {
                 Type::Array(inner) => *inner,

Original file line number	Diff line number	Diff line change
`@@ -296,6 +296,7 @@ async fn hover() {`
`296`	`296`	`test_lsp_request::<_, HoverRequest>("hover8.yar").await;`
`297`	`297`	`test_lsp_request::<_, HoverRequest>("hover9.yar").await;`
`298`	`298`	`test_lsp_request::<_, HoverRequest>("hover10.yar").await;`
	`299`	`+ test_lsp_request::<_, HoverRequest>("hover11.yar").await;`
`299`	`300`	`}`
`300`	`301`
`301`	`302`	`#[tokio::test]`