C++: Fix ABI mismatch with Slice on MSVC AArch64

The second constructor of `Slice` causes the Slice to be passed
differently (in different register) as a return value.

So remove that constructor and use a helper function to
construct a Slice

api/cpp/cbindgen.rs

@@ -410,13 +410,7 @@ fn gen_corelib(
     string_config.export.exclude = vec!["SharedString".into()];
     string_config.export.body.insert(
         "Slice".to_owned(),
-        "    const T &operator[](int i) const { return ptr[i]; }
-        /// Note: this doesn't initialize Slice properly, but we need to keep the struct as compatible with C
-        constexpr Slice() = default;
-        /// Rust uses a NonNull, so even empty slices shouldn't use nullptr
-        constexpr Slice(const T *ptr, uintptr_t len) : ptr(ptr ? const_cast<T*>(ptr) : reinterpret_cast<T*>(sizeof(T))), len(len) {}
-        "
-            .to_owned(),
+        "    const T &operator[](int i) const { return ptr[i]; }".to_owned(),
     );
     cbindgen::Builder::new()
         .with_config(string_config)

api/cpp/include/slint-interpreter.h

@@ -500,10 +500,7 @@ inline Struct::Struct(std::initializer_list<std::pair<std::string_view, Value>>
 inline std::optional<Value> Struct::get_field(std::string_view name) const
 {
     using namespace cbindgen_private;
-    cbindgen_private::Slice<uint8_t> name_view {
-        const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(name.data())),
-        name.size()
-    };
+    cbindgen_private::Slice<uint8_t> name_view = slint::private_api::string_to_slice(name);
     if (cbindgen_private::Value *field_val =
                 cbindgen_private::slint_interpreter_struct_get_field(&inner, name_view)) {
         return Value(std::move(field_val));
@@ -513,10 +510,7 @@ inline std::optional<Value> Struct::get_field(std::string_view name) const
 }
 inline void Struct::set_field(std::string_view name, const Value &value)
 {
-    cbindgen_private::Slice<uint8_t> name_view {
-        const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(name.data())),
-        name.size()
-    };
+    cbindgen_private::Slice<uint8_t> name_view = slint::private_api::string_to_slice(name);
     cbindgen_private::slint_interpreter_struct_set_field(&inner, name_view, value.inner);
 }
 
@@ -661,11 +655,8 @@ public:
     std::optional<Value> invoke(std::string_view name, std::span<const Value> args) const
     {
         using namespace cbindgen_private;
-        Slice<Box<cbindgen_private::Value>> args_view {
-            const_cast<Box<cbindgen_private::Value> *>(
-                    reinterpret_cast<const Box<cbindgen_private::Value> *>(args.data())),
-            args.size()
-        };
+        Slice<Box<cbindgen_private::Value>> args_view = slint::private_api::make_slice(
+                reinterpret_cast<const Box<cbindgen_private::Value> *>(args.data()), args.size());
         if (cbindgen_private::Value *rval_inner = slint_interpreter_component_instance_invoke(
                     inner(), slint::private_api::string_to_slice(name), args_view)) {
             return Value(std::move(rval_inner));
@@ -796,12 +787,11 @@ public:
                                        std::span<const Value> args) const
     {
         using namespace cbindgen_private;
-        Slice<cbindgen_private::Box<cbindgen_private::Value>> args_view {
-            const_cast<cbindgen_private::Box<cbindgen_private::Value> *>(
-                    reinterpret_cast<const cbindgen_private::Box<cbindgen_private::Value> *>(
-                            args.data())),
-            args.size()
-        };
+        Slice<cbindgen_private::Box<cbindgen_private::Value>> args_view =
+                slint::private_api::make_slice(
+                        reinterpret_cast<const cbindgen_private::Box<cbindgen_private::Value> *>(
+                                args.data()),
+                        args.size());
         if (cbindgen_private::Value *rval_inner =
                     slint_interpreter_component_instance_invoke_global(
                             inner(), slint::private_api::string_to_slice(global),

api/cpp/include/slint-testing.h

@@ -95,10 +95,7 @@ public:
     static SharedVector<ElementHandle> find_by_accessible_label(const ComponentHandle<T> &component,
                                                                 std::string_view label)
     {
-        cbindgen_private::Slice<uint8_t> label_view {
-            const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(label.data())),
-            label.size()
-        };
+        cbindgen_private::Slice<uint8_t> label_view = private_api::string_to_slice(label);
         auto vrc = component.into_dyn();
         SharedVector<ElementHandle> result;
         cbindgen_private::slint_testing_element_find_by_accessible_label(
@@ -112,10 +109,7 @@ public:
     static SharedVector<ElementHandle> find_by_element_id(const ComponentHandle<T> &component,
                                                           std::string_view element_id)
     {
-        cbindgen_private::Slice<uint8_t> element_id_view {
-            const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(element_id.data())),
-            element_id.size()
-        };
+        cbindgen_private::Slice<uint8_t> element_id_view = private_api::string_to_slice(element_id);
         auto vrc = component.into_dyn();
         SharedVector<ElementHandle> result;
         cbindgen_private::slint_testing_element_find_by_element_id(
@@ -129,10 +123,8 @@ public:
     static SharedVector<ElementHandle>
     find_by_element_type_name(const ComponentHandle<T> &component, std::string_view type_name)
     {
-        cbindgen_private::Slice<uint8_t> element_type_name_view {
-            const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(type_name.data())),
-            type_name.size()
-        };
+        cbindgen_private::Slice<uint8_t> element_type_name_view =
+                private_api::string_to_slice(type_name);
         auto vrc = component.into_dyn();
         SharedVector<ElementHandle> result;
         cbindgen_private::slint_testing_element_find_by_element_type_name(

api/cpp/include/slint.h

@@ -117,8 +117,8 @@ inline SharedVector<float> solve_box_layout(const cbindgen_private::BoxLayoutDat
                                             cbindgen_private::Slice<int> repeater_indexes)
 {
     SharedVector<float> result;
-    cbindgen_private::Slice<uint32_t> ri { reinterpret_cast<uint32_t *>(repeater_indexes.ptr),
-                                           repeater_indexes.len };
+    cbindgen_private::Slice<uint32_t> ri =
+            make_slice(reinterpret_cast<uint32_t *>(repeater_indexes.ptr), repeater_indexes.len);
     cbindgen_private::slint_solve_box_layout(&data, ri, &result);
     return result;
 }
@@ -233,9 +233,7 @@ inline SharedString translate_from_bundle(std::span<const char8_t *const> strs,
 {
     SharedString result;
     cbindgen_private::slint_translate_from_bundle(
-            cbindgen_private::Slice<const char *>(
-                    const_cast<char const **>(reinterpret_cast<char const *const *>(strs.data())),
-                    strs.size()),
+            make_slice((reinterpret_cast<char const *const *>(strs.data())), strs.size()),
             arguments, &result);
     return result;
 }
@@ -246,16 +244,13 @@ translate_from_bundle_with_plural(std::span<const char8_t *const> strs,
                                   cbindgen_private::Slice<SharedString> arguments, int n)
 {
     SharedString result;
-    cbindgen_private::Slice<const char *> strs_slice(
-            const_cast<char const **>(reinterpret_cast<char const *const *>(strs.data())),
-            strs.size());
-    cbindgen_private::Slice<uint32_t> indices_slice(
-            const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(indices.data())),
-            indices.size());
-    cbindgen_private::Slice<uintptr_t (*)(int32_t)> plural_rules_slice(
-            const_cast<uintptr_t (**)(int32_t)>(
-                    reinterpret_cast<uintptr_t (*const *)(int32_t)>(plural_rules.data())),
-            plural_rules.size());
+    cbindgen_private::Slice<const char *> strs_slice =
+            make_slice(reinterpret_cast<char const *const *>(strs.data()), strs.size());
+    cbindgen_private::Slice<uint32_t> indices_slice =
+            make_slice(reinterpret_cast<const uint32_t *>(indices.data()), indices.size());
+    cbindgen_private::Slice<uintptr_t (*)(int32_t)> plural_rules_slice =
+            make_slice(reinterpret_cast<uintptr_t (*const *)(int32_t)>(plural_rules.data()),
+                       plural_rules.size());
     cbindgen_private::slint_translate_from_bundle_with_plural(
             strs_slice, indices_slice, plural_rules_slice, arguments, n, &result);
     return result;

api/cpp/include/slint_image.h

@@ -284,12 +284,7 @@ inline Image load_image_from_embedded_data(std::span<const uint8_t> data,
 {
     cbindgen_private::types::Image img(cbindgen_private::types::Image::ImageInner_None());
     cbindgen_private::types::slint_image_load_from_embedded_data(
-            slint::cbindgen_private::Slice<uint8_t> { const_cast<uint8_t *>(data.data()),
-                                                      data.size() },
-            slint::cbindgen_private::Slice<uint8_t> {
-                    const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(extension.data())),
-                    extension.size() },
-            &img);
+            make_slice(data.data(), data.size()), string_to_slice(extension), &img);
     return Image(img);
 }
 

api/cpp/include/slint_string.h

@@ -3,6 +3,7 @@
 
 #pragma once
 #include <string_view>
+#include <span>
 #include "slint_string_internal.h"
 
 namespace slint {
@@ -223,11 +224,26 @@ private:
 };
 
 namespace private_api {
+
+template<typename T>
+inline cbindgen_private::Slice<T> make_slice(const T *ptr, size_t len)
+{
+    return cbindgen_private::Slice<T> {
+        // Rust uses a NonNull, so even empty slices shouldn't use nullptr
+        .ptr = ptr ? const_cast<T *>(ptr) : reinterpret_cast<T *>(sizeof(T)),
+        .len = len,
+    };
+}
+
+template<typename T, size_t Extent>
+inline cbindgen_private::Slice<std::remove_const_t<T>> make_slice(std::span<T, Extent> span)
+{
+    return make_slice(span.data(), span.size());
+}
+
 inline cbindgen_private::Slice<uint8_t> string_to_slice(std::string_view str)
 {
-    return cbindgen_private::Slice<uint8_t> {
-        const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(str.data())), str.size()
-    };
+    return make_slice(reinterpret_cast<const uint8_t *>(str.data()), str.size());
 }
 }
 

api/cpp/include/slint_window.h

@@ -216,8 +216,7 @@ public:
     inline std::optional<SharedString> register_font_from_data(const uint8_t *data, std::size_t len)
     {
         SharedString maybe_err;
-        cbindgen_private::slint_register_font_from_data(
-                &inner, { const_cast<uint8_t *>(data), len }, &maybe_err);
+        cbindgen_private::slint_register_font_from_data(&inner, make_slice(data, len), &maybe_err);
         if (!maybe_err.empty()) {
             return maybe_err;
         } else {

internal/compiler/generator/cpp.rs

@@ -991,12 +991,14 @@ fn embed_resource(
                 )),
                 ..Default::default()
             }));
-            let init = format!("slint::cbindgen_private::types::StaticTextures {{
+            let init = format!(
+                "slint::cbindgen_private::types::StaticTextures {{
                         .size = {{ {width}, {height} }},
                         .original_size = {{ {unscaled_width}, {unscaled_height} }},
-                        .data = slint::cbindgen_private::Slice<uint8_t>{{  {data_name} , {count} }},
-                        .textures = slint::cbindgen_private::Slice<slint::cbindgen_private::types::StaticTexture>{{ &{texture_name}, 1 }}
-                    }}");
+                        .data = slint::private_api::make_slice({data_name} , {count} ),
+                        .textures = slint::private_api::make_slice(&{texture_name}, 1)
+                    }}"
+            );
             declarations.push(Declaration::Var(Var {
                 ty: "const slint::cbindgen_private::types::StaticTextures".into(),
                 name: format_smolstr!("slint_embedded_resource_{}", resource.id),
@@ -1078,7 +1080,7 @@ fn embed_resource(
                     name: format_smolstr!("slint_embedded_resource_{}_glyphset_{}", resource.id, glyphset_index),
                     array_size: Some(glyphset.glyph_data.len()),
                     init: Some(format!("{{ {} }}", glyphset.glyph_data.iter().enumerate().map(|(glyph_index, glyph)| {
-                        format!("{{ .x = {}, .y = {}, .width = {}, .height = {}, .x_advance = {}, .data = slint::cbindgen_private::Slice<uint8_t>{{ {}, {} }} }}",
+                        format!("{{ .x = {}, .y = {}, .width = {}, .height = {}, .x_advance = {}, .data = slint::private_api::make_slice({}, {}) }}",
                         glyph.x, glyph.y, glyph.width, glyph.height, glyph.x_advance,
                         format!("slint_embedded_resource_{}_gs_{}_gd_{}", resource.id, glyphset_index, glyph_index),
                         glyph.data.len()
@@ -1101,10 +1103,7 @@ fn embed_resource(
                         .iter()
                         .enumerate()
                         .map(|(glyphset_index, glyphset)| format!(
-                            "{{ .pixel_size = {}, .glyph_data = slint::cbindgen_private::Slice<slint::cbindgen_private::BitmapGlyph>{{
-                                    {}, {}
-                                }}
-                                 }}",
+                            "{{ .pixel_size = {}, .glyph_data = slint::private_api::make_slice({}, {}) }}",
                             glyphset.pixel_size, format!("slint_embedded_resource_{}_glyphset_{}", resource.id, glyphset_index), glyphset.glyph_data.len()
                         ))
                         .join(", \n")
@@ -1114,14 +1113,14 @@ fn embed_resource(
 
             let init = format!(
                 "slint::cbindgen_private::BitmapFont {{
-                        .family_name = slint::cbindgen_private::Slice<uint8_t>{{ {family_name_var} , {family_name_size} }},
-                        .character_map = slint::cbindgen_private::Slice<slint::cbindgen_private::CharacterMapEntry>{{ {charmap_var}, {charmap_size} }},
+                        .family_name = slint::private_api::make_slice({family_name_var} , {family_name_size}),
+                        .character_map = slint::private_api::make_slice({charmap_var}, {charmap_size}),
                         .units_per_em = {units_per_em},
                         .ascent = {ascent},
                         .descent = {descent},
                         .x_height = {x_height},
                         .cap_height = {cap_height},
-                        .glyphs = slint::cbindgen_private::Slice<slint::cbindgen_private::BitmapGlyphs>{{ {glyphsets_var}, {glyphsets_size} }},
+                        .glyphs = slint::private_api::make_slice({glyphsets_var}, {glyphsets_size}),
                         .weight = {weight},
                         .italic = {italic},
                         .sdf = {sdf},
@@ -1584,13 +1583,13 @@ fn generate_item_tree(
         Access::Private,
         Declaration::Function(Function {
             name: "item_tree".into(),
-            signature: "() -> slint::cbindgen_private::Slice<slint::private_api::ItemTreeNode>".into(),
+            signature: "() -> slint::cbindgen_private::Slice<slint::private_api::ItemTreeNode>"
+                .into(),
             is_static: true,
             statements: Some(vec![
                 "static const slint::private_api::ItemTreeNode children[] {".to_owned(),
                 format!("    {} }};", item_tree_array.join(", \n")),
-                "return { const_cast<slint::private_api::ItemTreeNode*>(children), std::size(children) };"
-                    .to_owned(),
+                "return slint::private_api::make_slice(std::span(children));".to_owned(),
             ]),
             ..Default::default()
         }),
@@ -1605,8 +1604,7 @@ fn generate_item_tree(
             statements: Some(vec![
                 "static const slint::private_api::ItemArrayEntry items[] {".to_owned(),
                 format!("    {} }};", item_array.join(", \n")),
-                "return { const_cast<slint::private_api::ItemArrayEntry*>(items), std::size(items) };"
-                    .to_owned(),
+                "return slint::private_api::make_slice(std::span(items));".to_owned(),
             ]),
             ..Default::default()
         }),
@@ -1803,7 +1801,7 @@ fn generate_item_tree(
                     .map(|l| format!("slint::private_api::string_to_slice({l:?})"))
                     .join(", ")
             ));
-            create_code.push(format!("slint::cbindgen_private::slint_translate_set_bundled_languages({{ languages.data(), {lang_len} }});"));
+            create_code.push(format!("slint::cbindgen_private::slint_translate_set_bundled_languages(slint::private_api::make_slice(std::span(languages)));"));
         }
 
         create_code.push("self->globals = &self->m_globals;".into());
@@ -3397,7 +3395,7 @@ fn compile_expression(expr: &llr::Expression, ctx: &EvaluationContext) -> String
                 )
             } else {
                 format!(
-                    "slint::cbindgen_private::Slice<{ty}>{{ std::array<{ty}, {count}>{{ {val} }}.data(), {count} }}",
+                    "slint::private_api::make_slice<{ty}>(std::array<{ty}, {count}>{{ {val} }}.data(), {count})",
                     count = values.len(),
                     ty = ty,
                     val = val.join(", ")
@@ -3511,7 +3509,7 @@ fn compile_expression(expr: &llr::Expression, ctx: &EvaluationContext) -> String
             };
             format!("slint::cbindgen_private::GridLayoutCellData {cv}_array [] = {{ {c} }};\
                     slint::cbindgen_private::slint_reorder_dialog_button_layout({cv}_array, {r});\
-                    slint::cbindgen_private::Slice<slint::cbindgen_private::GridLayoutCellData> {cv} {{ std::data({cv}_array), std::size({cv}_array) }}",
+                    slint::cbindgen_private::Slice<slint::cbindgen_private::GridLayoutCellData> {cv} = slint::private_api::make_slice(std::span({cv}_array))",
                     r = compile_expression(roles, ctx),
                     cv = cells_variable,
                     c = cells.join(", "),
@@ -4099,13 +4097,13 @@ fn box_layout_function(
     let ri = repeated_indices.as_ref().map_or(String::new(), |ri| {
         write!(
             push_code,
-            "slint::cbindgen_private::Slice<int> {ri}{{ {ri}_array.data(), {ri}_array.size() }};"
+            "slint::cbindgen_private::Slice<int> {ri} = slint::private_api::make_slice(std::span({ri}_array));"
         )
         .unwrap();
         format!("std::array<int, {}> {}_array;", 2 * repeater_idx, ri)
     });
     format!(
-        "[&]{{ {} {} slint::cbindgen_private::Slice<slint::cbindgen_private::BoxLayoutCellData>{}{{cells_vector.data(), cells_vector.size()}}; return {}; }}()",
+        "[&]{{ {} {} slint::cbindgen_private::Slice<slint::cbindgen_private::BoxLayoutCellData>{} = slint::private_api::make_slice(std::span(cells_vector)); return {}; }}()",
         ri,
         push_code,
         ident(cells_variable),