add support for hover based on comments

Author: coder3101

Cargo.lock

@@ -11,6 +11,6 @@ tokio-util = { version = "0.7.11", features = ["compat"] }
 tower = "0.4.13"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
-tree-sitter-proto = { git = "https://github.com/mitchellh/tree-sitter-proto", rev = "42d82fa18f8afe59b5fc0b16c207ee4f84cb185f" }
-tree-sitter = "0.19.3"
+tree-sitter-proto = { git = "https://github.com/coder3101/tree-sitter-proto", branch = "main" }
+tree-sitter = "0.22.6"
 tracing-appender = "0.2.3"

Cargo.toml

@@ -5,8 +5,8 @@ use tracing::{debug, info};
 use async_lsp::lsp_types::{
     DidChangeTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
     GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents, HoverParams,
-    InitializeParams, InitializeResult, MarkedString, OneOf, ServerCapabilities, ServerInfo,
-    TextDocumentSyncCapability, TextDocumentSyncKind,
+    HoverProviderCapability, InitializeParams, InitializeResult, MarkedString, OneOf,
+    ServerCapabilities, ServerInfo, TextDocumentSyncCapability, TextDocumentSyncKind,
 };
 use async_lsp::{ErrorCode, LanguageServer, ResponseError};
 use futures::future::BoxFuture;
@@ -39,6 +39,7 @@ impl LanguageServer for ServerState {
                     TextDocumentSyncKind::FULL,
                 )),
                 definition_provider: Some(OneOf::Left(true)),
+                hover_provider: Some(HoverProviderCapability::Simple(true)),
                 ..ServerCapabilities::default()
             },
             server_info: Some(ServerInfo {
@@ -50,17 +51,46 @@ impl LanguageServer for ServerState {
         Box::pin(async move { Ok(response) })
     }
 
-    fn hover(&mut self, _: HoverParams) -> BoxFuture<'static, Result<Option<Hover>, Self::Error>> {
-        let counter = self.counter;
-        Box::pin(async move {
-            tokio::time::sleep(Duration::from_secs(1)).await;
-            Ok(Some(Hover {
-                contents: HoverContents::Scalar(MarkedString::String(format!(
-                    "I am a hover text {counter}!"
-                ))),
+    fn hover(
+        &mut self,
+        param: HoverParams,
+    ) -> BoxFuture<'static, Result<Option<Hover>, Self::Error>> {
+        let uri = param.text_document_position_params.text_document.uri;
+        let pos = param.text_document_position_params.position;
+
+        let Some(contents) = self.documents.get(&uri) else {
+            return Box::pin(async move {
+                Err(ResponseError::new(
+                    ErrorCode::INVALID_REQUEST,
+                    "uri was never opened",
+                ))
+            });
+        };
+
+        let Some(parsed) = self.parser.parse(contents.as_bytes()) else {
+            return Box::pin(async move {
+                Err(ResponseError::new(
+                    ErrorCode::REQUEST_FAILED,
+                    "ts failed to parse contents",
+                ))
+            });
+        };
+
+        let comments = parsed.hover(&pos, contents.as_bytes());
+        info!("Found {} node comments in the document", comments.len());
+        let response = match comments.len() {
+            0 => None,
+            1 => Some(Hover {
+                contents: HoverContents::Scalar(comments[0].clone()),
+                range: None,
+            }),
+            2.. => Some(Hover {
+                contents: HoverContents::Array(comments),
                 range: None,
-            }))
-        })
+            }),
+        };
+
+        Box::pin(async move { Ok(response) })
     }
 
     fn definition(
@@ -88,7 +118,7 @@ impl LanguageServer for ServerState {
             });
         };
 
-        let locations = parsed.definition_for(&pos, &uri, contents.as_bytes());
+        let locations = parsed.definition(&pos, &uri, contents.as_bytes());
         info!("Found {} matching nodes in the document", locations.len());
 
         let response = match locations.len() {

src/lsp.rs

@@ -1,4 +1,4 @@
-use async_lsp::lsp_types::{Location, Position, Range, Url};
+use async_lsp::lsp_types::{Location, MarkedString, Position, Range, Url};
 use tracing::info;
 use tree_sitter::{Node, Tree, TreeCursor};
 
@@ -15,7 +15,7 @@ pub struct ParsedTree {
 impl ProtoParser {
     pub fn new() -> Self {
         let mut parser = tree_sitter::Parser::new();
-        if let Err(e) = parser.set_language(tree_sitter_proto::language()) {
+        if let Err(e) = parser.set_language(&tree_sitter_proto::language()) {
             panic!("failed to set ts language parser {:?}", e);
         }
         Self { parser }
@@ -41,7 +41,11 @@ impl ParsedTree {
             .map(|n| n.utf8_text(content.as_ref()).expect("utf-8 parse error"))
     }
 
-    fn walk_and_collect_kinds<'a>(&self, cursor: &mut TreeCursor<'a>, kinds: &[&str]) -> Vec<Node<'a>> {
+    fn walk_and_collect_kinds<'a>(
+        &self,
+        cursor: &mut TreeCursor<'a>,
+        kinds: &[&str],
+    ) -> Vec<Node<'a>> {
         let mut v = vec![];
 
         loop {
@@ -64,12 +68,69 @@ impl ParsedTree {
         v
     }
 
+    fn advance_cursor_to<'a>(&self, cursor: &mut TreeCursor<'a>, nid: usize) -> bool {
+        loop {
+            let node = cursor.node();
+            if node.id() == nid {
+                return true;
+            }
+            if cursor.goto_first_child() {
+                if self.advance_cursor_to(cursor, nid) {
+                    return true;
+                }
+                cursor.goto_parent();
+            }
+            if !cursor.goto_next_sibling() {
+                return false;
+            }
+        }
+    }
+
+    fn find_preceeding_comments(&self, nid: usize, content: impl AsRef<[u8]>) -> Option<String> {
+        let root = self.tree.root_node();
+        let mut cursor = root.walk();
+
+        info!("Looking for node with id: {nid}");
+
+        self.advance_cursor_to(&mut cursor, nid);
+        if !cursor.goto_parent() {
+            return None;
+        }
+
+        if !cursor.goto_previous_sibling() {
+            return None;
+        }
+
+        let mut comments = vec![];
+        while cursor.node().kind() == "comment" {
+            let node = cursor.node();
+            let text = node
+                .utf8_text(content.as_ref())
+                .expect("utf-8 parser error")
+                .trim()
+                .trim_start_matches("//")
+                .trim();
+
+            comments.push(text);
+
+            if !cursor.goto_previous_sibling() {
+                break;
+            }
+        }
+        return if comments.len() != 0 {
+            comments.reverse();
+            Some(comments.join("\n"))
+        } else {
+            None
+        };
+    }
+
     pub fn find_childrens_by_kinds(&self, kinds: &[&str]) -> Vec<Node> {
         let mut cursor = self.tree.root_node().walk();
         self.walk_and_collect_kinds(&mut cursor, kinds)
     }
 
-    pub fn definition_for(
+    pub fn definition(
         &self,
         pos: &Position,
         uri: &Url,
@@ -94,4 +155,19 @@ impl ParsedTree {
             None => vec![],
         }
     }
+
+    pub fn hover(&self, pos: &Position, content: impl AsRef<[u8]>) -> Vec<MarkedString> {
+        let text = self.get_node_text_at_position(pos, content.as_ref());
+        info!("Looking for hover response on: {:?}", text);
+        match text {
+            Some(text) => self
+                .find_childrens_by_kinds(&["message_name", "enum_name", "service_name", "rpc_name"])
+                .into_iter()
+                .filter(|n| n.utf8_text(content.as_ref()).expect("utf-8 parse error") == text)
+                .filter_map(|n| self.find_preceeding_comments(n.id(), content.as_ref()))
+                .map(|s| MarkedString::String(s))
+                .collect(),
+            None => vec![],
+        }
+    }
 }

src/parser.rs

@@ -3,12 +3,17 @@ syntax = "proto3";
 package com.book;
 
 message Book {
+    // This is a multi line comment on the field name
+    // Of a message called Book
     int64 isbn = 1;
     string title = 2;
     string author = 3;
 }
 
+// This is a comment on message
 message GetBookRequest {
+    
+    // This is a sigle line comment on the field of a message
     int64 isbn = 1;
 }
 
@@ -22,6 +27,8 @@ message GetBookViaAuthor {
 
 // It is a BookService Implementation
 service BookService {
+    // This is GetBook RPC that takes a book request
+    // and returns a Book, simple and sweet
     rpc GetBook (GetBookRequest) returns (Book) {}
     rpc GetBooksViaAuthor (GetBookViaAuthor) returns (stream Book) {}
     rpc GetGreatestBook (stream GetBookRequest) returns (Book) {}
@@ -30,9 +37,14 @@ service BookService {
 
 message BookStore {
     string name = 1;
+    EnumSample sample = 3;
     map<int64, string> books = 2;
 }
 
+// These are enum options representing some operation in the proto
+// these are meant to be ony called from one place,
+
+// Note: Please set only to started or running
 enum EnumSample {
     option allow_alias = true;
     UNKNOWN = 0;