Implemented a way for remote viewers to request files by path.

Author: anlumo

Cargo.lock

@@ -352,7 +352,7 @@ pub enum LspToPreviewMessage {
 
 // Preview to LSP
 pub enum PreviewToLspMessage {
-    RequestState { unused: bool },
+    RequestState { paths: Vec<String> },
     UpdateElement { ... },
     SendWorkspaceEdit { ... },
     ShowDocument { ... },

docs/development/lsp-architecture.md

@@ -230,7 +230,7 @@ function initPreviewPanel(
                     map_url(panel.webview, message.url);
                     return;
                 case "preview_ready":
-                    send_to_lsp({ RequestState: { unused: true } });
+                    send_to_lsp({ RequestState: {} });
                     return;
                 case "slint/preview_to_lsp":
                     send_to_lsp(message.params);

editors/vscode/src/wasm_preview.ts

@@ -243,12 +243,12 @@ pub async fn run_passes(
         }
     });
 
+    embed_images::preload_images(doc, resource_preloader).await;
     embed_images::embed_images(
         doc,
         type_loader.compiler_config.embed_resources,
         type_loader.compiler_config.const_scale_factor.unwrap_or(1.),
         &type_loader.compiler_config.resource_url_mapper,
-        resource_preloader,
         diag,
     )
     .await;

internal/compiler/passes.rs

@@ -10,7 +10,7 @@ use crate::object_tree::*;
 use image::GenericImageView;
 use smol_str::SmolStr;
 use std::cell::RefCell;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
@@ -20,31 +20,54 @@ use typed_index_collections::TiVec;
 pub trait ResourcePreloader {
     fn load<'a>(
         &self,
-        urls: impl Iterator<Item = &'a str>,
-        push: impl FnMut(/* url */ &'a str, /* extension */ String, /* data */ Arc<[u8]>),
+        paths: impl Iterator<Item = &'a str>,
+        push: Rc<impl Fn(/* path */ &'a str, /* extension */ String, /* data */ Arc<[u8]>)>,
     ) -> impl Future<Output = ()>;
 }
 
 impl ResourcePreloader for () {
     fn load<'a>(
         &self,
-        _urls: impl Iterator<Item = &'a str>,
-        _push: impl FnMut(
-            /* url */ &'a str,
-            /* extension */ String,
-            /* data */ Arc<[u8]>,
-        ),
+        _paths: impl Iterator<Item = &'a str>,
+        _push: Rc<impl Fn(&'a str, String, Arc<[u8]>)>,
     ) -> impl Future<Output = ()> {
         std::future::ready(())
     }
 }
 
+pub async fn preload_images(doc: &Document, resource_preloader: impl ResourcePreloader) {
+    let mut all_components = Vec::new();
+    doc.visit_all_used_components(|c| all_components.push(c.clone()));
+
+    let mut urls = HashSet::<SmolStr>::new();
+    for component in &all_components {
+        visit_all_expressions(component, |e, _| {
+            foreach_image_url_from_expression(e, &mut |path| {
+                urls.insert(path.clone());
+            })
+        });
+    }
+
+    let global_embedded_resources = &doc.embedded_file_resources;
+    resource_preloader
+        .load(
+            urls.iter().map(SmolStr::as_str),
+            Rc::new(|url: &str, extension, data: Arc<[u8]>| {
+                let mut resources = global_embedded_resources.borrow_mut();
+                resources.push(EmbeddedResources {
+                    path: Some(url.into()),
+                    kind: EmbeddedResourcesKind::DataUriPayload(data.to_vec(), extension),
+                });
+            }),
+        )
+        .await;
+}
+
 pub async fn embed_images(
     doc: &Document,
     embed_files: EmbedResourcesKind,
     scale_factor: f32,
     resource_url_mapper: &Option<Rc<dyn Fn(&str) -> Pin<Box<dyn Future<Output = Option<String>>>>>>,
-    resource_preloader: impl ResourcePreloader,
     diag: &mut BuildDiagnostics,
 ) {
     if embed_files == EmbedResourcesKind::Nothing && resource_url_mapper.is_none() {
@@ -53,6 +76,11 @@ pub async fn embed_images(
 
     let global_embedded_resources = &doc.embedded_file_resources;
     let mut path_to_id = HashMap::<SmolStr, EmbeddedResourcesIdx>::new();
+    for (id, resource) in global_embedded_resources.borrow().iter_enumerated() {
+        if let Some(path) = &resource.path {
+            path_to_id.insert(path.clone(), id);
+        }
+    }
 
     let mut all_components = Vec::new();
     doc.visit_all_used_components(|c| all_components.push(c.clone()));
@@ -65,7 +93,9 @@ pub async fn embed_images(
             // Collect URLs (sync!):
             for component in &all_components {
                 visit_all_expressions(component, |e, _| {
-                    collect_image_urls_from_expression(e, &mut urls)
+                    foreach_image_url_from_expression(e, &mut |path| {
+                        urls.insert(path.clone(), None);
+                    })
                 });
             }
 
@@ -78,20 +108,6 @@ pub async fn embed_images(
         urls
     };
 
-    resource_preloader
-        .load(
-            mapped_urls.values().filter_map(|url| url.as_ref().map(SmolStr::as_str)),
-            |url: &str, extension, data| {
-                let mut resources = global_embedded_resources.borrow_mut();
-                let id = resources.push_and_get_key(EmbeddedResources {
-                    path: Some(url.into()),
-                    kind: EmbeddedResourcesKind::DataUriPayload(data.to_vec(), extension),
-                });
-                path_to_id.insert(url.into(), id);
-            },
-        )
-        .await;
-
     // Use URLs (sync!):
     for component in &all_components {
         visit_all_expressions(component, |e, _| {
@@ -108,17 +124,14 @@ pub async fn embed_images(
     }
 }
 
-fn collect_image_urls_from_expression(
-    e: &Expression,
-    urls: &mut HashMap<SmolStr, Option<SmolStr>>,
-) {
+fn foreach_image_url_from_expression(e: &Expression, f: &mut impl FnMut(&SmolStr)) {
     if let Expression::ImageReference { resource_ref, .. } = e
         && let ImageReference::AbsolutePath(path) = resource_ref
     {
-        urls.insert(path.clone(), None);
+        f(path);
     };
 
-    e.visit(|e| collect_image_urls_from_expression(e, urls));
+    e.visit(|e| foreach_image_url_from_expression(e, f));
 }
 
 fn embed_images_from_expression(
@@ -133,6 +146,10 @@ fn embed_images_from_expression(
     if let Expression::ImageReference { resource_ref, source_location, nine_slice: _ } = e
         && let ImageReference::AbsolutePath(path) = resource_ref
     {
+        if path_to_id.contains_key(path) {
+            return;
+        }
+
         if path.starts_with("data:") {
             let image_ref = embed_data_uri(
                 global_embedded_resources,

internal/compiler/passes/embed_images.rs

@@ -18,7 +18,8 @@ fn reuse_window() {
     let handle = {
         let mut compiler = Compiler::default();
         compiler.set_style("fluent".into());
-        let result = spin_on::spin_on(compiler.build_from_source(code.into(), Default::default()));
+        let result =
+            spin_on::spin_on(compiler.build_from_source(code.into(), Default::default(), ()));
         assert!(!result.has_errors(), "{:?}", result.diagnostics().collect::<Vec<_>>());
         let definition = result.component("MainWindow").unwrap();
         let instance = definition.create().unwrap();
@@ -32,7 +33,8 @@ fn reuse_window() {
     let _handle2 = {
         let mut compiler = Compiler::default();
         compiler.set_style("fluent".into());
-        let result = spin_on::spin_on(compiler.build_from_source(code.into(), Default::default()));
+        let result =
+            spin_on::spin_on(compiler.build_from_source(code.into(), Default::default(), ()));
         assert!(!result.has_errors(), "{:?}", result.diagnostics().collect::<Vec<_>>());
         let definition = result.component("MainWindow").unwrap();
         let instance = definition.create_with_existing_window(handle.window()).unwrap();
@@ -68,7 +70,7 @@ export component Clock {
 }
     "#;
     let compiler = Compiler::default();
-    let result = spin_on::spin_on(compiler.build_from_source(code.into(), Default::default()));
+    let result = spin_on::spin_on(compiler.build_from_source(code.into(), Default::default(), ()));
     assert!(!result.has_errors(), "{:?}", result.diagnostics().collect::<Vec<_>>());
     let definition = result.component("Clock").unwrap();
     let instance = definition.create().unwrap();

internal/interpreter/tests.rs

@@ -28,7 +28,10 @@ pub enum PreviewToLspMessage {
     PreviewTypeChanged { target: PreviewTarget },
     /// Request all documents and configuration to be sent from the LSP to the
     /// Preview.
-    RequestState { unused: bool },
+    RequestState {
+        #[serde(default)]
+        files: Vec<Url>,
+    },
     /// Pass a `WorkspaceEdit` on to the editor
     SendWorkspaceEdit { label: Option<String>, edit: lsp_types::WorkspaceEdit },
     /// Pass a `ShowMessage` notification on to the editor

internal/preview-protocol/src/preview_to_lsp.rs

@@ -23,6 +23,7 @@ use i_slint_compiler::parser::{
     NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize, syntax_nodes,
 };
 use i_slint_compiler::{diagnostics::BuildDiagnostics, langtype::Type};
+use i_slint_preview_protocol::PreviewToLspMessage;
 use itertools::Itertools;
 use lsp_types::{
     ClientCapabilities, CodeActionOrCommand, CodeActionProviderCapability, CodeLens,
@@ -173,6 +174,7 @@ pub struct Context {
     /// Files to recompile after all other operations are done
     /// (i.e. recompilations triggered by updates to unopened files)
     pub pending_recompile: HashSet<lsp_types::Url>,
+    pub preview_to_lsp_sender: tokio::sync::mpsc::UnboundedSender<PreviewToLspMessage>,
 }
 
 /// An error from a LSP request
@@ -400,7 +402,7 @@ pub fn register_request_handlers(rh: &mut RequestHandler) {
             }
             POPULATE_COMMAND => {
                 let future = populate_command(&params.arguments, ctx)?;
-                tokio::task::spawn_local(async move {
+                crate::common::spawn_local(async move {
                     if let Err(err) = future.await {
                         tracing::error!("Error executing populate command: {err}");
                     }
@@ -653,22 +655,24 @@ pub fn connect_remote_preview_command(
     });
     let port = params.get(1).and_then(serde_json::Value::as_u64);
 
-    let to_preview = ctx.to_preview.clone();
-
     if let Some(addresses) = addresses {
         if let Some(port) = port {
             use crate::preview::connector::remote::RemoteLspToPreview;
 
-            let _ = to_preview.set_preview_target(i_slint_preview_protocol::PreviewTarget::Remote);
-            to_preview.with_preview_target::<RemoteLspToPreview, Result<Option<serde_json::Value>, LspError>>(
-                move |remote| {
+            let _ =
+                ctx.to_preview.set_preview_target(i_slint_preview_protocol::PreviewTarget::Remote);
+            ctx.to_preview.with_preview_target::<RemoteLspToPreview, Result<Option<serde_json::Value>, LspError>>(
+                |remote| {
+                    let preview_to_lsp_sender = ctx.preview_to_lsp_sender.clone();
                     let future = remote.connect(addresses, port as u16);
-                    tokio::task::spawn_local(async move {
+                    crate::common::spawn_local(async move {
                         if let Err(err) = future.await {
                             LspError {
                                 code: LspErrorCode::RequestFailed,
                                 message: format!("Failed to connect to remote preview: {err}"),
                             };
+                        } else {
+                            let _ = preview_to_lsp_sender.send(PreviewToLspMessage::RequestState { files: Vec::new() });
                         }
                     });
                     Ok(None)
@@ -692,7 +696,7 @@ pub fn disconnect_remote_preview_command(ctx: &Context) {
     let to_preview = ctx.to_preview.clone();
     tracing::debug!("disconnect_remote_preview_command");
     to_preview.with_preview_target::<crate::preview::connector::RemoteLspToPreview, _>(|remote| {
-        tokio::task::spawn_local(remote.disconnect());
+        crate::common::spawn_local(remote.disconnect());
     });
 }
 

tools/lsp/language.rs

@@ -203,6 +203,7 @@ fn test_goto_definition_multi_files() {
             common::DummyLspToPreview::default(),
         )),
         pending_recompile: Default::default(),
+        preview_to_lsp_sender: tokio::sync::mpsc::unbounded_channel().0,
     };
     let (extra_files, diag) = spin_on::spin_on(crate::language::load_document_impl(
         &mut ctx,

tools/lsp/language/goto.rs

@@ -35,6 +35,7 @@ pub fn mock_context() -> Context {
         open_urls: HashSet::new(),
         to_preview: Rc::new(SwitchableLspToPreview::with_one(common::DummyLspToPreview::default())),
         pending_recompile: Default::default(),
+        preview_to_lsp_sender: tokio::sync::mpsc::unbounded_channel().0,
     }
 }
 
@@ -80,6 +81,7 @@ pub fn loaded_document_cache_with_file_name(
             common::DummyLspToPreview::default(),
         )),
         pending_recompile: Default::default(),
+        preview_to_lsp_sender: tokio::sync::mpsc::unbounded_channel().0,
     };
     let (extra_files, diag) =
         spin_on::spin_on(load_document_impl(&mut ctx, content, url.clone(), Some(42)));