feat: Read import path and produce import diagnostics

Author: coder3101

Cargo.lock

@@ -27,6 +27,7 @@ hard-xml = "1.36.0"
 tempfile = "3.12.0"
 serde = { version = "1.0.209", features = ["derive"] }
 basic-toml = "0.1.9"
+uuid = { version = "1.11.1", features = ["v4"] }
 
 [dev-dependencies]
 insta = { version = "1.39.0", features = ["yaml"] }

Cargo.toml

@@ -0,0 +1,2 @@
+[config]
+include_paths = ["sample", "src/workspace/input"]

protols.toml

@@ -1,6 +1,6 @@
 use std::{
     collections::{HashMap, HashSet},
-    path::Path,
+    path::{Path, PathBuf},
 };
 
 use async_lsp::lsp_types::{Url, WorkspaceFolder};
@@ -61,6 +61,21 @@ impl WorkspaceProtoConfigs {
             .iter()
             .find(|&k| upath.starts_with(k.to_file_path().unwrap()))
     }
+
+    pub fn get_include_paths(&self, uri: &Url) -> Option<Vec<PathBuf>> {
+        let c = self.get_config_for_uri(uri)?;
+        let w = self.get_workspace_for_uri(uri)?.to_file_path().ok()?;
+        let mut ipath: Vec<PathBuf> = c
+            .config
+            .include_paths
+            .iter()
+            .map(PathBuf::from)
+            .map(|p| if p.is_relative() { w.join(p) } else { p })
+            .collect();
+
+        ipath.push(w.to_path_buf());
+        Some(ipath)
+    }
 }
 
 #[cfg(test)]

sample/google/protobuf/source_content.proto renamed to sample/google/protobuf/source_context.proto

@@ -1,6 +1,4 @@
 use std::ops::ControlFlow;
-use std::sync::mpsc;
-use std::thread;
 use std::{collections::HashMap, fs::read_to_string};
 use tracing::{error, info};
 
@@ -12,11 +10,12 @@ use async_lsp::lsp_types::{
     DocumentSymbolParams, DocumentSymbolResponse, FileOperationFilter, FileOperationPattern,
     FileOperationPatternKind, FileOperationRegistrationOptions, GotoDefinitionParams,
     GotoDefinitionResponse, Hover, HoverContents, HoverParams, HoverProviderCapability,
-    InitializeParams, InitializeResult, Location, OneOf, PrepareRenameResponse, ProgressParams,
-    ReferenceParams, RenameFilesParams, RenameOptions, RenameParams, ServerCapabilities,
-    ServerInfo, TextDocumentPositionParams, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextEdit, Url, WorkspaceEdit, WorkspaceFileOperationsServerCapabilities,
-    WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
+    InitializeParams, InitializeResult, Location, OneOf, PrepareRenameResponse,
+    ReferenceParams, RenameFilesParams, RenameOptions, RenameParams,
+    ServerCapabilities, ServerInfo, TextDocumentPositionParams, TextDocumentSyncCapability,
+    TextDocumentSyncKind, TextEdit, Url, WorkspaceEdit,
+    WorkspaceFileOperationsServerCapabilities, WorkspaceFoldersServerCapabilities,
+    WorkspaceServerCapabilities,
 };
 use async_lsp::{LanguageClient, LanguageServer, ResponseError};
 use futures::future::BoxFuture;
@@ -377,15 +376,19 @@ impl LanguageServer for ProtoLanguageServer {
         let uri = params.text_document.uri;
         let content = params.text_document.text;
 
-        let Some(diagnostics) = self.state.upsert_file(&uri, content) else {
+        let Some(ipath) = self.configs.get_include_paths(&uri) else {
             return ControlFlow::Continue(());
         };
 
-        let Some(ws) = self.configs.get_config_for_uri(&uri) else {
+        let Some(diagnostics) = self.state.upsert_file(&uri, content.clone(), &ipath) else {
             return ControlFlow::Continue(());
         };
 
-        if !ws.config.disable_parse_diagnostics {
+        let Some(pconf) = self.configs.get_config_for_uri(&uri) else {
+            return ControlFlow::Continue(());
+        };
+
+        if !pconf.config.disable_parse_diagnostics {
             if let Err(e) = self.client.publish_diagnostics(diagnostics) {
                 error!(error=%e, "failed to publish diagnostics")
             }
@@ -397,7 +400,11 @@ impl LanguageServer for ProtoLanguageServer {
         let uri = params.text_document.uri;
         let content = params.content_changes[0].text.clone();
 
-        let Some(diagnostics) = self.state.upsert_file(&uri, content) else {
+        let Some(ipath) = self.configs.get_include_paths(&uri) else {
+            return ControlFlow::Continue(());
+        };
+
+        let Some(diagnostics) = self.state.upsert_file(&uri, content, &ipath) else {
             return ControlFlow::Continue(());
         };
 
@@ -419,7 +426,7 @@ impl LanguageServer for ProtoLanguageServer {
             if let Ok(uri) = Url::from_file_path(&file.uri) {
                 // Safety: The uri is always a file type
                 let content = read_to_string(uri.to_file_path().unwrap()).unwrap_or_default();
-                self.state.upsert_content(&uri, content);
+                self.state.upsert_content(&uri, content, &vec![]);
             } else {
                 error!(uri=%file.uri, "failed parse uri");
             }

src/config/workspace.rs

@@ -1,13 +1,12 @@
-use async_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, PublishDiagnosticsParams, Range};
+use async_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, Range};
 
 use crate::{nodekind::NodeKind, utils::ts_to_lsp_position};
 
 use super::ParsedTree;
 
 impl ParsedTree {
-    pub fn collect_parse_errors(&self) -> PublishDiagnosticsParams {
-        let diagnostics = self
-            .find_all_nodes(NodeKind::is_error)
+    pub fn collect_parse_diagnostics(&self) -> Vec<Diagnostic> {
+        self.find_all_nodes(NodeKind::is_error)
             .into_iter()
             .map(|n| Diagnostic {
                 range: Range {
@@ -19,12 +18,24 @@ impl ParsedTree {
                 message: "Syntax error".to_string(),
                 ..Default::default()
             })
-            .collect();
-        PublishDiagnosticsParams {
-            uri: self.uri.clone(),
-            diagnostics,
-            version: None,
-        }
+            .collect()
+    }
+
+    pub fn collect_import_diagnostics(
+        &self,
+        content: &[u8],
+        import: Vec<String>,
+    ) -> Vec<Diagnostic> {
+        self.get_import_path_range(content, import)
+            .into_iter()
+            .map(|r| Diagnostic {
+                range: r,
+                severity: Some(DiagnosticSeverity::ERROR),
+                source: Some(String::from("protols")),
+                message: "failed to find proto file".to_string(),
+                ..Default::default()
+            })
+            .collect()
     }
 }
 
@@ -42,12 +53,12 @@ mod test {
 
         let parsed = ProtoParser::new().parse(url.clone(), contents);
         assert!(parsed.is_some());
-        assert_yaml_snapshot!(parsed.unwrap().collect_parse_errors());
+        assert_yaml_snapshot!(parsed.unwrap().collect_parse_diagnostics());
 
         let contents = include_str!("input/test_collect_parse_error2.proto");
 
         let parsed = ProtoParser::new().parse(url.clone(), contents);
         assert!(parsed.is_some());
-        assert_yaml_snapshot!(parsed.unwrap().collect_parse_errors());
+        assert_yaml_snapshot!(parsed.unwrap().collect_parse_diagnostics());
     }
 }

src/lsp.rs

@@ -1,16 +1,15 @@
 ---
 source: src/parser/diagnostics.rs
-expression: parsed.unwrap().collect_parse_errors()
+expression: parsed.unwrap().collect_parse_diagnostics()
+snapshot_kind: text
 ---
-uri: "file://foo/bar.proto"
-diagnostics:
-  - range:
-      start:
-        line: 6
-        character: 8
-      end:
-        line: 6
-        character: 19
-    severity: 1
-    source: protols
-    message: Syntax error
+- range:
+    start:
+      line: 6
+      character: 8
+    end:
+      line: 6
+      character: 19
+  severity: 1
+  source: protols
+  message: Syntax error

src/parser/diagnostics.rs

@@ -1,6 +1,6 @@
 ---
 source: src/parser/diagnostics.rs
-expression: parsed.unwrap().collect_parse_errors()
+expression: parsed.unwrap().collect_parse_diagnostics()
+snapshot_kind: text
 ---
-uri: "file://foo/bar.proto"
-diagnostics: []
+[]

src/parser/snapshots/protols__parser__diagnostics__test__collect_parse_error-2.snap

@@ -1,7 +1,10 @@
-use async_lsp::lsp_types::Position;
+use async_lsp::lsp_types::{Position, Range};
 use tree_sitter::{Node, TreeCursor};
 
-use crate::{nodekind::NodeKind, utils::lsp_to_ts_point};
+use crate::{
+    nodekind::NodeKind,
+    utils::{lsp_to_ts_point, ts_to_lsp_position},
+};
 
 use super::ParsedTree;
 
@@ -133,15 +136,38 @@ impl ParsedTree {
             .first()
             .map(|n| n.utf8_text(content).expect("utf-8 parse error"))
     }
-    pub fn get_import_path<'a>(&self, content: &'a [u8]) -> Vec<&'a str> {
+
+    pub fn get_import_node(&self) -> Vec<Node> {
         self.find_all_nodes(NodeKind::is_import_path)
             .into_iter()
-            .filter_map(|n| {
-                n.child_by_field_name("path").map(|c| {
-                    c.utf8_text(content)
-                        .expect("utf-8 parse error")
-                        .trim_matches('"')
-                })
+            .filter_map(|n| n.child_by_field_name("path"))
+            .collect()
+    }
+
+    pub fn get_import_path<'a>(&self, content: &'a [u8]) -> Vec<&'a str> {
+        self.get_import_node()
+            .into_iter()
+            .map(|n| {
+                n.utf8_text(content)
+                    .expect("utf-8 parse error")
+                    .trim_matches('"')
+            })
+            .collect()
+    }
+
+    pub fn get_import_path_range<'a>(&self, content: &'a [u8], import: Vec<String>) -> Vec<Range> {
+        self.get_import_node()
+            .into_iter()
+            .filter(|n| {
+                let t = n
+                    .utf8_text(content)
+                    .expect("utf8-parse error")
+                    .trim_matches('"');
+                import.iter().any(|i| i == t)
+            })
+            .map(|n| Range {
+                start: ts_to_lsp_position(&n.start_position()),
+                end: ts_to_lsp_position(&n.end_position()),
             })
             .collect()
     }