Fix wrong value or panic in the interpreter when converting struct of struct

The "tmpobj" variable was overwriten because the interpreter (contrary
to rust and C++) don't have scopes for the local variables, and local
variable of the same name would conflict.
(I think this could in theory be a problem in C++ and rust although i
haven't reproduced it)

Other uses of StoreLocalVariable also make the number unique with a
counter

Fixes #6721

Author: ogoffart

internal/compiler/expression_tree.rs

@@ -8,7 +8,7 @@ use crate::lookup::LookupCtx;
 use crate::object_tree::*;
 use crate::parser::{NodeOrToken, SyntaxNode};
 use core::cell::RefCell;
-use smol_str::SmolStr;
+use smol_str::{format_smolstr, SmolStr};
 use std::cell::Cell;
 use std::collections::HashMap;
 use std::rc::{Rc, Weak};
@@ -1119,13 +1119,18 @@ impl Expression {
                         }
                         return Expression::Struct { values: new_values, ty: target_type };
                     }
-                    let var_name = "tmpobj";
+                    static COUNT: std::sync::atomic::AtomicUsize =
+                        std::sync::atomic::AtomicUsize::new(0);
+                    let var_name = format_smolstr!(
+                        "tmpobj_conv_{}",
+                        COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+                    );
                     let mut new_values = HashMap::new();
                     for (key, ty) in &right.fields {
                         let expression = if left.fields.contains_key(key) {
                             Expression::StructFieldAccess {
                                 base: Box::new(Expression::ReadLocalVariable {
-                                    name: var_name.into(),
+                                    name: var_name.clone(),
                                     ty: from_ty.clone(),
                                 }),
                                 name: key.clone(),
@@ -1137,10 +1142,7 @@ impl Expression {
                         new_values.insert(key.clone(), expression);
                     }
                     return Expression::CodeBlock(vec![
-                        Expression::StoreLocalVariable {
-                            name: var_name.into(),
-                            value: Box::new(self),
-                        },
+                        Expression::StoreLocalVariable { name: var_name, value: Box::new(self) },
                         Expression::Struct { values: new_values, ty: target_type },
                     ]);
                 }

internal/compiler/passes/remove_return.rs

@@ -460,7 +460,11 @@ fn convert_struct(from: Expression, to: Type) -> Expression {
         }
         return Expression::Struct { values: new_values, ty: to };
     }
-    let var_name = "tmpobj";
+    static COUNT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+    let var_name = format_smolstr!(
+        "tmpobj_ret_conv_{}",
+        COUNT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    );
     let from_ty = from.ty();
     let mut new_values = HashMap::new();
     let Type::Struct(from_s) = &from_ty else {
@@ -471,7 +475,7 @@ fn convert_struct(from: Expression, to: Type) -> Expression {
         let expression = if from_s.fields.contains_key(key) {
             Expression::StructFieldAccess {
                 base: Box::new(Expression::ReadLocalVariable {
-                    name: var_name.into(),
+                    name: var_name.clone(),
                     ty: from_ty.clone(),
                 }),
                 name: key.clone(),
@@ -482,7 +486,7 @@ fn convert_struct(from: Expression, to: Type) -> Expression {
         new_values.insert(key.clone(), expression);
     }
     Expression::CodeBlock(vec![
-        Expression::StoreLocalVariable { name: var_name.into(), value: Box::new(from) },
+        Expression::StoreLocalVariable { name: var_name, value: Box::new(from) },
         Expression::Struct { values: new_values, ty: to },
     ])
 }

tests/cases/crashes/issue6721_struct_convert.slint

@@ -0,0 +1,75 @@
+// Copyright © SixtyFPS GmbH <[email protected]>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
+
+
+export struct SA {
+    is-set: bool,
+    zoom-range: float,
+}
+export struct SB {
+    is-set: bool,
+}
+
+export struct Model {
+    fov: SA,
+    tilt-speed: SB,
+}
+
+
+export struct EvenMoreComplex {
+    m1: Model,
+    m2: Model,
+    xx: bool,
+}
+
+export component TestCase inherits Window{
+
+    preferred-width: 600px;
+    preferred-height: 320px;
+
+    in-out property <Model> local: {
+        {
+            fov: {
+                is-set: false,
+            },
+            tilt-speed: {
+                is-set: true,
+            },
+        }
+    };
+
+    in-out property <EvenMoreComplex> p2: {
+        {
+            m1: { fov: { zoom-range: 5 }, tilt-speed: { is-set: true } },
+            m2: { tilt-speed: local.tilt-speed, fov: { is-set: local.fov.is-set } },
+        }
+    }
+
+    init => {
+        debug(p2);
+        local.fov = { is-set: true }
+    }
+    out property <bool> test: p2.m2.fov.is-set && p2.m1.fov.zoom-range == 5 && !p2.m1.fov.is-set;
+}
+
+
+/*
+```cpp
+auto handle = TestCase::create();
+const TestCase &instance = *handle;
+assert(instance.get_test());
+```
+
+```rust
+let instance = TestCase::new().unwrap();
+assert!(instance.get_test());
+```
+
+```js
+var instance = new slint.TestCase({});
+assert(instance.test);
+```
+*/
+
+
+