support textdocument/diagnostic

Fix #

Author: CppCXY

crates/emmylua_ls/src/context/lsp_features.rs

@@ -0,0 +1,42 @@
+use lsp_types::ClientCapabilities;
+
+#[derive(Debug)]
+pub struct LspFeatures {
+    client_capabilities: ClientCapabilities,
+}
+
+#[allow(unused)]
+impl LspFeatures {
+    pub fn new(client_capabilities: ClientCapabilities) -> Self {
+        Self {
+            client_capabilities,
+        }
+    }
+
+    pub fn supports_multiline_tokens(&self) -> bool {
+        if let Some(semantic) = &self.client_capabilities.text_document {
+            if let Some(semantic) = &semantic.semantic_tokens {
+                if let Some(supports) = semantic.multiline_token_support {
+                    return supports;
+                }
+            }
+        }
+        false
+    }
+
+    pub fn supports_config_request(&self) -> bool {
+        if let Some(workspace) = &self.client_capabilities.workspace {
+            if let Some(supports) = workspace.configuration {
+                return supports;
+            }
+        }
+        false
+    }
+
+    pub fn supports_pull_diagnostics(&self) -> bool {
+        if let Some(text_document) = &self.client_capabilities.text_document {
+            return text_document.diagnostic.is_some();
+        }
+        false
+    }
+}

crates/emmylua_ls/src/context/mod.rs

@@ -1,6 +1,7 @@
 mod client;
 mod client_id;
 mod file_diagnostic;
+mod lsp_features;
 mod snapshot;
 mod status_bar;
 mod workspace_manager;
@@ -21,6 +22,7 @@ pub use workspace_manager::WorkspaceFileMatcher;
 pub use workspace_manager::WorkspaceManager;
 pub use workspace_manager::load_emmy_config;
 
+use crate::context::lsp_features::LspFeatures;
 use crate::context::snapshot::ServerContextInner;
 
 pub struct ServerContext {
@@ -31,7 +33,7 @@ pub struct ServerContext {
 }
 
 impl ServerContext {
-    pub fn new(conn: Connection, client_capabilities: Arc<ClientCapabilities>) -> Self {
+    pub fn new(conn: Connection, client_capabilities: ClientCapabilities) -> Self {
         let client = Arc::new(ClientProxy::new(Connection {
             sender: conn.sender.clone(),
             receiver: conn.receiver.clone(),
@@ -50,6 +52,7 @@ impl ServerContext {
             status_bar.clone(),
             file_diagnostic.clone(),
         )));
+        let lsp_features = Arc::new(LspFeatures::new(client_capabilities));
 
         ServerContext {
             conn,
@@ -60,7 +63,7 @@ impl ServerContext {
                 file_diagnostic,
                 workspace_manager,
                 status_bar,
-                client_capabilities,
+                lsp_features,
             }),
         }
     }

crates/emmylua_ls/src/context/snapshot.rs

@@ -1,9 +1,10 @@
-use lsp_types::ClientCapabilities;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
 use emmylua_code_analysis::EmmyLuaAnalysis;
 
+use crate::context::lsp_features::LspFeatures;
+
 use super::{
     client::ClientProxy, file_diagnostic::FileDiagnostic, status_bar::StatusBar,
     workspace_manager::WorkspaceManager,
@@ -39,8 +40,8 @@ impl ServerContextSnapshot {
         &self.inner.status_bar
     }
 
-    pub fn client_capabilities(&self) -> &ClientCapabilities {
-        &self.inner.client_capabilities
+    pub fn lsp_features(&self) -> &LspFeatures {
+        &self.inner.lsp_features
     }
 }
 
@@ -50,5 +51,5 @@ pub struct ServerContextInner {
     pub file_diagnostic: Arc<FileDiagnostic>,
     pub workspace_manager: Arc<RwLock<WorkspaceManager>>,
     pub status_bar: Arc<StatusBar>,
-    pub client_capabilities: Arc<ClientCapabilities>,
+    pub lsp_features: Arc<LspFeatures>,
 }

crates/emmylua_ls/src/handlers/configuration/mod.rs

@@ -23,12 +23,7 @@ pub async fn on_did_change_configuration(
 
     drop(workspace_manager);
 
-    let supports_config_request = context
-        .client_capabilities()
-        .workspace
-        .as_ref()?
-        .configuration
-        .unwrap_or_default();
+    let supports_config_request = context.lsp_features().supports_config_request();
 
     log::info!("change config client_id: {:?}", client_id);
     let new_client_config = get_client_config(&context, client_id, supports_config_request).await;

crates/emmylua_ls/src/handlers/document_diagnostic/mod.rs

@@ -0,0 +1,59 @@
+use lsp_types::{
+    ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, DocumentDiagnosticParams,
+    DocumentDiagnosticReport, DocumentDiagnosticReportResult, FullDocumentDiagnosticReport,
+    RelatedFullDocumentDiagnosticReport, ServerCapabilities,
+};
+use tokio_util::sync::CancellationToken;
+
+use crate::context::ServerContextSnapshot;
+
+use super::RegisterCapabilities;
+
+pub async fn on_pull_document_diagnostic(
+    context: ServerContextSnapshot,
+    params: DocumentDiagnosticParams,
+    token: CancellationToken,
+) -> DocumentDiagnosticReportResult {
+    let uri = params.text_document.uri;
+    let analysis = context.analysis().read().await;
+    let Some(file_id) = analysis.get_file_id(&uri) else {
+        return default_diagnostic_report();
+    };
+
+    let analysis = context.analysis().read().await;
+    let diagnostics = analysis.diagnose_file(file_id, token).unwrap_or_default();
+
+    DocumentDiagnosticReport::Full(RelatedFullDocumentDiagnosticReport {
+        related_documents: None,
+        full_document_diagnostic_report: FullDocumentDiagnosticReport {
+            result_id: None,
+            items: diagnostics,
+        },
+    })
+    .into()
+}
+
+fn default_diagnostic_report() -> DocumentDiagnosticReportResult {
+    DocumentDiagnosticReport::Full(RelatedFullDocumentDiagnosticReport {
+        related_documents: None,
+        full_document_diagnostic_report: FullDocumentDiagnosticReport {
+            result_id: None,
+            items: vec![],
+        },
+    })
+    .into()
+}
+
+pub struct DocumentDiagnosticCapabilities;
+
+impl RegisterCapabilities for DocumentDiagnosticCapabilities {
+    fn register_capabilities(server_capabilities: &mut ServerCapabilities, _: &ClientCapabilities) {
+        server_capabilities.diagnostic_provider =
+            Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
+                identifier: Some("EmmyLua".to_string()),
+                inter_file_dependencies: false,
+                workspace_diagnostics: false,
+                ..Default::default()
+            }))
+    }
+}

crates/emmylua_ls/src/handlers/mod.rs

@@ -6,6 +6,7 @@ mod completion;
 mod configuration;
 mod definition;
 mod document_color;
+mod document_diagnostic;
 mod document_formatting;
 mod document_highlight;
 mod document_link;
@@ -75,6 +76,7 @@ capabilities!(modules: {
     document_highlight => DocumentHighlightCapabilities,
     document_formatting => DocumentFormattingCapabilities,
     document_range_formatting => DocumentRangeFormattingCapabilities,
+    document_diagnostic => DocumentDiagnosticCapabilities,
     // document_type_format => DocumentTypeFormattingCapabilities,
     completion => CompletionCapabilities,
     inlay_hint => InlayHintCapabilities,

crates/emmylua_ls/src/handlers/request_handler.rs

@@ -5,15 +5,21 @@ use lsp_server::{Request, Response};
 use lsp_types::request::{
     CallHierarchyIncomingCalls, CallHierarchyOutgoingCalls, CallHierarchyPrepare,
     CodeActionRequest, CodeLensRequest, CodeLensResolve, ColorPresentationRequest, Completion,
-    DocumentColor, DocumentHighlightRequest, DocumentLinkRequest, DocumentLinkResolve,
-    DocumentSymbolRequest, ExecuteCommand, FoldingRangeRequest, Formatting, GotoDefinition,
-    GotoImplementation, HoverRequest, InlayHintRequest, InlayHintResolveRequest,
+    DocumentColor, DocumentDiagnosticRequest, DocumentHighlightRequest, DocumentLinkRequest,
+    DocumentLinkResolve, DocumentSymbolRequest, ExecuteCommand, FoldingRangeRequest, Formatting,
+    GotoDefinition, GotoImplementation, HoverRequest, InlayHintRequest, InlayHintResolveRequest,
     InlineValueRequest, OnTypeFormatting, PrepareRenameRequest, RangeFormatting, References,
     Rename, Request as LspRequest, ResolveCompletionItem, SelectionRangeRequest,
     SemanticTokensFullRequest, SignatureHelpRequest, WorkspaceSymbolRequest,
 };
 
-use crate::{context::ServerContext, handlers::document_type_format::on_type_formatting_handler};
+use crate::{
+    context::ServerContext,
+    handlers::{
+        document_diagnostic::on_pull_document_diagnostic,
+        document_type_format::on_type_formatting_handler,
+    },
+};
 
 use super::{
     call_hierarchy::{
@@ -112,6 +118,7 @@ pub async fn on_request_handler(
         CallHierarchyPrepare => on_prepare_call_hierarchy_handler,
         CallHierarchyIncomingCalls => on_incoming_calls_handler,
         CallHierarchyOutgoingCalls => on_outgoing_calls_handler,
+        DocumentDiagnosticRequest => on_pull_document_diagnostic,
     });
 
     Ok(())

crates/emmylua_ls/src/handlers/semantic_token/mod.rs

@@ -32,13 +32,18 @@ pub async fn on_semantic_token_handler(
     let client_id = workspace_manager.client_config.client_id;
     let _ = workspace_manager;
 
-    semantic_token(&analysis, file_id, context.client_capabilities(), client_id)
+    semantic_token(
+        &analysis,
+        file_id,
+        context.lsp_features().supports_multiline_tokens(),
+        client_id,
+    )
 }
 
 pub fn semantic_token(
     analysis: &EmmyLuaAnalysis,
     file_id: FileId,
-    client_capabilities: &ClientCapabilities,
+    supports_multiline_tokens: bool,
     client_id: ClientId,
 ) -> Option<SemanticTokensResult> {
     let semantic_model = analysis.compilation.get_semantic_model(file_id)?;
@@ -49,7 +54,7 @@ pub fn semantic_token(
 
     let result = build_semantic_tokens(
         &semantic_model,
-        supports_multiline_tokens(client_capabilities),
+        supports_multiline_tokens,
         client_id,
         emmyrc,
     )?;
@@ -79,14 +84,3 @@ impl RegisterCapabilities for SemanticTokenCapabilities {
         );
     }
 }
-
-fn supports_multiline_tokens(client_capability: &ClientCapabilities) -> bool {
-    if let Some(text_document) = &client_capability.text_document
-        && let Some(support) = &text_document.semantic_tokens
-        && let Some(support) = &support.multiline_token_support
-    {
-        return *support;
-    }
-
-    false
-}

crates/emmylua_ls/src/handlers/test_lib/mod.rs

@@ -2,11 +2,10 @@ use emmylua_code_analysis::{EmmyLuaAnalysis, Emmyrc, FileId, VirtualUrlGenerator
 use googletest::prelude::*;
 use itertools::Itertools;
 use lsp_types::{
-    ClientCapabilities, CodeActionOrCommand, CompletionItem, CompletionItemKind,
-    CompletionResponse, CompletionTriggerKind, GotoDefinitionResponse, Hover, HoverContents,
-    InlayHintLabel, Location, MarkupContent, Position, SemanticTokenModifier, SemanticTokenType,
-    SemanticTokensResult, SignatureHelpContext, SignatureHelpTriggerKind, SignatureInformation,
-    TextEdit,
+    CodeActionOrCommand, CompletionItem, CompletionItemKind, CompletionResponse,
+    CompletionTriggerKind, GotoDefinitionResponse, Hover, HoverContents, InlayHintLabel, Location,
+    MarkupContent, Position, SemanticTokenModifier, SemanticTokenType, SemanticTokensResult,
+    SignatureHelpContext, SignatureHelpTriggerKind, SignatureInformation, TextEdit,
 };
 use std::collections::HashSet;
 use std::{ops::Deref, sync::Arc};
@@ -493,14 +492,9 @@ impl ProviderVirtualWorkspace {
         expected: Vec<VirtualSemanticToken>,
     ) -> Result<()> {
         let file_id = self.def(block_str);
-        let result = semantic_token(
-            &self.analysis,
-            file_id,
-            &ClientCapabilities::default(),
-            ClientId::VSCode,
-        )
-        .ok_or("failed to get semantic tokens")
-        .or_fail()?;
+        let result = semantic_token(&self.analysis, file_id, true, ClientId::VSCode)
+            .ok_or("failed to get semantic tokens")
+            .or_fail()?;
         let SemanticTokensResult::Tokens(result) = result else {
             return fail!("expected SemanticTokensResult::Tokens, got {result:?}");
         };

crates/emmylua_ls/src/handlers/text_document/text_document_handler.rs

@@ -24,13 +24,15 @@ pub async fn on_did_open_text_document(
     }
 
     let file_id = analysis.update_file_by_uri(&uri, Some(text));
-    let emmyrc = analysis.get_emmyrc();
-    let interval = emmyrc.diagnostics.diagnostic_interval.unwrap_or(500);
-    if let Some(file_id) = file_id {
-        context
-            .file_diagnostic()
-            .add_diagnostic_task(file_id, interval)
-            .await;
+    if !context.lsp_features().supports_pull_diagnostics() {
+        let emmyrc = analysis.get_emmyrc();
+        let interval = emmyrc.diagnostics.diagnostic_interval.unwrap_or(500);
+        if let Some(file_id) = file_id {
+            context
+                .file_diagnostic()
+                .add_diagnostic_task(file_id, interval)
+                .await;
+        }
     }
 
     let mut workspace = context.workspace_manager().write().await;
@@ -87,13 +89,14 @@ pub async fn on_did_change_text_document(
         workspace.extend_reindex_delay().await;
         drop(workspace);
     }
-    if let Some(file_id) = file_id {
-        context
-            .file_diagnostic()
-            .add_diagnostic_task(file_id, interval)
-            .await;
+    if !context.lsp_features().supports_pull_diagnostics() {
+        if let Some(file_id) = file_id {
+            context
+                .file_diagnostic()
+                .add_diagnostic_task(file_id, interval)
+                .await;
+        }
     }
-
     Some(())
 }