feat: Add file watcher (#20)

Author: felix-andreas

Cargo.lock

@@ -14,6 +14,7 @@ indoc = "2.0.6"
 itertools = "0.14.0"
 ropey = "1.6.1"
 serde = "1.0.219"
+serde_json = "1.0.140"
 similar = { version = "2.7.0", features = ["inline"] }
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = [

Cargo.toml

@@ -20,6 +20,7 @@ tracing-subscriber.workspace = true
 tracing-tree.workspace = true
 tree-sitter.workspace = true
 tree-sitter-r.workspace = true
+serde_json.workspace = true
 
 # async-lsp
 async-lsp.workspace = true

crates/roughly/Cargo.toml

@@ -7,13 +7,17 @@ use {
         index::{self, IndexError},
         lsp_types::{
             CompletionOptions, CompletionParams, CompletionResponse, DidChangeTextDocumentParams,
+            DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions,
             DidCloseTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams,
             DocumentFormattingParams, DocumentRangeFormattingParams, DocumentSymbol,
-            DocumentSymbolParams, DocumentSymbolResponse, InitializeParams, InitializeResult,
-            MessageType, OneOf, Position, PublishDiagnosticsParams, Range, SaveOptions,
-            ServerCapabilities, ServerInfo, ShowMessageParams, TextDocumentSyncCapability,
-            TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions, TextEdit,
-            WorkspaceSymbolParams, WorkspaceSymbolResponse,
+            DocumentSymbolParams, DocumentSymbolResponse, FileChangeType, FileSystemWatcher,
+            GlobPattern, InitializeParams, InitializeResult, InitializedParams, MessageType, OneOf,
+            Position, PublishDiagnosticsParams, Range, Registration, RegistrationParams,
+            RelativePattern, SaveOptions, ServerCapabilities, ServerInfo, ShowMessageParams,
+            TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
+            TextDocumentSyncSaveOptions, TextEdit, Url, WorkspaceSymbolParams,
+            WorkspaceSymbolResponse,
+            notification::{DidChangeWatchedFiles, Notification},
         },
         tree, utils,
     },
@@ -78,7 +82,9 @@ struct ServerState {
     experimental: bool,
     base_path: PathBuf,
     document_map: HashMap<PathBuf, Document>,
+    /// stores symbolds for all other files
     document_symbols: HashMap<PathBuf, Vec<DocumentSymbol>>,
+    /// stores index for all files in R/ folder
     workspace_symbols: HashMap<PathBuf, Vec<DocumentSymbol>>,
     parser: Parser,
 }
@@ -154,6 +160,46 @@ impl LanguageServer for ServerState {
         }))
     }
 
+    fn initialized(&mut self, _: InitializedParams) -> ControlFlow<async_lsp::Result<()>> {
+        // TODO: consider to negotiate client capabilities
+        // see: https://github.com/oxalica/nil/blob/870a4b1b5f/crates/nil/src/capabilities.rs
+        let params = RegistrationParams {
+            registrations: vec![Registration {
+                id: DidChangeWatchedFiles::METHOD.into(),
+                method: DidChangeWatchedFiles::METHOD.into(),
+                register_options: Some(
+                    serde_json::to_value(DidChangeWatchedFilesRegistrationOptions {
+                        watchers: vec![FileSystemWatcher {
+                            glob_pattern: GlobPattern::Relative(RelativePattern {
+                                base_uri: OneOf::Right(
+                                    Url::from_file_path(&self.base_path).unwrap(),
+                                ),
+                                pattern: "*.[rR]".into(),
+                            }),
+                            kind: None,
+                        }],
+                    })
+                    .unwrap(),
+                ),
+            }],
+        };
+
+        let mut client = self.client.clone();
+        tokio::spawn(async move {
+            if let Err(err) = client.register_capability(params).await {
+                client
+                    .show_message(ShowMessageParams {
+                        typ: MessageType::ERROR,
+                        message: format!("failed to watch R files: {err:#}"),
+                    })
+                    .unwrap();
+            }
+            tracing::info!("registered file watching for R files");
+        });
+
+        ControlFlow::Continue(())
+    }
+
     //
     // TEXT SYNC
     //
@@ -177,10 +223,13 @@ impl LanguageServer for ServerState {
             diagnostics::Config::from_config(self.config, self.experimental),
         );
 
-        if !path.starts_with(&self.base_path) {
-            let symbols = index::index(tree.root_node(), &rope, false);
+        let symbols = index::index(tree.root_node(), &rope, false);
+        if path.starts_with(&self.base_path) {
+            // note: we need to insert into workspace in case a new file is created
+            self.workspace_symbols.insert(path.clone(), symbols);
+        } else {
             self.document_symbols.insert(path.clone(), symbols);
-        };
+        }
 
         self.document_map.insert(path, Document { rope, tree });
 
@@ -343,6 +392,35 @@ impl LanguageServer for ServerState {
         ControlFlow::Continue(())
     }
 
+    fn did_change_watched_files(
+        &mut self,
+        params: DidChangeWatchedFilesParams,
+    ) -> ControlFlow<async_lsp::Result<()>> {
+        for change in params.changes {
+            let uri = change.uri;
+            let typ = change.typ;
+            let path = uri.to_file_path().unwrap();
+
+            tracing::info!(?path, ?typ, "watched file changed");
+
+            if path.starts_with(&self.base_path) {
+                match change.typ {
+                    FileChangeType::CREATED | FileChangeType::CHANGED => {
+                        // note: potential race condition if the user already has the file open and begins editing immediately.
+                        let symbols = index::index_file(&path, &mut self.parser);
+                        self.workspace_symbols.insert(path.clone(), symbols);
+                    }
+                    FileChangeType::DELETED => {
+                        self.workspace_symbols.remove(&path);
+                    }
+                    _ => unreachable!(),
+                }
+            }
+        }
+
+        ControlFlow::Continue(())
+    }
+
     //
     // COMPLETION
     //

crates/roughly/src/server.rs

@@ -34,16 +34,16 @@ x: numeric <- 4
 names: character[] <- c("Alice", "Bob")
 ```
 
-However, this syntax would require major changes to R's parser and is not practical for early experimentation.
+However, this syntax would require major changes to R's parser which is not practical for early experimentation.
 
 ### Option C: JSDoc-style comments
 
-JSDoc is an alternative syntax for TypeScript that uses the same underlying type system and type checker. In this approach, types are provided in comments, making it practical for prototyping and not requiring changes to R itself.
+[JSDoc](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html) is an alternative syntax for TypeScript that uses the same underlying type system and type checker. In this approach, types are provided in comments, so no changes to R itself are required.
 
 ```r
 #: @param items character[] # character vector input
-#: @param count numeric  # scalar numeric input (expected length)
-#: @return logical       # returns a scalar logical
+#: @param count numeric     # scalar numeric input (expected length)
+#: @return logical          # returns a scalar logical
 has_expected_length <- function(items, count) {
   length(items) == count
 }
@@ -52,7 +52,7 @@ x <- 4 #: numeric
 names <- c("Alice", "Bob") #: character[]
 ```
 
-> [!INFO]
+> [!NOTE]
 > To distinguish from roxygen, use `#:` as the comment prefix:
 
 This is the option we use for now, as it enables experimentation without modifying R itself.
@@ -82,9 +82,10 @@ Vectors and lists can have arbitrary length, but some constructs (like `if`) req
 
 - Support for:
   - **Scalar** (length-one vector)
-  - **Array** (vector + array attributes)
-  - **Record** (lists of fixed size with names)
-  - **Tuple** (lists of fixed size, no names)
+  - **Array** (arbitrary length vector)
+  - **List** (arbitrary length, homogenous list)
+  - **Record** (fixed length, heterogeneous list with named fields)
+  - **Tuple** (fixed length, heterogeneous list with positional fields)
   - **Unknown** (type could not be inferred)
   - **Any** (explicit opt-out of type checking)
 - Future:
@@ -250,11 +251,11 @@ Err <- function(error) {
   error |> with_tag("Err")
 }
 
-#: @param x [Ok<T>, Err <E>]
+#: @param x [Ok <T>, Err <E>]
 #: @return logical
 is_ok <- \(x) tag(x) == "Ok"
 
-#: @param x [Ok<T>, Err <E>]
+#: @param x [Ok <T>, Err <E>]
 #: @return logical
 is_err <- \(x) tag(x) == "Err"
 ```
@@ -263,23 +264,23 @@ is_err <- \(x) tag(x) == "Err"
 
 A key benefit of union types is that the type checker can enforce exhaustiveness in pattern matching or switch statements. This means that all possible variants of a union type must be handled explicitly, preventing bugs from unhandled cases.
 
-For example, consider a `Maybe` type with two variants: `Just` and `Nothing`:
+For example, suppose you have a function parameter that can be either `Just` or `Nothing`, representing a tagged union with two possible variants:
 
 ```r
-#: @param result [Just numeric, Nothing]
+#: @param maybe [Just numeric, Nothing]
 #: @return numeric
-process_result <- function(result) {
+process_maybe <- function(maybe) {
   switch(
-    tag(result),
-    Just = get_value(result),
+    tag(maybe),
+    Just = process(maybe),
     Nothing = 0
-    # If a new variant is added to the Maybe type, the type checker will report an error
-    # if it is not handled here.
+    # If a new variant is added to the `maybe` parameter,
+    # the type checker will report an error if it is not handled here.
   )
 }
 ```
 
-If you later extend `Maybe` with a new variant (e.g., `Unknown`), the type checker will require you to update all switch statements that handle `Maybe` to cover the new case, ensuring your code remains correct and robust.
+If you later extend the union with a new variant (e.g., `Unknown`), the type checker will require you to update all switch statements that handle `maybe` to cover the new case, ensuring your code remains correct and robust.
 
 ## Open Questions
 

crates/typing/README.md

@@ -188,6 +188,8 @@ See https://github.com/r-lib/tree-sitter-r/issues/166
   * https://github.com/IWANABETHATGUY/tower-lsp-boilerplate
   * https://github.com/TenStrings/glicol-lsp/blob/77e97d9c687dc5d66871ad5ec91b6f049de2b8e8/src/main.rs#L16
   * https://github.com/jfecher/ante/blob/5f7446375bc1c6c94b44a44bfb89777c1437aaf5/ante-ls/src/main.rs#L163
+* async_lsp
+  * https://github.com/oxalica/nil
 
 ### Formatting