Interpreter: Fix setting a struct with less fields than expected (#10120)

It shouldn't leave bad values in the interpreter which later can cause
panic anywhere

Author: ogoffart

internal/interpreter/api.rs

@@ -1418,7 +1418,7 @@ impl ComponentInstance {
             .get_global(comp.borrow(), &&normalize_identifier(global))
             .map_err(|()| SetPropertyError::NoSuchProperty)? // FIXME: should there be a NoSuchGlobal error?
             .as_ref()
-            .set_property(&&normalize_identifier(property), value)
+            .set_property(&normalize_identifier(property), value)
     }
 
     /// Set a handler for the callback in the exported global singleton. A callback with that

internal/interpreter/eval.rs

@@ -1622,7 +1622,7 @@ pub fn store_property(
     component_instance: InstanceRef,
     element: &ElementRc,
     name: &str,
-    value: Value,
+    mut value: Value,
 ) -> Result<(), SetPropertyError> {
     generativity::make_guard!(guard);
     match enclosing_component_instance_for_element(
@@ -1653,7 +1653,7 @@ pub fn store_property(
                         .get(name)
                     {
                         // Do an extra type checking because PropertyInfo::set won't do it for custom structures or array
-                        if !check_value_type(&value, &orig_decl.property_type) {
+                        if !check_value_type(&mut value, &orig_decl.property_type) {
                             return Err(SetPropertyError::WrongType);
                         }
                     }
@@ -1682,7 +1682,7 @@ pub fn store_property(
 }
 
 /// Return true if the Value can be used for a property of the given type
-fn check_value_type(value: &Value, ty: &Type) -> bool {
+fn check_value_type(value: &mut Value, ty: &Type) -> bool {
     match ty {
         Type::Void => true,
         Type::Invalid
@@ -1711,10 +1711,21 @@ fn check_value_type(value: &Value, ty: &Type) -> bool {
         Type::Easing => matches!(value, Value::EasingCurve(_)),
         Type::Brush => matches!(value, Value::Brush(_)),
         Type::Array(inner) => {
-            matches!(value, Value::Model(m) if m.iter().all(|v| check_value_type(&v, inner)))
+            matches!(value, Value::Model(m) if m.iter().all(|mut v| check_value_type(&mut v, inner)))
         }
         Type::Struct(s) => {
-            matches!(value, Value::Struct(str) if str.iter().all(|(k, v)| s.fields.get(k).is_some_and(|ty| check_value_type(v, ty))))
+            let Value::Struct(str) = value else { return false };
+            if !str
+                .0
+                .iter_mut()
+                .all(|(k, v)| s.fields.get(k).is_some_and(|ty| check_value_type(v, ty)))
+            {
+                return false;
+            }
+            for (k, v) in &s.fields {
+                str.0.entry(k.clone()).or_insert_with(|| default_value_for_type(v));
+            }
+            true
         }
         Type::Enumeration(en) => {
             matches!(value, Value::EnumerationValue(name, _) if name == en.name.as_str())

internal/interpreter/tests.rs

@@ -44,3 +44,56 @@ fn reuse_window() {
         instance
     };
 }
+
+#[test]
+fn set_wrong_struct() {
+    i_slint_backend_testing::init_no_event_loop();
+    use crate::{Compiler, Struct, Value};
+    let code = r#"
+struct TimeStruct {
+    Clock:              string,
+    Enabled:            bool,
+}
+
+export global Device {
+    in-out property <TimeStruct> Time: { Clock: "11:37", Enabled: true };
+}
+
+export component Clock {
+    ta := TouchArea {
+        enabled: Device.Time.Enabled;
+    }
+    out property <bool> ta_enabled: ta.enabled;
+    out property <string> time: Device.Time.Clock;
+}
+    "#;
+    let compiler = Compiler::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();
+    assert_eq!(instance.get_property("ta_enabled").unwrap(), Value::from(true));
+    assert_eq!(instance.get_property("time").unwrap(), Value::String("11:37".into()));
+    // This only has "Clock" but no "Enabled"
+    instance
+        .set_global_property(
+            "Device",
+            "Time",
+            Struct::from_iter([("Clock".into(), Value::String("10:37".into()))]).into(),
+        )
+        .unwrap();
+    assert_eq!(instance.get_property("ta_enabled").unwrap(), Value::from(false));
+    assert_eq!(instance.get_property("time").unwrap(), Value::String("10:37".into()));
+
+    // Setting a struct with wrong fields leads to an error
+    assert_eq!(
+        instance.set_global_property(
+            "Device",
+            "Time",
+            Struct::from_iter([("Broken".into(), Value::Number(12.1))]).into(),
+        ),
+        Err(crate::SetPropertyError::WrongType)
+    );
+    assert_eq!(instance.get_property("ta_enabled").unwrap(), Value::from(false));
+    assert_eq!(instance.get_property("time").unwrap(), Value::String("10:37".into()));
+}