Support document sync for bangls

Author: A4-Tacks

Cargo.lock

@@ -1,9 +1,10 @@
 [package]
 name = "bangls"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 
 [features]
+default = ["lalrpop"]
 lalrpop = ["parser/lalrpop"]
 
 [dependencies]

tools/bangls/Cargo.toml

@@ -24,7 +24,7 @@ bangls 是一个 bang 语言的语言服务器, 使用语言服务器协议 (LSP
 功能支持
 ===============================================================================
 - [x] 基本补全
-- [ ] 无需保存分析
+- [x] 无需保存分析
 - [ ] 启发式片段补全
 - [ ] 定义跳转
 - [ ] 引用跳转

tools/bangls/README.md

@@ -1,16 +1,18 @@
-use std::{fs, path::Path};
-
 use anyhow::{Result, anyhow, bail};
 use crossbeam_channel::{Receiver, Sender};
 use linked_hash_map::LinkedHashMap;
 use lsp_server::{IoThreads, Message};
-use lsp_types::{CompletionItem, CompletionOptions, InitializeParams, ServerCapabilities, request::{self, Request}};
+use lsp_types::{CompletionItem, CompletionOptions, InitializeParams, MessageType, Position, ServerCapabilities, ShowMessageParams, TextDocumentSyncCapability, TextDocumentSyncKind, Uri, notification::{self, Notification}, request::{self, Request}};
 use syntax::{Compile, CompileMeta, EmulateInfo, Expand, LSP_DEBUG};
 
 fn main() {
     main_loop().unwrap();
 }
 
+fn lopos(pos: Position) -> (u32, u32) {
+    (pos.line + 1, pos.character + 1)
+}
+
 struct IoJoiner(pub Option<IoThreads>);
 impl std::ops::DerefMut for IoJoiner {
     fn deref_mut(&mut self) -> &mut Self::Target {
@@ -45,6 +47,7 @@ fn main_loop() -> Result<()> {
             trigger_characters: Some(vec![]),
             ..Default::default()
         }),
+        text_document_sync: Some(TextDocumentSyncCapability::Kind(TextDocumentSyncKind::FULL)),
         ..Default::default()
     };
     let server_capabilities = serde_json::to_value(server_capabilities)?;
@@ -55,33 +58,60 @@ fn main_loop() -> Result<()> {
     } = serde_json::from_value::<InitializeParams>(init_params)?;
     let _workspace_folders = workspace_folders.ok_or(anyhow!("Cannot find workspace folder"))?;
     let mut ctx = Ctx {
+        open_files: Default::default(),
         sender: connect.sender,
         recver: connect.receiver,
     };
     ctx.run()
 }
 
 struct Ctx {
+    open_files: LinkedHashMap<Uri, String>,
     sender: Sender<Message>,
     recver: Receiver<Message>,
 }
 impl Ctx {
     fn run(&mut self) -> Result<(), anyhow::Error> {
         while let Ok(msg) = self.recver.recv() {
             match msg {
-                Message::Request(request) => self.handle_request(request)?,
+                Message::Request(request) => self.handle_requests(request)?,
                 Message::Response(response) => {
                     eprintln!("unknown response {response:?}")
                 },
                 Message::Notification(notification) => {
+                    let notification = &mut Some(notification);
+                    self.try_handle_notif::<notification::DidOpenTextDocument>(notification)?;
+                    self.try_handle_notif::<notification::DidChangeTextDocument>(notification)?;
+                    self.try_handle_notif::<notification::DidCloseTextDocument>(notification)?;
                     eprintln!("unknown notification {notification:?}")
                 },
             }
         }
         Ok(())
     }
 
-    fn try_handle<T: RequestHandler>(&mut self, request: &mut Option<lsp_server::Request>) -> Option<Result<()>> {
+    fn handle_requests(&mut self, request: lsp_server::Request) -> Result<()> {
+        let request = &mut Some(request);
+
+        self.try_handle_req::<request::Completion>(request).transpose()?;
+
+        if let Some(request) = request {
+            bail!("unknown request {request:#?}")
+        }
+        Ok(())
+    }
+
+    fn try_handle_notif<T: NotificationHandler>(&mut self, notification: &mut Option<lsp_server::Notification>) -> Result<()> {
+        let Some(lsp_server::Notification { params, .. })
+            = notification.take_if(|it| it.method == T::METHOD) else { return Ok(()) };
+        let params = match serde_json::from_value(params) {
+            Ok(it) => it,
+            Err(err) => bail!(err),
+        };
+        T::handle(self, params)
+    }
+
+    fn try_handle_req<T: RequestHandler>(&mut self, request: &mut Option<lsp_server::Request>) -> Option<Result<()>> {
         let lsp_server::Request { id, params, .. }
             = request.take_if(|req| req.method == T::METHOD)?;
         let params = match serde_json::from_value(params) {
@@ -109,21 +139,15 @@ impl Ctx {
         Some(self.sender.send(Message::Response(response)).map_err(Into::into))
     }
 
-    fn handle_request(&mut self, request: lsp_server::Request) -> Result<()> {
-        let request = &mut Some(request);
-
-        None.or_else(|| self.try_handle::<request::Completion>(request))
-            .unwrap_or_else(|| bail!("unknown request {request:#?}"))
-    }
-
-    fn read_file(&self, path: impl AsRef<Path>) -> Result<String> {
-        let file = fs::read(path)?;
-        let file = String::from_utf8_lossy(&file);
-        Ok(file.into_owned())
+    fn read_file(&self, uri: &Uri) -> Result<&str> {
+        match self.open_files.get(uri) {
+            Some(s) => Ok(s),
+            None => bail!("Cannot read no opened file"),
+        }
     }
 
     fn try_parse(&self, (line, col): (u32, u32), file: &str) -> Result<(Expand, String)> {
-        let index = line_column::index(&file, line+1, col+1);
+        let index = line_column::index(&file, line, col);
         let placeholders = [
             format!("{LSP_DEBUG} "),
             format!("{LSP_DEBUG} __lsp_arg;"),
@@ -141,18 +165,31 @@ impl Ctx {
         }
         Err(anyhow!("Fake parse err: {parse_err}"))
     }
+
+    fn send_window_notif(&self, typ: MessageType, msg: impl std::fmt::Display) -> Result<()> {
+        let params = ShowMessageParams {
+            typ,
+            message: msg.to_string(),
+        };
+        let params = serde_json::to_value(params)?;
+        let msg = Message::Notification(lsp_server::Notification {
+                method: notification::ShowMessage::METHOD.to_owned(),
+                params,
+            });
+        self.sender.send(msg)?;
+        Ok(())
+    }
 }
 
 trait RequestHandler: Request {
     fn handle(ctx: &Ctx, param: Self::Params) -> Result<Self::Result>;
 }
 impl RequestHandler for request::Completion {
     fn handle(ctx: &Ctx, param: Self::Params) -> Result<Self::Result> {
-        let path = param.text_document_position.text_document.uri.path();
-        let line = param.text_document_position.position.line;
-        let col = param.text_document_position.position.character;
+        let uri = param.text_document_position.text_document.uri;
+        let (line, col) = lopos(param.text_document_position.position);
 
-        let file = ctx.read_file(path.as_str())?;
+        let file = ctx.read_file(&uri)?;
         let (top, src) = ctx.try_parse((line, col), &file)?;
         let mut meta = CompileMeta::with_source(src.into());
         meta.is_emulated = true;
@@ -196,3 +233,37 @@ fn generate_completes(infos: &[EmulateInfo]) -> Vec<CompletionItem> {
         }
     }).collect()
 }
+
+trait NotificationHandler: Notification {
+    fn handle(ctx: &mut Ctx, param: Self::Params) -> Result<()>;
+}
+impl NotificationHandler for notification::DidOpenTextDocument {
+    fn handle(ctx: &mut Ctx, param: Self::Params) -> Result<()> {
+        ctx.send_window_notif(MessageType::LOG, "open file")?;
+        let file = ctx.open_files.entry(param.text_document.uri).or_default();
+        *file = param.text_document.text;
+        Ok(())
+    }
+}
+impl NotificationHandler for notification::DidChangeTextDocument {
+    fn handle(ctx: &mut Ctx, param: Self::Params) -> Result<()> {
+        let file = ctx.open_files.entry(param.text_document.uri).or_default();
+
+        for change in param.content_changes {
+            if change.range.is_some() {
+                bail!("unsupported range change sync: {change:#?}")
+            }
+            *file = change.text;
+        }
+        Ok(())
+    }
+}
+impl NotificationHandler for notification::DidCloseTextDocument {
+    fn handle(ctx: &mut Ctx, param: Self::Params) -> Result<()> {
+        let uri = param.text_document.uri;
+        if ctx.open_files.remove(&uri).is_none() {
+            ctx.send_window_notif(MessageType::WARNING, format_args!("Cannot close unknown file: {uri:?}"))?;
+        }
+        Ok(())
+    }
+}