Add vhdl_ls no-lint argument

Author: kraigher

vhdl_ls/src/lib.rs

@@ -12,3 +12,4 @@ mod rpc_channel;
 mod stdio_server;
 mod vhdl_server;
 pub use crate::stdio_server::start;
+pub use crate::vhdl_server::VHDLServerSettings;

vhdl_ls/src/main.rs

@@ -5,15 +5,22 @@
 // Copyright (c) 2018, Olof Kraigher olof.kraigher@gmail.com
 
 use clap::Parser;
+use vhdl_ls::VHDLServerSettings;
 
 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
-struct Args {}
+struct Args {
+    /// Disable diagnostic messages, only use navigation and hover features
+    #[arg(long, default_value_t = false)]
+    no_lint: bool,
+}
 
 fn main() {
-    Args::parse();
+    let args = Args::parse();
 
     env_logger::init();
     log::info!("Starting language server");
-    vhdl_ls::start();
+    vhdl_ls::start(VHDLServerSettings {
+        no_lint: args.no_lint,
+    });
 }

vhdl_ls/src/stdio_server.rs

@@ -14,12 +14,13 @@ use std::{cell::RefCell, rc::Rc};
 
 use crate::rpc_channel::RpcChannel;
 use crate::vhdl_server::VHDLServer;
+use crate::vhdl_server::VHDLServerSettings;
 
 /// Set up the IO channel for `stdio` and start the VHDL language server.
-pub fn start() {
+pub fn start(settings: VHDLServerSettings) {
     let (connection, io_threads) = Connection::stdio();
     let connection_rpc = ConnectionRpcChannel::new(connection);
-    let mut server = VHDLServer::new(connection_rpc.clone());
+    let mut server = VHDLServer::new_settings(connection_rpc.clone(), settings);
 
     connection_rpc.handle_initialization(&mut server);
     connection_rpc.main_event_loop(server);

vhdl_ls/src/vhdl_server.rs

@@ -14,22 +14,36 @@ use std::io;
 use std::path::{Path, PathBuf};
 use vhdl_lang::{Config, Diagnostic, Message, Project, Severity, Source, SrcPos};
 
+#[derive(Default, Clone)]
+pub struct VHDLServerSettings {
+    pub no_lint: bool,
+}
+
 pub struct VHDLServer<T: RpcChannel + Clone> {
     rpc_channel: T,
+    settings: VHDLServerSettings,
     // To have well defined unit tests that are not affected by environment
     use_external_config: bool,
     server: Option<InitializedVHDLServer<T>>,
     config_file: Option<PathBuf>,
 }
 
 impl<T: RpcChannel + Clone> VHDLServer<T> {
-    pub fn new(rpc_channel: T) -> VHDLServer<T> {
-        Self::new_external_config(rpc_channel, true)
+    pub fn new_settings(rpc_channel: T, settings: VHDLServerSettings) -> VHDLServer<T> {
+        VHDLServer {
+            rpc_channel,
+            settings,
+            use_external_config: true,
+            server: None,
+            config_file: None,
+        }
     }
 
+    #[cfg(test)]
     fn new_external_config(rpc_channel: T, use_external_config: bool) -> VHDLServer<T> {
         VHDLServer {
             rpc_channel,
+            settings: Default::default(),
             use_external_config,
             server: None,
             config_file: None,
@@ -86,7 +100,12 @@ impl<T: RpcChannel + Clone> VHDLServer<T> {
     pub fn initialize_request(&mut self, params: InitializeParams) -> InitializeResult {
         self.config_file = self.root_uri_config_file(&params);
         let config = self.load_config();
-        let (server, result) = InitializedVHDLServer::new(self.rpc_channel.clone(), config, params);
+        let (server, result) = InitializedVHDLServer::new(
+            self.rpc_channel.clone(),
+            self.settings.clone(),
+            config,
+            params,
+        );
         self.server = Some(server);
         result
     }
@@ -212,6 +231,7 @@ impl<T: RpcChannel + Clone> VHDLServer<T> {
 
 struct InitializedVHDLServer<T: RpcChannel> {
     rpc_channel: T,
+    settings: VHDLServerSettings,
     init_params: InitializeParams,
     project: Project,
     files_with_notifications: FnvHashMap<Url, ()>,
@@ -235,13 +255,15 @@ impl<T: RpcChannel> RpcChannel for InitializedVHDLServer<T> {
 impl<T: RpcChannel + Clone> InitializedVHDLServer<T> {
     pub fn new(
         rpc_channel: T,
+        settings: VHDLServerSettings,
         config: Config,
         init_params: InitializeParams,
     ) -> (InitializedVHDLServer<T>, InitializeResult) {
         let project = Project::from_config(&config, &mut MessageChannel::new(&rpc_channel));
 
         let server = InitializedVHDLServer {
             rpc_channel,
+            settings,
             init_params,
             project,
             files_with_notifications: FnvHashMap::default(),
@@ -303,6 +325,10 @@ impl<T: RpcChannel + Clone> InitializedVHDLServer<T> {
     }
 
     fn publish_diagnostics(&mut self) {
+        if self.settings.no_lint {
+            return;
+        }
+
         let supports_related_information = self.client_supports_related_information();
         let diagnostics = self.project.analyse();
         let diagnostics = {