add support for enum/message definition within file

Author: coder3101

.gitignore

@@ -1 +1,2 @@
 /target
+/logs

Cargo.lock

@@ -11,3 +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"
+tracing-appender = "0.2.3"

Cargo.toml

@@ -1,15 +1,14 @@
-use async_lsp::LanguageClient;
 use std::ops::ControlFlow;
 use std::time::Duration;
 use tracing::{debug, info};
 
 use async_lsp::lsp_types::{
-    DidChangeConfigurationParams, DidChangeTextDocumentParams, DidOpenTextDocumentParams,
-    DidSaveTextDocumentParams, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents,
-    HoverParams, HoverProviderCapability, InitializeParams, InitializeResult, MarkedString,
-    MessageType, OneOf, ServerCapabilities, ServerInfo, ShowMessageParams,
+    DidChangeTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
+    GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents, HoverParams,
+    InitializeParams, InitializeResult, MarkedString, OneOf, ServerCapabilities, ServerInfo,
+    TextDocumentSyncCapability, TextDocumentSyncKind,
 };
-use async_lsp::{LanguageServer, ResponseError};
+use async_lsp::{ErrorCode, LanguageServer, ResponseError};
 use futures::future::BoxFuture;
 
 use crate::server::ServerState;
@@ -33,31 +32,28 @@ impl LanguageServer for ServerState {
         info!("Connected with client {cname} {cversion}");
         debug!("Initialize with {params:?}");
 
-        Box::pin(async move {
-            Ok(InitializeResult {
-                capabilities: ServerCapabilities {
-                    hover_provider: Some(HoverProviderCapability::Simple(true)),
-                    ..ServerCapabilities::default()
-                },
-                server_info: Some(ServerInfo {
-                    name: env!("CARGO_PKG_NAME").to_string(),
-                    version: Some(env!("CARGO_PKG_VERSION").to_string()),
-                }),
-            })
-        })
+        let response = InitializeResult {
+            capabilities: ServerCapabilities {
+                // todo(): We might prefer incremental sync at some later stage
+                text_document_sync: Some(TextDocumentSyncCapability::Kind(
+                    TextDocumentSyncKind::FULL,
+                )),
+                definition_provider: Some(OneOf::Left(true)),
+                ..ServerCapabilities::default()
+            },
+            server_info: Some(ServerInfo {
+                name: env!("CARGO_PKG_NAME").to_string(),
+                version: Some(env!("CARGO_PKG_VERSION").to_string()),
+            }),
+        };
+
+        Box::pin(async move { Ok(response) })
     }
 
     fn hover(&mut self, _: HoverParams) -> BoxFuture<'static, Result<Option<Hover>, Self::Error>> {
-        let mut client = self.client.clone();
         let counter = self.counter;
         Box::pin(async move {
             tokio::time::sleep(Duration::from_secs(1)).await;
-            client
-                .show_message(ShowMessageParams {
-                    typ: MessageType::INFO,
-                    message: "Hello LSP".into(),
-                })
-                .unwrap();
             Ok(Some(Hover {
                 contents: HoverContents::Scalar(MarkedString::String(format!(
                     "I am a hover text {counter}!"
@@ -67,22 +63,59 @@ impl LanguageServer for ServerState {
         })
     }
 
-    // fn definition(
-    //     &mut self,
-    //     _: GotoDefinitionParams,
-    // ) -> BoxFuture<'static, Result<Option<GotoDefinitionResponse>, ResponseError>> {
-    //     unimplemented!("Not yet implemented!");
-    // }
+    fn definition(
+        &mut self,
+        param: GotoDefinitionParams,
+    ) -> BoxFuture<'static, Result<Option<GotoDefinitionResponse>, ResponseError>> {
+        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 locations = parsed.definition_for(&pos, &uri, contents.as_bytes());
+        info!("Found {} matching nodes in the document", locations.len());
+
+        let response = match locations.len() {
+            0 => None,
+            1 => Some(GotoDefinitionResponse::Scalar(locations[0].clone())),
+            2.. => Some(GotoDefinitionResponse::Array(locations)),
+        };
+
+        Box::pin(async move { Ok(response) })
+    }
 
     fn did_save(&mut self, _: DidSaveTextDocumentParams) -> Self::NotifyResult {
-        todo!("to implement")
+        ControlFlow::Continue(())
     }
 
-    fn did_open(&mut self, _: DidOpenTextDocumentParams) -> Self::NotifyResult {
-        todo!("to implement")
+    fn did_open(&mut self, params: DidOpenTextDocumentParams) -> Self::NotifyResult {
+        let uri = params.text_document.uri;
+        let contents = params.text_document.text;
+        info!("Opened file at: {:}", uri);
+        self.documents.insert(uri, contents);
+        ControlFlow::Continue(())
     }
 
-    fn did_change(&mut self, _: DidChangeTextDocumentParams) -> Self::NotifyResult {
-        todo!("to implement")
+    fn did_change(&mut self, params: DidChangeTextDocumentParams) -> Self::NotifyResult {
+        let uri = params.text_document.uri;
+        let contents = params.content_changes[0].text.clone();
+        self.documents.insert(uri, contents);
+        ControlFlow::Continue(())
     }
 }

src/lsp.rs

@@ -11,6 +11,8 @@ use tracing::Level;
 
 mod lsp;
 mod server;
+mod utils;
+mod parser;
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
@@ -37,10 +39,13 @@ async fn main() {
             .service(ServerState::new_router(client))
     });
 
+    let file_appender = tracing_appender::rolling::daily("/Users/ashar/Developer/protols/logs", "lsp.log");
+    let (non_blocking, _gaurd) = tracing_appender::non_blocking(file_appender);
+
     tracing_subscriber::fmt()
         .with_max_level(Level::INFO)
         .with_ansi(false)
-        .with_writer(std::io::stderr)
+        .with_writer(non_blocking)
         .init();
 
     // Prefer truly asynchronous piped stdin/stdout without blocking tasks.