Prepare implementing file transfer for remote viewers.

Author: anlumo

api/rs/build/lib.rs

@@ -568,8 +568,12 @@ pub fn compile_with_output_path(
     let syntax_node = syntax_node.expect("diags contained no compilation errors");
 
     // 'spin_on' is ok here because the compiler in single threaded and does not block if there is no blocking future
-    let (doc, diag, loader) =
-        spin_on::spin_on(i_slint_compiler::compile_syntax_node(syntax_node, diag, compiler_config));
+    let (doc, diag, loader) = spin_on::spin_on(i_slint_compiler::compile_syntax_node(
+        syntax_node,
+        diag,
+        compiler_config,
+        (),
+    ));
 
     if diag.has_errors()
         || (!diag.is_empty() && std::env::var("SLINT_COMPILER_DENY_WARNINGS").is_ok())

api/rs/macros/lib.rs

@@ -372,7 +372,7 @@ pub fn slint(stream: TokenStream) -> TokenStream {
     //println!("{syntax_node:#?}");
     compiler_config.translation_domain = std::env::var("CARGO_PKG_NAME").ok();
     let (root_component, diag, loader) =
-        spin_on::spin_on(compile_syntax_node(syntax_node, diag, compiler_config));
+        spin_on::spin_on(compile_syntax_node(syntax_node, diag, compiler_config, ()));
     //println!("{tree:#?}");
     if diag.has_errors() {
         return diag.report_macro_diagnostic(&tokens);

internal/compiler/benches/semantic_analysis.rs

@@ -209,7 +209,7 @@ fn compile_full(source: &str) -> (Document, BuildDiagnostics) {
     let config = CompilerConfiguration::new(i_slint_compiler::generator::OutputFormat::Interpreter);
 
     let (doc, diag, _loader) =
-        spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config));
+        spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config, ()));
     (doc, diag)
 }
 
@@ -363,7 +363,7 @@ mod proc_macro_simulation {
         let config = CompilerConfiguration::new(i_slint_compiler::generator::OutputFormat::Rust);
 
         let (doc, diag, loader) =
-            spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config));
+            spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config, ()));
 
         let rust_code = i_slint_compiler::generator::rust::generate(&doc, &loader.compiler_config)
             .expect("Rust code generation failed");
@@ -427,6 +427,7 @@ mod phase_breakdown {
             node,
             diagnostics,
             config,
+            (),
         )));
     }
 
@@ -438,7 +439,7 @@ mod phase_breakdown {
         let node = parse_source(EMPTY_COMPONENT);
         let config = CompilerConfiguration::new(i_slint_compiler::generator::OutputFormat::Rust);
         let (doc, _diag, loader) =
-            spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config));
+            spin_on::spin_on(i_slint_compiler::compile_syntax_node(node, diagnostics, config, ()));
 
         // Now benchmark just the code generation
         divan::black_box(
@@ -503,6 +504,7 @@ mod phase_breakdown {
             &mut loader,
             false,
             &mut diag,
+            (),
         )));
     }
 

internal/compiler/lib.rs

@@ -297,6 +297,7 @@ pub async fn compile_syntax_node(
     doc_node: parser::SyntaxNode,
     mut diagnostics: diagnostics::BuildDiagnostics,
     #[allow(unused_mut)] mut compiler_config: CompilerConfiguration,
+    resource_preloader: impl crate::passes::ResourcePreloader,
 ) -> (object_tree::Document, diagnostics::BuildDiagnostics, typeloader::TypeLoader) {
     let mut loader = prepare_for_compile(&mut diagnostics, compiler_config);
 
@@ -316,7 +317,8 @@ pub async fn compile_syntax_node(
     );
 
     if !diagnostics.has_errors() {
-        passes::run_passes(&mut doc, &mut loader, false, &mut diagnostics).await;
+        passes::run_passes(&mut doc, &mut loader, false, &mut diagnostics, resource_preloader)
+            .await;
     } else {
         // Don't run all the passes in case of errors because because some invariants are not met.
         passes::run_import_passes(&doc, &loader, &mut diagnostics);
@@ -335,11 +337,13 @@ pub async fn load_root_file(
     source_code: String,
     mut diagnostics: diagnostics::BuildDiagnostics,
     #[allow(unused_mut)] mut compiler_config: CompilerConfiguration,
+    resource_preloader: impl passes::ResourcePreloader,
 ) -> (std::path::PathBuf, diagnostics::BuildDiagnostics, typeloader::TypeLoader) {
     let mut loader = prepare_for_compile(&mut diagnostics, compiler_config);
 
-    let (path, _) =
-        loader.load_root_file(path, source_path, source_code, false, &mut diagnostics).await;
+    let (path, _) = loader
+        .load_root_file(path, source_path, source_code, false, &mut diagnostics, resource_preloader)
+        .await;
 
     (path, diagnostics, loader)
 }
@@ -356,6 +360,7 @@ pub async fn load_root_file_with_raw_type_loader(
     source_code: String,
     mut diagnostics: diagnostics::BuildDiagnostics,
     #[allow(unused_mut)] mut compiler_config: CompilerConfiguration,
+    resource_preloader: impl passes::ResourcePreloader,
 ) -> (
     std::path::PathBuf,
     diagnostics::BuildDiagnostics,
@@ -364,8 +369,9 @@ pub async fn load_root_file_with_raw_type_loader(
 ) {
     let mut loader = prepare_for_compile(&mut diagnostics, compiler_config);
 
-    let (path, raw_type_loader) =
-        loader.load_root_file(path, source_path, source_code, true, &mut diagnostics).await;
+    let (path, raw_type_loader) = loader
+        .load_root_file(path, source_path, source_code, true, &mut diagnostics, resource_preloader)
+        .await;
 
     (path, diagnostics, loader, raw_type_loader)
 }

internal/compiler/passes.rs

@@ -61,6 +61,7 @@ use crate::expression_tree::Expression;
 use smol_str::SmolStr;
 
 pub use binding_analysis::GlobalAnalysis;
+pub use embed_images::ResourcePreloader;
 
 pub fn ignore_debug_hooks(expr: &Expression) -> &Expression {
     let mut expr = expr;
@@ -77,6 +78,7 @@ pub async fn run_passes(
     type_loader: &mut crate::typeloader::TypeLoader,
     keep_raw: bool,
     diag: &mut crate::diagnostics::BuildDiagnostics,
+    resource_preloader: impl ResourcePreloader,
 ) -> Option<crate::typeloader::TypeLoader> {
     let style_metrics = {
         // Ignore import errors
@@ -246,6 +248,7 @@ pub async fn run_passes(
         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/const_propagation.rs

@@ -356,7 +356,7 @@ export component Foo {
         &mut test_diags,
     );
     let (doc, diag, _) =
-        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config));
+        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config, ()));
     assert!(!diag.has_errors(), "slint compile error {:#?}", diag.to_string_vec());
 
     let expected_p = 3.0 * 2.0 + 15.0;
@@ -487,7 +487,7 @@ export component Foo inherits Window {{
             crate::CompilerConfiguration::new(crate::generator::OutputFormat::Interpreter);
         compiler_config.style = Some("fluent".into());
         let (doc, diag, _) =
-            spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config));
+            spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config, ()));
         assert!(!diag.has_errors(), "slint compile error {:#?}", diag.to_string_vec());
 
         let bindings = &doc.inner_components.last().unwrap().root_element.borrow().bindings;
@@ -514,7 +514,7 @@ export component Foo inherits Window {
     compiler_config.style = Some("fluent".into());
     compiler_config.const_scale_factor = Some(2.);
     let (doc, diag, _) =
-        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config));
+        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config, ()));
     assert!(!diag.has_errors(), "slint compile error {:#?}", diag.to_string_vec());
 
     let bindings = &doc.inner_components.last().unwrap().root_element.borrow().bindings;

internal/compiler/passes/default_geometry.rs

@@ -565,7 +565,7 @@ fn test_no_property_for_100pc() {
         &mut test_diags,
     );
     let (doc, diag, _) =
-        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config));
+        spin_on::spin_on(crate::compile_syntax_node(doc_node, test_diags, compiler_config, ()));
     assert!(!diag.has_errors(), "{:?}", diag.to_string_vec());
 
     let root_elem = doc.inner_components.last().unwrap().root_element.borrow();

internal/compiler/passes/embed_images.rs

@@ -14,13 +14,37 @@ use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
 use std::rc::Rc;
+use std::sync::Arc;
 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]>),
+    ) -> 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]>,
+        ),
+    ) -> impl Future<Output = ()> {
+        std::future::ready(())
+    }
+}
+
 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() {
@@ -54,6 +78,20 @@ 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, _| {

internal/compiler/tests/syntax_tests.rs

@@ -447,6 +447,7 @@ fn process_file_source(
             syntax_node.clone(),
             parse_diagnostics,
             compiler_config.clone(),
+            (),
         ));
         build_diags
     } else {
@@ -472,6 +473,7 @@ fn process_file_source(
             syntax_node,
             compile_diagnostics,
             compiler_config,
+            (),
         ));
     }
 

internal/compiler/typeloader.rs

@@ -1468,6 +1468,7 @@ impl TypeLoader {
         source_code: String,
         keep_raw: bool,
         diag: &mut BuildDiagnostics,
+        resource_preloader: impl crate::passes::ResourcePreloader,
     ) -> (PathBuf, Option<TypeLoader>) {
         let path = crate::pathutils::clean_path(path);
         let doc_node: syntax_nodes::Document =
@@ -1480,7 +1481,8 @@ impl TypeLoader {
         let mut state = state.borrow_mut();
         let state = &mut *state;
         let raw_type_loader = if !state.diag.has_errors() {
-            crate::passes::run_passes(&mut doc, state.tl, keep_raw, state.diag).await
+            crate::passes::run_passes(&mut doc, state.tl, keep_raw, state.diag, resource_preloader)
+                .await
         } else {
             None
         };