Implement a more responsive compilation thread in the the language server.

forc-pkg/src/pkg.rs

@@ -23,7 +23,7 @@ use std::{
     io::Write,
     path::{Path, PathBuf},
     str::FromStr,
-    sync::Arc,
+    sync::{atomic::AtomicBool, Arc},
 };
 pub use sway_core::Programs;
 use sway_core::{
@@ -1776,6 +1776,7 @@ pub fn compile(
             namespace,
             Some(&sway_build_config),
             &pkg.name,
+            None,
         ),
         Some(sway_build_config.clone()),
         metrics
@@ -2581,6 +2582,7 @@ pub fn check(
     terse_mode: bool,
     include_tests: bool,
     engines: &Engines,
+    retrigger_compilation: Option<Arc<AtomicBool>>,
 ) -> anyhow::Result<Vec<(Option<Programs>, Handler)>> {
     let mut lib_namespace_map = Default::default();
     let mut source_map = SourceMap::new();
@@ -2636,8 +2638,17 @@ pub fn check(
             dep_namespace,
             Some(&build_config),
             &pkg.name,
+            retrigger_compilation.clone(),
         );
 
+        if retrigger_compilation
+            .as_ref()
+            .map(|b| b.load(std::sync::atomic::Ordering::SeqCst))
+            .unwrap_or(false)
+        {
+            bail!("compilation was retriggered")
+        }
+
         let programs = match programs_res.as_ref() {
             Ok(programs) => programs,
             _ => {

forc-plugins/forc-doc/src/main.rs

@@ -218,6 +218,7 @@ pub fn compile_html(
         build_instructions.silent,
         tests_enabled,
         &engines,
+        None,
     )?;
 
     let raw_docs = if !build_instructions.no_deps {

forc/src/ops/forc_check.rs

@@ -34,7 +34,14 @@ pub fn check(command: CheckCommand, engines: &Engines) -> Result<(Option<ty::TyP
     )?;
     let tests_enabled = !disable_tests;
 
-    let mut v = pkg::check(&plan, build_target, terse_mode, tests_enabled, engines)?;
+    let mut v = pkg::check(
+        &plan,
+        build_target,
+        terse_mode,
+        tests_enabled,
+        engines,
+        None,
+    )?;
     let (res, handler) = v
         .pop()
         .expect("there is guaranteed to be at least one elem in the vector");

sway-core/src/decl_engine/engine.rs

@@ -34,6 +34,25 @@ pub struct DeclEngine {
     parents: RwLock<HashMap<AssociatedItemDeclId, Vec<AssociatedItemDeclId>>>,
 }
 
+impl Clone for DeclEngine {
+    fn clone(&self) -> Self {
+        DeclEngine {
+            function_slab: self.function_slab.clone(),
+            trait_slab: self.trait_slab.clone(),
+            trait_fn_slab: self.trait_fn_slab.clone(),
+            trait_type_slab: self.trait_type_slab.clone(),
+            impl_trait_slab: self.impl_trait_slab.clone(),
+            struct_slab: self.struct_slab.clone(),
+            storage_slab: self.storage_slab.clone(),
+            abi_slab: self.abi_slab.clone(),
+            constant_slab: self.constant_slab.clone(),
+            enum_slab: self.enum_slab.clone(),
+            type_alias_slab: self.type_alias_slab.clone(),
+            parents: RwLock::new(self.parents.read().unwrap().clone()),
+        }
+    }
+}
+
 pub trait DeclEngineGet<I, U> {
     fn get(&self, index: &I) -> Arc<U>;
 }

sway-core/src/engine_threading.rs

@@ -6,7 +6,7 @@ use std::{
 };
 use sway_types::SourceEngine;
 
-#[derive(Debug, Default)]
+#[derive(Clone, Debug, Default)]
 pub struct Engines {
     type_engine: TypeEngine,
     decl_engine: DeclEngine,

sway-core/src/ir_generation/const_eval.rs

@@ -1140,6 +1140,7 @@ mod tests {
             core_lib,
             None,
             "test",
+            None,
         );
 
         let (errors, _warnings) = handler.consume();

sway-core/src/lib.rs

@@ -35,6 +35,7 @@ use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use sway_ast::AttributeDecl;
 use sway_error::handler::{ErrorEmitted, Handler};
@@ -467,6 +468,7 @@ pub fn parsed_to_ast(
     initial_namespace: namespace::Module,
     build_config: Option<&BuildConfig>,
     package_name: &str,
+    retrigger_compilation: Option<Arc<AtomicBool>>,
 ) -> Result<ty::TyProgram, ErrorEmitted> {
     // Type check the program.
     let typed_program_opt = ty::TyProgram::type_check(
@@ -477,6 +479,8 @@ pub fn parsed_to_ast(
         package_name,
     );
 
+    check_should_abort(handler, retrigger_compilation.clone())?;
+
     let mut typed_program = match typed_program_opt {
         Ok(typed_program) => typed_program,
         Err(e) => return Err(e),
@@ -524,6 +528,9 @@ pub fn parsed_to_ast(
         ),
         None => (None, None),
     };
+
+    check_should_abort(handler, retrigger_compilation.clone())?;
+
     // Perform control flow analysis and extend with any errors.
     let _ = perform_control_flow_analysis(
         handler,
@@ -596,7 +603,10 @@ pub fn compile_to_ast(
     initial_namespace: namespace::Module,
     build_config: Option<&BuildConfig>,
     package_name: &str,
+    retrigger_compilation: Option<Arc<AtomicBool>>,
 ) -> Result<Programs, ErrorEmitted> {
+    check_should_abort(handler, retrigger_compilation.clone())?;
+
     let query_engine = engines.qe();
     let mut metrics = PerformanceData::default();
 
@@ -612,7 +622,6 @@ pub fn compile_to_ast(
             let (warnings, errors) = entry.handler_data;
             let new_handler = Handler::from_parts(warnings, errors);
             handler.append(new_handler);
-
             return Ok(entry.programs);
         };
     }
@@ -626,6 +635,8 @@ pub fn compile_to_ast(
         metrics
     );
 
+    check_should_abort(handler, retrigger_compilation.clone())?;
+
     let (lexed_program, mut parsed_program) = match parse_program_opt {
         Ok(modules) => modules,
         Err(e) => {
@@ -653,18 +664,20 @@ pub fn compile_to_ast(
             initial_namespace,
             build_config,
             package_name,
+            retrigger_compilation.clone(),
         ),
         build_config,
         metrics
     );
 
+    check_should_abort(handler, retrigger_compilation.clone())?;
+
     handler.dedup();
 
     let programs = Programs::new(lexed_program, parsed_program, typed_res, metrics);
 
     if let Some(config) = build_config {
         let path = config.canonical_root_module();
-
         let cache_entry = ProgramsCacheEntry {
             path,
             programs: programs.clone(),
@@ -693,6 +706,7 @@ pub fn compile_to_asm(
         initial_namespace,
         Some(&build_config),
         package_name,
+        None,
     )?;
     ast_to_asm(handler, engines, &ast_res, &build_config)
 }
@@ -942,6 +956,20 @@ fn module_return_path_analysis(
     }
 }
 
+/// Check if the retrigger compilation flag has been set to true in the language server.
+/// If it has, there is a new compilation request, so we should abort the current compilation.
+fn check_should_abort(
+    handler: &Handler,
+    retrigger_compilation: Option<Arc<AtomicBool>>,
+) -> Result<(), ErrorEmitted> {
+    if let Some(ref retrigger_compilation) = retrigger_compilation {
+        if retrigger_compilation.load(Ordering::SeqCst) {
+            return Err(handler.cancel());
+        }
+    }
+    Ok(())
+}
+
 #[test]
 fn test_basic_prog() {
     let handler = Handler::default();

sway-core/src/query_engine/mod.rs

@@ -51,6 +51,15 @@ pub struct QueryEngine {
     programs_cache: RwLock<ProgramsCacheMap>,
 }
 
+impl Clone for QueryEngine {
+    fn clone(&self) -> Self {
+        Self {
+            parse_module_cache: RwLock::new(self.parse_module_cache.read().unwrap().clone()),
+            programs_cache: RwLock::new(self.programs_cache.read().unwrap().clone()),
+        }
+    }
+}
+
 impl QueryEngine {
     pub fn get_parse_module_cache_entry(&self, path: &ModuleCacheKey) -> Option<ModuleCacheEntry> {
         let cache = self.parse_module_cache.read().unwrap();
@@ -67,7 +76,10 @@ impl QueryEngine {
     }
 
     pub fn get_programs_cache_entry(&self, path: &Arc<PathBuf>) -> Option<ProgramsCacheEntry> {
-        let cache = self.programs_cache.read().unwrap();
+        let cache = self
+            .programs_cache
+            .read()
+            .expect("Failed to read programs cache");
         cache.get(path).cloned()
     }
 

sway-core/src/type_system/engine.rs

@@ -22,6 +22,15 @@ pub struct TypeEngine {
     id_map: RwLock<HashMap<TypeSourceInfo, TypeId>>,
 }
 
+impl Clone for TypeEngine {
+    fn clone(&self) -> Self {
+        TypeEngine {
+            slab: self.slab.clone(),
+            id_map: RwLock::new(self.id_map.read().unwrap().clone()),
+        }
+    }
+}
+
 impl TypeEngine {
     /// Inserts a [TypeInfo] into the [TypeEngine] and returns a [TypeId]
     /// referring to that [TypeInfo].

sway-error/src/handler.rs

@@ -34,6 +34,11 @@ impl Handler {
         ErrorEmitted { _priv: () }
     }
 
+    // Compilation should be cancelled.
+    pub fn cancel(&self) -> ErrorEmitted {
+        ErrorEmitted { _priv: () }
+    }
+
     /// Emit the warning `warn`.
     pub fn emit_warn(&self, warn: CompileWarning) {
         self.inner.borrow_mut().warnings.push(warn);

sway-lsp/Cargo.toml

@@ -10,6 +10,7 @@ repository.workspace = true
 
 [dependencies]
 anyhow = "1.0.41"
+crossbeam-channel = "0.5"
 dashmap = "5.4"
 fd-lock = "4.0"
 forc-pkg = { version = "0.48.1", path = "../forc-pkg" }
@@ -46,7 +47,7 @@ tokio = { version = "1.3", features = [
     "time",
 ] }
 toml_edit = "0.19"
-tower-lsp = { version = "0.19", features = ["proposed"] }
+tower-lsp = { version = "0.20", features = ["proposed"] }
 tracing = "0.1"
 urlencoding = "2.1.2"
 

sway-lsp/benches/lsp_benchmarks/compile.rs

@@ -1,39 +1,33 @@
 use criterion::{black_box, criterion_group, Criterion};
 use lsp_types::Url;
 use sway_core::Engines;
-use sway_lsp::core::session::{self, Session};
-use tokio::runtime::Runtime;
+use sway_lsp::core::session;
 
-const NUM_DID_CHANGE_ITERATIONS: usize = 4;
+const NUM_DID_CHANGE_ITERATIONS: usize = 10;
 
 fn benchmarks(c: &mut Criterion) {
     // Load the test project
     let uri = Url::from_file_path(super::benchmark_dir().join("src/main.sw")).unwrap();
-    let session = Runtime::new().unwrap().block_on(async {
-        let session = Session::new();
-        session.handle_open_file(&uri).await;
-        session
-    });
-
     c.bench_function("compile", |b| {
         b.iter(|| {
             let engines = Engines::default();
-            let _ = black_box(session::compile(&uri, &engines).unwrap());
+            let _ = black_box(session::compile(&uri, &engines, None).unwrap());
         })
     });
 
     c.bench_function("traverse", |b| {
         let engines = Engines::default();
-        let results = black_box(session::compile(&uri, &engines).unwrap());
+        let results = black_box(session::compile(&uri, &engines, None).unwrap());
         b.iter(|| {
             let _ = black_box(session::traverse(results.clone(), &engines).unwrap());
         })
     });
 
     c.bench_function("did_change_with_caching", |b| {
+        let engines = Engines::default();
         b.iter(|| {
             for _ in 0..NUM_DID_CHANGE_ITERATIONS {
-                let _ = black_box(session::compile(&uri, &session.engines.read()).unwrap());
+                let _ = black_box(session::compile(&uri, &engines, None).unwrap());
             }
         })
     });