debugging sync module

Author: JoshuaBatty

sway-lsp/src/capabilities/semantic_tokens.rs

@@ -25,6 +25,13 @@ pub fn semantic_tokens_range(
     range: &Range,
 ) -> Option<SemanticTokensRangeResult> {
     let _p = tracing::trace_span!("semantic_tokens_range").entered();
+    eprintln!("semantic_tokens_range request for: url: {:?}", url.to_file_path().unwrap());
+    let mut k = std::collections::HashSet::new();
+    for i in token_map.iter() {
+        let key = i.key().path.clone();
+        k.insert(key.clone());
+    }
+    eprintln!("token map keys: {:?}", k);
     let tokens: Vec<_> = token_map
         .tokens_for_file(url)
         .filter(|item| {
@@ -33,6 +40,7 @@ pub fn semantic_tokens_range(
             token_range.start >= range.start && token_range.end <= range.end
         })
         .collect();
+    eprintln!("semantic_tokens_range: token length: {:?} | url: {:?}", tokens.len(), url.to_file_path().unwrap());
     let sorted_tokens_refs = sort_tokens(&tokens);
     Some(semantic_tokens(&sorted_tokens_refs[..]).into())
 }

sway-lsp/src/core/session.rs

@@ -336,6 +336,7 @@ pub fn traverse(
     session: Arc<Session>,
     token_map: &TokenMap,
     lsp_mode: Option<&LspConfig>,
+    program_id: ProgramId,
 ) -> Result<Option<CompileResults>, LanguageServerError> {
     let _p = tracing::trace_span!("traverse").entered();
     let modified_file = lsp_mode.and_then(|mode| {
@@ -344,9 +345,11 @@ pub fn traverse(
             .find_map(|(path, version)| version.map(|_| path.clone()))
     });
     if let Some(path) = &modified_file {
+        eprintln!("removing tokens for file: {:?}", path);
         token_map.remove_tokens_for_file(path);
     } else {
-        token_map.clear();
+        eprintln!("this is where we used to remove all tokens");
+        token_map.remove_tokens_for_program(program_id);
     }
 
     session.metrics.clear();
@@ -390,6 +393,7 @@ pub fn traverse(
                 let modified_program_id = program_id_from_path(modified_file, engines)?;
                 // We can skip traversing the programs for this iteration as they are unchanged.
                 if program_id != modified_program_id {
+                    eprintln!("skipping traversing program: {:?}", program_id);
                     continue;
                 }
             }
@@ -465,33 +469,42 @@ pub fn parse_project(
     session: Arc<Session>,
     token_map: Arc<TokenMap>,
 ) -> Result<(), LanguageServerError> {
+    eprintln!("parse_project");
     let _p = tracing::trace_span!("parse_project").entered();
+    let program_id = program_id_from_url(&uri, engines_clone)?;
+
     let build_plan = session
         .build_plan_cache
         .get_or_update(&session.sync.manifest_path(), || build_plan(uri))?;
 
+    eprintln!("compile");
     let results = compile(
         &build_plan,
         engines_clone,
         retrigger_compilation,
         lsp_mode.as_ref(),
     )?;
-
+    eprintln!("compile done");
     // Check if the last result is None or if results is empty, indicating an error occurred in the compiler.
     // If we don't return an error here, then we will likely crash when trying to access the Engines
     // during traversal or when creating runnables.
     if results.last().is_none_or(|(value, _)| value.is_none()) {
         return Err(LanguageServerError::ProgramsIsNone);
     }
 
+    eprintln!("traverse");
     let diagnostics = traverse(
         results,
         engines_original.clone(),
         engines_clone,
         session.clone(),
         &token_map,
         lsp_mode.as_ref(),
+        program_id,
     )?;
+    let tokens_for_program = token_map.tokens_for_file(&uri).collect::<Vec<_>>();
+    eprintln!("tokens_for_program: {:?}", tokens_for_program.len());
+
     if let Some(config) = &lsp_mode {
         // Only write the diagnostics results on didSave or didOpen.
         if !config.optimized_build {
@@ -503,8 +516,6 @@ pub fn parse_project(
     }
 
     session.runnables.clear();
-    let path = uri.to_file_path().unwrap();
-    let program_id = program_id_from_path(&path, engines_clone)?;
     if let Some(metrics) = session.metrics.get(&program_id) {
         // Check if the cached AST was returned by the compiler for the users workspace.
         // If it was, then we need to use the original engines.
@@ -690,6 +701,11 @@ pub fn program_id_from_path(
     Ok(program_id)
 }
 
+pub fn program_id_from_url(url: &Url, engines: &Engines) -> Result<ProgramId, DirectoryError> {
+    let path = url.to_file_path().unwrap();
+    program_id_from_path(&path, engines)
+}
+
 /// A cache for storing and retrieving BuildPlan objects.
 #[derive(Debug, Clone)]
 pub struct BuildPlanCache {

sway-lsp/src/core/token_map.rs

@@ -20,7 +20,7 @@ pub use crate::core::token_map_ext::TokenMapExt;
 ///
 /// The TokenMap is a wrapper around a [DashMap], which is a concurrent HashMap.
 #[derive(Debug, Default)]
-pub struct TokenMap(DashMap<TokenIdent, Token>);
+pub struct TokenMap(pub DashMap<TokenIdent, Token>);
 
 impl<'a> TokenMap {
     /// Create a new token map.
@@ -256,6 +256,11 @@ impl<'a> TokenMap {
         self.0
             .retain(|key, _value| (key.path.as_ref() != Some(path_to_remove)));
     }
+
+    /// Remove all tokens for the given program from the token map.
+    pub fn remove_tokens_for_program(&self, program_id: ProgramId) {
+        self.0.retain(|key, _value| (key.program_id() != Some(program_id)));
+    }
 }
 
 impl std::ops::Deref for TokenMap {

sway-lsp/src/handlers/notification.rs

@@ -23,11 +23,15 @@ pub async fn handle_did_open_text_document(
     let (uri, session) = state
         .uri_and_session_from_workspace(&params.text_document.uri)
         .await?;
+    eprintln!("did_open for {:?}", uri.to_file_path().unwrap());
+
     state.documents.handle_open_file(&uri).await;
 
     send_new_compilation_request(state, session.clone(), &uri, None, false);
     state.is_compiling.store(true, Ordering::SeqCst);
+    eprintln!("did_open: waiting for parsing to finish for {:?}", uri.to_file_path().unwrap());
     state.wait_for_parsing().await;
+    eprintln!("did_open: publishing diagnostics for {:?}", uri.to_file_path().unwrap());
     state
         .publish_diagnostics(uri, params.text_document.uri, session)
         .await;
@@ -42,9 +46,11 @@ fn send_new_compilation_request(
     version: Option<i32>,
     optimized_build: bool,
 ) {
+    eprintln!("new compilation request for {:?}", uri.to_file_path().unwrap());
     let file_versions = file_versions(&state.documents, uri, version.map(|v| v as u64));
 
     if state.is_compiling.load(Ordering::SeqCst) {
+        eprintln!("cancelling existing compilation and retriggering compilation for {:?}", uri.to_file_path().unwrap());
         // If we are already compiling, then we need to retrigger compilation
         state.retrigger_compilation.store(true, Ordering::SeqCst);
     }
@@ -58,6 +64,7 @@ fn send_new_compilation_request(
         }
     }
 
+    eprintln!("sending compilation request for {:?}", uri.to_file_path().unwrap());
     let _ = state
         .cb_tx
         .send(TaskMessage::CompilationContext(CompilationContext {

sway-lsp/src/handlers/request.rs

@@ -329,16 +329,20 @@ pub async fn handle_semantic_tokens_range(
     state: &ServerState,
     params: SemanticTokensRangeParams,
 ) -> Result<Option<SemanticTokensRangeResult>> {
+    eprintln!("semantic tokens req, waiting for parsing| params uri: {:?}", params.text_document.uri.to_file_path().unwrap());
     let _ = state.wait_for_parsing().await;
     match state
         .uri_and_session_from_workspace(&params.text_document.uri)
         .await
     {
-        Ok((uri, _session)) => Ok(capabilities::semantic_tokens::semantic_tokens_range(
+        Ok((uri, _session)) => {
+            eprintln!("semantic tokens req, got uri: {:?}", uri.to_file_path().unwrap());
+            Ok(capabilities::semantic_tokens::semantic_tokens_range(
             &state.token_map,
             &uri,
             &params.range,
-        )),
+        ))
+        },
         Err(err) => {
             tracing::error!("{}", err.to_string());
             Ok(None)

sway-lsp/src/server_state.rs

@@ -137,6 +137,7 @@ impl ServerState {
             while let Ok(msg) = rx.recv() {
                 match msg {
                     TaskMessage::CompilationContext(ctx) => {
+                        eprintln!("compilation context received for {:?}", ctx.uri.as_ref().unwrap().to_file_path().unwrap());
                         let uri = ctx.uri.as_ref().unwrap().clone();
                         let session = ctx.session.as_ref().unwrap().clone();
                         let engines_original = ctx.engines.clone();
@@ -160,6 +161,7 @@ impl ServerState {
                             file_versions: ctx.file_versions,
                         });
 
+                        eprintln!("compiling for {:?}", uri.to_file_path().unwrap());
                         // Set the is_compiling flag to true so that the wait_for_parsing function knows that we are compiling
                         is_compiling.store(true, Ordering::SeqCst);
                         match session::parse_project(
@@ -176,6 +178,7 @@ impl ServerState {
                                 // Find the program id from the path
                                 match session::program_id_from_path(&path, &engines_clone) {
                                     Ok(program_id) => {
+                                        eprintln!("compilation success for {:?}", uri.to_file_path().unwrap());
                                         // Use the program id to get the metrics for the program
                                         if let Some(metrics) = session.metrics.get(&program_id) {
                                             // It's very important to check if the workspace AST was reused to determine if we need to overwrite the engines.
@@ -198,23 +201,27 @@ impl ServerState {
                                             LastCompilationState::Success;
                                     }
                                     Err(err) => {
+                                        eprintln!("compilation failed for {:?}", uri.to_file_path().unwrap());
                                         tracing::error!("{}", err.to_string());
                                         *last_compilation_state.write() =
                                             LastCompilationState::Failed;
                                     }
                                 }
                             }
                             Err(_err) => {
+                                eprintln!("compilation failed for {:?}", uri.to_file_path().unwrap());
                                 *last_compilation_state.write() = LastCompilationState::Failed;
                             }
                         }
 
                         // Reset the flags to false
                         is_compiling.store(false, Ordering::SeqCst);
                         retrigger_compilation.store(false, Ordering::SeqCst);
+                        eprintln!("resetting compilation flags for {:?}", uri.to_file_path().unwrap());
 
                         // Make sure there isn't any pending compilation work
                         if rx.is_empty() {
+                            eprintln!("finished compilation, notify waiters for {:?}", uri.to_file_path().unwrap());
                             // finished compilation, notify waiters
                             finished_compilation.notify_waiters();
                         }
@@ -303,6 +310,7 @@ impl ServerState {
         session: Arc<Session>,
     ) {
         let diagnostics = self.diagnostics(&uri, session.clone());
+        eprintln!("diagnostics len = {:?}", diagnostics.len());
         // Note: Even if the computed diagnostics vec is empty, we still have to push the empty Vec
         // in order to clear former diagnostics. Newly pushed diagnostics always replace previously pushed diagnostics.
         if let Some(client) = self.client.as_ref() {