LS: Proc macro disable option in config (#6706)

Author: Draggu

crates/cairo-lang-language-server/src/config.rs

@@ -38,6 +38,11 @@ pub struct Config {
     /// The property is set by the user under the `cairo1.traceMacroDiagnostics` key in client
     /// configuration.
     pub trace_macro_diagnostics: bool,
+    /// Whether to resolve procedural macros or ignore them.
+    ///
+    /// The property is set by the user under the `cairo1.enableProcMacros` key in client
+    /// configuration.
+    pub enable_proc_macros: bool,
 }
 
 impl Config {
@@ -61,6 +66,10 @@ impl Config {
                 scope_uri: None,
                 section: Some("cairo1.traceMacroDiagnostics".to_owned()),
             },
+            ConfigurationItem {
+                scope_uri: None,
+                section: Some("cairo1.enableProcMacros".to_owned()),
+            },
         ];
         let expected_len = items.len();
 
@@ -86,8 +95,12 @@ impl Config {
                     .map(Into::into);
                 state.config.trace_macro_diagnostics =
                     response.pop_front().as_ref().and_then(Value::as_bool).unwrap_or_default();
+                state.config.enable_proc_macros =
+                    response.pop_front().as_ref().and_then(Value::as_bool).unwrap_or(true);
 
                 debug!("reloaded configuration: {:#?}", state.config);
+
+                state.proc_macro_controller.on_config_change(&mut state.db, &state.config);
             })
         };
 

crates/cairo-lang-language-server/src/lang/proc_macros/controller.rs

@@ -15,6 +15,7 @@ use tracing::error;
 use super::client::connection::ProcMacroServerConnection;
 use super::client::status::ClientStatus;
 use super::client::{ProcMacroClient, RequestParams};
+use crate::config::Config;
 use crate::lang::db::AnalysisDatabase;
 use crate::lang::proc_macros::db::ProcMacroGroup;
 use crate::lang::proc_macros::plugins::proc_macro_plugin_suite;
@@ -84,18 +85,18 @@ impl ProcMacroClientController {
         }
     }
 
-    /// Start proc-macro-server.
+    /// Start proc-macro-server after config reload.
     /// Note that this will only try to go from `ClientStatus::Pending` to
-    /// `ClientStatus::Starting`.
-    pub fn initialize_once(&mut self, db: &mut AnalysisDatabase) {
+    /// `ClientStatus::Starting` if config allows this.
+    pub fn on_config_change(&mut self, db: &mut AnalysisDatabase, config: &Config) {
         if db.proc_macro_client_status().is_pending() {
-            self.try_initialize(db);
+            self.try_initialize(db, config);
         }
     }
 
     /// Check if an error was reported. If so, try to restart.
-    pub fn handle_error(&mut self, db: &mut AnalysisDatabase) {
-        if !self.try_initialize(db) {
+    pub fn handle_error(&mut self, db: &mut AnalysisDatabase, config: &Config) {
+        if !self.try_initialize(db, config) {
             self.fatal_failed(db, ProcMacroServerInitializationFailedParams::NoMoreRetries {
                 retries: RATE_LIMITER_RETRIES,
                 in_minutes: RATE_LIMITER_PERIOD_SEC / 60,
@@ -104,11 +105,11 @@ impl ProcMacroClientController {
     }
 
     /// If the client is ready, apply all available responses.
-    pub fn on_response(&mut self, db: &mut AnalysisDatabase) {
+    pub fn on_response(&mut self, db: &mut AnalysisDatabase, config: &Config) {
         match db.proc_macro_client_status() {
             ClientStatus::Starting(client) => {
                 let Ok(defined_macros) = client.finish_initialize() else {
-                    self.handle_error(db);
+                    self.handle_error(db, config);
 
                     return;
                 };
@@ -124,17 +125,19 @@ impl ProcMacroClientController {
                 db.set_proc_macro_client_status(ClientStatus::Ready(client));
             }
             ClientStatus::Ready(client) => {
-                self.apply_responses(db, &client);
+                self.apply_responses(db, config, &client);
             }
             _ => {}
         }
     }
 
-    /// Tries starting proc-macro-server initialization process.
+    /// Tries starting proc-macro-server initialization process, if allowed by config.
     ///
     /// Returns value indicating if initialization was attempted.
-    fn try_initialize(&mut self, db: &mut AnalysisDatabase) -> bool {
-        let initialize = self.initialization_retries.check().is_ok();
+    fn try_initialize(&mut self, db: &mut AnalysisDatabase, config: &Config) -> bool {
+        // Keep the rate limiter check as second condition when config doesn't allow it to make
+        // sure it is not impacted.
+        let initialize = config.enable_proc_macros && self.initialization_retries.check().is_ok();
 
         if initialize {
             self.spawn_server(db);
@@ -176,7 +179,12 @@ impl ProcMacroClientController {
         self.notifier.notify::<ProcMacroServerInitializationFailed>(params);
     }
 
-    fn apply_responses(&mut self, db: &mut AnalysisDatabase, client: &ProcMacroClient) {
+    fn apply_responses(
+        &mut self,
+        db: &mut AnalysisDatabase,
+        config: &Config,
+        client: &ProcMacroClient,
+    ) {
         let mut attribute_resolutions = Arc::unwrap_or_clone(db.attribute_macro_resolution());
         let mut attribute_resolutions_changed = false;
 
@@ -218,7 +226,7 @@ impl ProcMacroClientController {
         // This must be called AFTER `client.available_responses()` is dropped, otherwise we can
         // deadlock.
         if error_occurred {
-            self.handle_error(db);
+            self.handle_error(db, config);
         }
 
         // Set input only if resolution changed, this way we don't recompute queries if there were

crates/cairo-lang-language-server/src/lib.rs

@@ -269,8 +269,6 @@ impl Backend {
     fn run(self) -> Result<JoinHandle<Result<()>>> {
         event_loop_thread(move || {
             let Self { mut state, connection } = self;
-
-            state.proc_macro_controller.initialize_once(&mut state.db);
             let proc_macro_channels = state.proc_macro_controller.init_channels();
 
             let mut scheduler = Scheduler::new(&mut state, connection.make_sender());
@@ -380,13 +378,13 @@ impl Backend {
     /// Calls [`lang::proc_macros::controller::ProcMacroClientController::handle_error`] to do its
     /// work.
     fn on_proc_macro_error(state: &mut State, _: Notifier, _: &mut Requester<'_>, _: Responder) {
-        state.proc_macro_controller.handle_error(&mut state.db);
+        state.proc_macro_controller.handle_error(&mut state.db, &state.config);
     }
 
     /// Calls [`lang::proc_macros::controller::ProcMacroClientController::on_response`] to do its
     /// work.
     fn on_proc_macro_response(state: &mut State, _: Notifier, _: &mut Requester<'_>, _: Responder) {
-        state.proc_macro_controller.on_response(&mut state.db);
+        state.proc_macro_controller.on_response(&mut state.db, &state.config);
     }
 
     /// Calls [`lang::db::AnalysisDatabaseSwapper::maybe_swap`] to do its work.

vscode-cairo/package.json

@@ -141,6 +141,12 @@
             "default": true,
             "description": "Show CairoLS information in the status bar.",
             "scope": "window"
+          },
+          "cairo1.enableProcMacros": {
+            "type": "boolean",
+            "default": true,
+            "description": "Enable support for procedural macros.",
+            "scope": "window"
           }
         }
       }