Enhance path resolution caching

CHANGELOG.md

@@ -7,6 +7,7 @@ Path Server is now published to crates.io! You can now install it via `cargo ins
 
 ### Added
 - Added new step to release workflow to publish to crates.io.
+- Added TTL to resolved path cache to keep path highlighting up to date with file system changes.
 
 ### Improved
 - **VS Code**: Updated icon color from #007fd4 to #0098ff to keep consistent with VS Code's color palette.

src/document/mod.rs

@@ -2,11 +2,13 @@ mod language;
 pub use language::Language;
 
 use line_index::{LineIndex, TextSize, WideEncoding, WideLineCol};
+use std::sync::Arc;
 use tokio::sync::Mutex;
 use tower_lsp_server::ls_types;
 use tree_sitter::Tree;
 
 use crate::error::*;
+use crate::parser::PathCandidate;
 use crate::parser::{new_tree, update_tree};
 use crate::resolver::ResolvedPathCache;
 
@@ -16,8 +18,12 @@ pub struct Document {
     pub text: String,
     /// Language if from lsp client
     pub language: Language,
-    /// Tokens cache
-    pub tokens: Mutex<ResolvedPathCache>,
+    /// Cached tokens from parser (candidate paths)
+    /// This will never expire until the document content changes
+    pub candidate_path: Mutex<Option<Arc<Vec<Vec<PathCandidate>>>>>,
+    /// Cached exists paths (resolved from candidate paths)
+    /// This may expire to reflect file system changes
+    pub resolved_path: Mutex<Option<ResolvedPathCache>>,
     /// Index for line/column -> offset calculations
     index: LineIndex,
     /// Tree-sitter AST tree for incremental parsing
@@ -31,7 +37,8 @@ impl Default for Document {
             index: LineIndex::new(""),
             language: Language::Unknown("".into()),
             tree: None,
-            tokens: Mutex::new(ResolvedPathCache::new()),
+            candidate_path: Mutex::new(None),
+            resolved_path: Mutex::new(None),
         }
     }
 }
@@ -43,7 +50,8 @@ impl Document {
             text,
             language: Language::from_id(language_id),
             tree: None,
-            tokens: Mutex::new(ResolvedPathCache::new()),
+            candidate_path: Mutex::new(None),
+            resolved_path: Mutex::new(None),
         };
         doc.tree = new_tree(&doc)?;
         Ok(doc)
@@ -74,7 +82,8 @@ impl Document {
             index: new_index,
             tree: None,
             language: old_document.language.clone(),
-            tokens: Mutex::new(ResolvedPathCache::new()),
+            candidate_path: Mutex::new(None),
+            resolved_path: Mutex::new(None),
         };
 
         // update tree

src/resolver/collect.rs

@@ -9,29 +9,30 @@ use crate::error::*;
 use crate::fs;
 use crate::parser::{PathCandidate, parse_document};
 
-use super::{ResolvedPath, ResolvedPathCache};
+use super::{RESOLVE_CACHE_TTL, ResolvedPath, ResolvedPathCache};
 
 pub async fn resolve_all(
     document: &Document,
     config: &Config,
     workspace_roots: &[String],
     doc_parent: &Option<String>,
 ) -> PathServerResult<Arc<Vec<ResolvedPath>>> {
-    let mut cache = document.tokens.lock().await;
+    let mut cache = document.resolved_path.lock().await;
     let signature = config.signature()?;
-    if let Some(tokens) = &cache.tokens
+    if let Some(cache) = &*cache
         && cache.config_signature == signature
+        && cache.created_at.elapsed() < RESOLVE_CACHE_TTL
     {
         // hit
-        return Ok(tokens.clone());
+        return Ok(cache.tokens.clone());
     }
     // miss
     let tokens = compute_tokens(document, config, workspace_roots, doc_parent).await?;
     let shared_tokens = Arc::new(tokens);
-    *cache = ResolvedPathCache {
-        tokens: Some(Arc::clone(&shared_tokens)),
-        config_signature: signature,
-    };
+    *cache = Some(ResolvedPathCache::new(
+        Arc::clone(&shared_tokens),
+        signature,
+    ));
     Ok(shared_tokens)
 }
 
@@ -42,20 +43,27 @@ async fn compute_tokens(
     doc_parent: &Option<String>,
 ) -> PathServerResult<Vec<ResolvedPath>> {
     let home = std::env::var("HOME").ok();
+    let path_candidates = if let Some(cache) = &*document.candidate_path.lock().await {
+        // hit
+        cache.clone()
+    } else {
+        // miss
+        let path_candidates: Arc<Vec<Vec<PathCandidate>>> = Arc::new(parse_document(document)?);
+        *document.candidate_path.lock().await = Some(path_candidates.clone());
+        path_candidates
+    };
     let tokens: Vec<ResolvedPath> =
-        future::try_join_all(parse_document(document).into_iter().flatten().map(
-            |candidates| async {
-                filter_exist_path(
-                    candidates,
-                    config,
-                    workspace_roots,
-                    doc_parent.as_ref(),
-                    home.as_ref(),
-                    document,
-                )
-                .await
-            },
-        ))
+        future::try_join_all(path_candidates.iter().map(|candidates| async {
+            filter_exist_path(
+                candidates,
+                config,
+                workspace_roots,
+                doc_parent.as_ref(),
+                home.as_ref(),
+                document,
+            )
+            .await
+        }))
         .await?
         .into_iter()
         .flatten()
@@ -68,19 +76,19 @@ async fn compute_tokens(
 }
 
 async fn filter_exist_path(
-    candidates: Vec<PathCandidate>,
+    candidates: &[PathCandidate],
     config: &Config,
     workspace_roots: &[String],
     parent: Option<&String>,
     home: Option<&String>,
     document: &Document,
 ) -> PathServerResult<Vec<ResolvedPath>> {
-    let resolved = future::try_join_all(candidates.into_iter().map(|candidate| async move {
+    let resolved = future::try_join_all(candidates.iter().map(|candidate| async move {
         let path = PathBuf::from(&candidate.content);
         if path.is_absolute() {
             if fs::exists(&path).await {
                 PathServerResult::Ok(vec![
-                    candidate_to_resolved(&candidate, &path, document).await?,
+                    candidate_to_resolved(candidate, &path, document).await?,
                 ])
             } else {
                 PathServerResult::Ok(vec![])

src/resolver/mod.rs

@@ -7,6 +7,8 @@ pub use query::resolve_at_pos;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+const RESOLVE_CACHE_TTL: std::time::Duration = std::time::Duration::from_secs(10);
+
 #[derive(Debug, Clone)]
 pub struct ResolvedPath {
     pub start: (usize, usize), // (line, character) in utf16
@@ -26,15 +28,18 @@ impl ResolvedPath {
 
 #[derive(Debug)]
 pub struct ResolvedPathCache {
-    tokens: Option<Arc<Vec<ResolvedPath>>>,
+    tokens: Arc<Vec<ResolvedPath>>,
     config_signature: String,
+    /// For expiration
+    created_at: std::time::Instant,
 }
 
 impl ResolvedPathCache {
-    pub fn new() -> Self {
+    pub fn new(tokens: Arc<Vec<ResolvedPath>>, config_signature: String) -> Self {
         Self {
-            tokens: None,
-            config_signature: String::new(),
+            tokens,
+            config_signature,
+            created_at: std::time::Instant::now(),
         }
     }
 }