lsp: Make WASM build again

... the wasm preview still does not work though.

Author: hunger

internal/compiler/lib.rs

@@ -91,6 +91,10 @@ pub type FontCache = Rc<
     >,
 >;
 
+pub type OpenImportFallback =
+    Rc<dyn Fn(String) -> Pin<Box<dyn Future<Output = Option<std::io::Result<String>>>>>>;
+pub type ResourceUrlMapper = Rc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = Option<String>>>>>;
+
 /// CompilationConfiguration allows configuring different aspects of the compiler.
 #[derive(Clone)]
 pub struct CompilerConfiguration {
@@ -111,14 +115,11 @@ pub struct CompilerConfiguration {
     ///
     /// The callback should open the file specified by the given file name and
     /// return an future that provides the text content of the file as output.
-    pub open_import_fallback: Option<
-        Rc<dyn Fn(String) -> Pin<Box<dyn Future<Output = Option<std::io::Result<String>>>>>>,
-    >,
+    pub open_import_fallback: Option<OpenImportFallback>,
     /// Callback to map URLs for resources
     ///
     /// The function takes the url and returns the mapped URL (or None if not mapped)
-    pub resource_url_mapper:
-        Option<Rc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = Option<String>>>>>>,
+    pub resource_url_mapper: Option<ResourceUrlMapper>,
 
     /// Run the pass that inlines all the elements.
     ///

tools/lsp/common/document_cache.rs

@@ -32,21 +32,19 @@ fn default_cc() -> i_slint_compiler::CompilerConfiguration {
     )
 }
 
-pub type OpenImportFallback = Option<
-    Rc<
-        dyn Fn(
-            String,
-        ) -> Pin<
-            Box<dyn Future<Output = Option<std::io::Result<(SourceFileVersion, String)>>>>,
-        >,
-    >,
+/// This is i_slint_compiler::OpenImportFallback with version information
+pub type OpenImportFallback = Rc<
+    dyn Fn(
+        String,
+    )
+        -> Pin<Box<dyn Future<Output = Option<std::io::Result<(SourceFileVersion, String)>>>>>,
 >;
 
 pub struct CompilerConfiguration {
     pub include_paths: Vec<std::path::PathBuf>,
     pub library_paths: HashMap<String, std::path::PathBuf>,
     pub style: Option<String>,
-    pub open_import_fallback: OpenImportFallback,
+    pub open_import_fallback: Option<OpenImportFallback>,
     pub resource_url_mapper:
         Option<Rc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = Option<String>>>>>>,
 }
@@ -66,7 +64,7 @@ impl Default for CompilerConfiguration {
 }
 
 impl CompilerConfiguration {
-    fn build(mut self) -> (i_slint_compiler::CompilerConfiguration, OpenImportFallback) {
+    fn build(mut self) -> (i_slint_compiler::CompilerConfiguration, Option<OpenImportFallback>) {
         let mut result = default_cc();
         result.include_paths = std::mem::take(&mut self.include_paths);
         result.library_paths = std::mem::take(&mut self.library_paths);
@@ -80,16 +78,16 @@ impl CompilerConfiguration {
 /// A cache of loaded documents
 pub struct DocumentCache {
     type_loader: TypeLoader,
-    open_import_fallback: OpenImportFallback,
+    open_import_fallback: Option<OpenImportFallback>,
     source_file_versions: Rc<RefCell<SourceFileVersionMap>>,
 }
 
 #[cfg(feature = "preview-engine")]
 pub fn document_cache_parts_setup(
     compiler_config: &mut i_slint_compiler::CompilerConfiguration,
-    open_import_fallback: OpenImportFallback,
+    open_import_fallback: Option<OpenImportFallback>,
     initial_file_versions: SourceFileVersionMap,
-) -> (OpenImportFallback, Rc<RefCell<SourceFileVersionMap>>) {
+) -> (Option<OpenImportFallback>, Rc<RefCell<SourceFileVersionMap>>) {
     let source_file_versions = Rc::new(RefCell::new(initial_file_versions));
     DocumentCache::wire_up_import_fallback(
         compiler_config,
@@ -101,9 +99,9 @@ pub fn document_cache_parts_setup(
 impl DocumentCache {
     fn wire_up_import_fallback(
         compiler_config: &mut i_slint_compiler::CompilerConfiguration,
-        open_import_fallback: OpenImportFallback,
+        open_import_fallback: Option<OpenImportFallback>,
         source_file_versions: Rc<RefCell<SourceFileVersionMap>>,
-    ) -> (OpenImportFallback, Rc<RefCell<SourceFileVersionMap>>) {
+    ) -> (Option<OpenImportFallback>, Rc<RefCell<SourceFileVersionMap>>) {
         let sfv = source_file_versions.clone();
         if let Some(open_import_fallback) = open_import_fallback.clone() {
             compiler_config.open_import_fallback = Some(Rc::new(move |file_name: String| {
@@ -152,7 +150,7 @@ impl DocumentCache {
 
     pub fn new_from_raw_parts(
         mut type_loader: TypeLoader,
-        open_import_fallback: OpenImportFallback,
+        open_import_fallback: Option<OpenImportFallback>,
         source_file_versions: Rc<RefCell<SourceFileVersionMap>>,
     ) -> Self {
         let (open_import_fallback, source_file_versions) = Self::wire_up_import_fallback(

tools/lsp/common/test.rs

@@ -40,7 +40,7 @@ async fn parse_source(
         }));
         #[cfg(target_arch = "wasm32")]
         {
-            tmp.resource_url_mapper = resource_url_mapper();
+            tmp.resource_url_mapper = crate::preview::connector::resource_url_mapper();
         }
         tmp
     };

tools/lsp/preview.rs

@@ -10,7 +10,7 @@
 
 use crate::common::{
     self, component_catalog, rename_component, ComponentInformation, ElementRcNode,
-    PreviewComponent, PreviewConfig, PreviewToLsp, PreviewToLspMessage, SourceFileVersion,
+    PreviewComponent, PreviewConfig, PreviewToLspMessage, SourceFileVersion,
 };
 use crate::preview::element_selection::ElementSelection;
 use crate::util;
@@ -51,7 +51,7 @@ pub fn run(config: &crate::LivePreview) -> std::result::Result<(), slint::Platfo
         ));
     }
 
-    let to_lsp: Rc<dyn PreviewToLsp> = Rc::new(connector::NativePreviewToLsp::new());
+    let to_lsp: Rc<dyn common::PreviewToLsp> = Rc::new(connector::NativePreviewToLsp::new());
 
     let experimental = std::env::var_os("SLINT_ENABLE_EXPERIMENTAL_FEATURES").is_some();
     let ui = ui::create_ui(&to_lsp, &config.style, experimental)?;
@@ -1316,7 +1316,7 @@ async fn parse_source(
 ) -> (
     Vec<diagnostics::Diagnostic>,
     Option<ComponentDefinition>,
-    common::document_cache::OpenImportFallback,
+    Option<common::document_cache::OpenImportFallback>,
     Rc<RefCell<common::document_cache::SourceFileVersionMap>>,
 ) {
     let mut builder = slint_interpreter::Compiler::default();
@@ -1327,10 +1327,7 @@ async fn parse_source(
     } else {
         i_slint_compiler::ComponentSelection::LastExported
     };
-    #[cfg(target_arch = "wasm32")]
-    {
-        cc.resource_url_mapper = connector::resource_url_mapper();
-    }
+    cc.resource_url_mapper = connector::resource_url_mapper();
     cc.embed_resources = EmbedResourcesKind::ListAllResources;
     cc.no_native_menu = true;
     // Otherwise this may cause a runtime panic because of the recursion
@@ -1825,7 +1822,7 @@ fn set_status_text(text: &str) {
 fn update_preview_area(
     compiled: Option<ComponentDefinition>,
     behavior: LoadBehavior,
-    open_import_fallback: common::document_cache::OpenImportFallback,
+    open_import_fallback: Option<common::document_cache::OpenImportFallback>,
     source_file_versions: Rc<RefCell<common::document_cache::SourceFileVersionMap>>,
 ) -> Result<(), PlatformError> {
     PREVIEW_STATE.with_borrow_mut(move |preview_state| {

tools/lsp/preview/connector.rs

@@ -3,11 +3,9 @@
 
 #[cfg(all(target_arch = "wasm32", feature = "preview-external"))]
 mod wasm;
-
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_prelude::*;
 #[cfg(all(target_arch = "wasm32", feature = "preview-external"))]
 pub use wasm::*;
+
 #[cfg(all(not(target_arch = "wasm32"), feature = "preview-builtin"))]
 mod native;
 #[cfg(all(not(target_arch = "wasm32"), feature = "preview-builtin"))]

tools/lsp/preview/connector/native.rs

@@ -8,6 +8,10 @@ use crate::{common, preview};
 use std::cell::RefCell;
 use std::io::{BufRead as _, Write as _};
 
+pub fn resource_url_mapper() -> Option<i_slint_compiler::ResourceUrlMapper> {
+    None
+}
+
 struct NativeLspToPreviewInner {
     communication_handle: std::thread::JoinHandle<std::result::Result<(), String>>,
     to_child: std::process::ChildStdin,

tools/lsp/preview/connector/wasm.rs

@@ -5,13 +5,11 @@
 #![cfg(target_arch = "wasm32")]
 
 use crate::common;
-use crate::preview::{self, ui};
+use crate::preview::{self, connector, ui};
 
 use slint_interpreter::ComponentHandle;
 
 use std::cell::RefCell;
-use std::future::Future;
-use std::pin::Pin;
 use std::rc::Rc;
 
 use wasm_bindgen::prelude::*;
@@ -33,11 +31,14 @@ extern "C" {
     pub type PreviewConnectorPromise;
 }
 
+// We have conceptually two threads: The UI thread and the JS runtime, even though
+// the WASM is strictly single threaded.
+//
+// So we use a thread local variable to transfer data between the two conceptual threads.
 struct WasmCallbacks {
     lsp_notifier: SignalLspFunction,
     resource_url_mapper: ResourceUrlMapperFunction,
 }
-
 thread_local! {static WASM_CALLBACKS: RefCell<Option<WasmCallbacks>> = Default::default();}
 
 #[wasm_bindgen(start)]
@@ -83,14 +84,18 @@ impl PreviewConnector {
             let reject_c = send_wrapper::SendWrapper::new(reject.clone());
             let style = style.clone();
             if let Err(e) = slint_interpreter::invoke_from_event_loop(move || {
+                let to_lsp: Rc<dyn common::PreviewToLsp> = Rc::new(WasmPreviewToLsp::default());
+
                 preview::PREVIEW_STATE.with(move |preview_state| {
                     if preview_state.borrow().ui.is_some() {
                         reject_c.take().call1(&JsValue::UNDEFINED,
                             &JsValue::from("PreviewConnector already set up.")).unwrap_throw();
                     } else {
-                        match ui::create_ui(style, experimental) {
+                        match ui::create_ui(&to_lsp, &style, experimental) {
                             Ok(ui) => {
                                 preview_state.borrow_mut().ui = Some(ui);
+                                *preview_state.borrow().to_lsp.borrow_mut() = Some(to_lsp);
+
                                 resolve.take().call1(&JsValue::UNDEFINED,
                                     &JsValue::from(Self { })).unwrap_throw()
                             }
@@ -127,7 +132,7 @@ impl PreviewConnector {
         let message = serde_wasm_bindgen::from_value(value)
             .map_err(|e| -> JsValue { format!("{e:?}").into() })?;
         i_slint_core::api::invoke_from_event_loop(move || {
-            lsp_to_preview_message(message);
+            connector::lsp_to_preview(message);
         })
         .map_err(|e| -> JsValue { format!("{e:?}").into() })?;
         Ok(())
@@ -190,8 +195,7 @@ fn invoke_from_event_loop_wrapped_in_promise(
     }))
 }
 
-pub fn resource_url_mapper(
-) -> Option<Rc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = Option<String>>>>>> {
+pub fn resource_url_mapper() -> Option<i_slint_compiler::ResourceUrlMapper> {
     let callback = WASM_CALLBACKS.with_borrow(|callbacks| {
         callbacks.as_ref().map(|cb| js_sys::Function::from((cb.resource_url_mapper).clone()))
     })?;
@@ -205,16 +209,36 @@ pub fn resource_url_mapper(
     }))
 }
 
-pub fn send_message_to_lsp(message: common::PreviewToLspMessage) {
-    WASM_CALLBACKS.with_borrow(|callbacks| {
-        if let Some(callbacks) = &callbacks {
-            let notifier = js_sys::Function::from((callbacks.lsp_notifier).clone());
-            let value = serde_wasm_bindgen::to_value(&message).unwrap();
-            let _ = notifier.call1(&JsValue::UNDEFINED, &value);
-        }
-    })
+pub struct WasmLspToPreview {
+    server_notifier: crate::ServerNotifier,
 }
 
-fn lsp_to_preview_message(message: common::LspToPreviewMessage) {
-    super::lsp_to_preview_message_impl(message);
+impl WasmLspToPreview {
+    pub fn new(server_notifier: crate::ServerNotifier) -> Self {
+        Self { server_notifier }
+    }
+}
+
+impl common::LspToPreview for WasmLspToPreview {
+    fn send(&self, message: &common::LspToPreviewMessage) -> common::Result<()> {
+        self.server_notifier.send_notification::<common::LspToPreviewMessage>(message.clone())
+    }
+}
+
+#[derive(Default)]
+struct WasmPreviewToLsp {}
+
+impl common::PreviewToLsp for WasmPreviewToLsp {
+    fn send(&self, message: &common::PreviewToLspMessage) -> common::Result<()> {
+        WASM_CALLBACKS.with_borrow(|callbacks| {
+            let notifier = js_sys::Function::from(
+                (callbacks.as_ref().expect("Callbacks were set up earlier").lsp_notifier).clone(),
+            );
+            let value = serde_wasm_bindgen::to_value(&message)?;
+            notifier
+                .call1(&JsValue::UNDEFINED, &value)
+                .map_err(|_| "Failed to send message to LSP".to_string())?;
+            Ok(())
+        })
+    }
 }

tools/lsp/wasm_main.rs

@@ -11,7 +11,7 @@ mod language;
 mod preview;
 pub mod util;
 
-use common::{DocumentCache, LspToPreviewMessage, Result, VersionedUrl};
+use common::{DocumentCache, LspToPreview, LspToPreviewMessage, Result, VersionedUrl};
 use js_sys::Function;
 pub use language::{Context, RequestHandler};
 use lsp_types::Url;
@@ -77,9 +77,9 @@ impl ServerNotifier {
         })
     }
 
-    pub fn send_message_to_preview(&self, message: LspToPreviewMessage) {
-        let _ = self.send_notification::<LspToPreviewMessage>(message);
-    }
+    // pub fn send_message_to_preview(&self, message: LspToPreviewMessage) {
+    //     let _ = self.send_notification::<LspToPreviewMessage>(message);
+    // }
 }
 
 impl RequestHandler {
@@ -190,20 +190,28 @@ pub fn create(
 
     let mut compiler_config = crate::common::document_cache::CompilerConfiguration::default();
 
-    let server_notifier_ = server_notifier.clone();
+    #[cfg(not(feature = "preview-engine"))]
+    let to_preview: Rc<dyn LspToPreview> = Rc::new(common::DummyLspToPreview::default());
+    #[cfg(feature = "preview-engine")]
+    let to_preview: Rc<dyn LspToPreview> =
+        Rc::new(preview::connector::WasmLspToPreview::new(server_notifier.clone()));
+
+    let to_preview_clone = to_preview.clone();
     compiler_config.open_import_fallback = Some(Rc::new(move |path| {
         let load_file = Function::from(load_file.clone());
-        let server_notifier = server_notifier_.clone();
+        let to_preview = to_preview_clone.clone();
         Box::pin(async move {
             let contents = self::load_file(path.clone(), &load_file).await;
             let Ok(url) = Url::from_file_path(&path) else {
                 return Some(contents.map(|c| (None, c)));
             };
             if let Ok(contents) = &contents {
-                server_notifier.send_message_to_preview(LspToPreviewMessage::SetContents {
-                    url: VersionedUrl::new(url, None),
-                    contents: contents.clone(),
-                })
+                to_preview
+                    .send(&LspToPreviewMessage::SetContents {
+                        url: VersionedUrl::new(url, None),
+                        contents: contents.clone(),
+                    })
+                    .unwrap()
             }
             Some(contents.map(|c| (None, c)))
         })
@@ -222,13 +230,14 @@ pub fn create(
             server_notifier,
             to_show: Default::default(),
             open_urls: Default::default(),
+            to_preview,
         }),
         reentry_guard,
         rh: Rc::new(rh),
     })
 }
 
-fn send_workspace_edit(
+fn forward_workspace_edit(
     server_notifier: ServerNotifier,
     label: Option<String>,
     edit: Result<lsp_types::WorkspaceEdit>,
@@ -294,7 +303,7 @@ impl SlintServer {
                 crate::language::request_state(&self.ctx);
             }
             M::SendWorkspaceEdit { label, edit } => {
-                send_workspace_edit(self.ctx.server_notifier.clone(), label, Ok(edit));
+                forward_workspace_edit(self.ctx.server_notifier.clone(), label, Ok(edit));
             }
             M::SendShowMessage { message } => {
                 let _ = self