LLR: don't use LocalMemberReference to initialize property binding

Because they could be aliases to global

Author: ogoffart

internal/compiler/generator/cpp.rs

@@ -597,13 +597,13 @@ fn property_set_value_code(
 }
 
 fn handle_property_init(
-    prop: &llr::LocalMemberReference,
+    prop: &llr::MemberReference,
     binding_expression: &llr::BindingExpression,
     init: &mut Vec<String>,
     ctx: &EvaluationContext,
 ) {
-    let prop_access = access_local_member(prop, ctx);
-    let prop_type = ctx.relative_property_ty(prop, 0);
+    let prop_access = access_member(prop, ctx).unwrap();
+    let prop_type = ctx.property_ty(prop);
     if let Type::Callback(callback) = &prop_type {
         let mut ctx2 = ctx.clone();
         ctx2.argument_types = &callback.args;
@@ -2086,8 +2086,8 @@ fn generate_sub_component(
 
     for (prop1, prop2, fields) in &component.two_way_bindings {
         if fields.is_empty() {
-            let ty = ctx.relative_property_ty(&prop1, 0).cpp_type().unwrap();
-            let p1 = access_local_member(prop1, &ctx);
+            let ty = ctx.property_ty(&prop1).cpp_type().unwrap();
+            let p1 = access_member(prop1, &ctx).unwrap();
             init.push(
                 access_member(prop2, &ctx).then(|p2| {
                     format!("slint::private_api::Property<{ty}>::link_two_way(&{p1}, &{p2})",)
@@ -2105,7 +2105,7 @@ fn generate_sub_component(
                 ty = s.fields.get(f).unwrap();
             }
 
-            let p1 = access_local_member(prop1, &ctx);
+            let p1 = access_member(prop1, &ctx).unwrap();
             init.push(
                 access_member(prop2, &ctx).then(|p2|
                     format!("slint::private_api::Property<{cpp_ty}>::link_two_way_with_map(&{p2}, &{p1}, [](const auto &x){{ return {access}; }}, [](auto &x, const auto &v){{ {access} = v; }})")
@@ -2121,7 +2121,7 @@ fn generate_sub_component(
         }
     }
     for prop in &component.const_properties {
-        if component.prop_used(prop, root) {
+        if component.prop_used(&prop.clone().into(), root) {
             let p = access_local_member(prop, &ctx);
             properties_init_code.push(format!("{p}.set_constant();"));
         }
@@ -2659,10 +2659,7 @@ fn generate_global(
 
         if let Some(expression) = expression.as_ref() {
             handle_property_init(
-                &llr::LocalMemberReference {
-                    sub_component_path: vec![],
-                    reference: property_index.into(),
-                },
+                &llr::LocalMemberReference::from(property_index).into(),
                 expression,
                 &mut init,
                 &ctx,

internal/compiler/generator/rust.rs

@@ -577,13 +577,13 @@ fn generate_enum(en: &std::rc::Rc<Enumeration>) -> TokenStream {
 }
 
 fn handle_property_init(
-    prop: &llr::LocalMemberReference,
+    prop: &llr::MemberReference,
     binding_expression: &llr::BindingExpression,
     init: &mut Vec<TokenStream>,
     ctx: &EvaluationContext,
 ) {
-    let rust_property = access_local_member(prop, ctx);
-    let prop_type = ctx.relative_property_ty(prop, 0);
+    let rust_property = access_member(prop, ctx).unwrap();
+    let prop_type = ctx.property_ty(prop);
 
     let init_self_pin_ref = if ctx.current_global().is_some() {
         quote!(let _self = self_rc.as_ref();)
@@ -1125,7 +1125,7 @@ fn generate_sub_component(
         component.popup_windows.iter().enumerate().map(|(i, _)| internal_popup_id(i));
 
     for (prop1, prop2, fields) in &component.two_way_bindings {
-        let p1 = access_local_member(prop1, &ctx);
+        let p1 = access_member(prop1, &ctx).unwrap();
         let p2 = access_member(prop2, &ctx);
         let r = p2.then(|p2| {
             if fields.is_empty() {
@@ -1151,7 +1151,7 @@ fn generate_sub_component(
         }
     }
     for prop in &component.const_properties {
-        if component.prop_used(prop, root) {
+        if component.prop_used(&prop.clone().into(), root) {
             let rust_property = access_local_member(prop, &ctx);
             init.push(quote!(#rust_property.set_constant();))
         }
@@ -1487,7 +1487,12 @@ fn generate_global(
             continue;
         }
         if let Some(expression) = expression.as_ref() {
-            handle_property_init(&property_index.into(), expression, &mut init, &ctx)
+            handle_property_init(
+                &llr::LocalMemberReference::from(property_index).into(),
+                expression,
+                &mut init,
+                &ctx,
+            )
         }
     }
     for (property_index, cst) in global.const_properties.iter_enumerated() {

internal/compiler/llr/expression.rs

@@ -567,7 +567,7 @@ impl<'a, T> EvaluationContext<'a, T> {
             };
 
             let animation = sc.animations.get(prop).map(|a| (a, map.clone()));
-            let analysis = sc.prop_analysis.get(prop);
+            let analysis = sc.prop_analysis.get(&prop.clone().into());
             if let Some(a) = &analysis {
                 if let Some(init) = a.property_init {
                     return PropertyInfoResult {

internal/compiler/llr/item_tree.rs

@@ -327,12 +327,12 @@ pub struct SubComponent {
     pub sub_components: TiVec<SubComponentInstanceIdx, SubComponentInstance>,
     /// The initial value or binding for properties.
     /// This is ordered in the order they must be set.
-    pub property_init: Vec<(LocalMemberReference, BindingExpression)>,
-    pub change_callbacks: Vec<(LocalMemberReference, MutExpression)>,
+    pub property_init: Vec<(MemberReference, BindingExpression)>,
+    pub change_callbacks: Vec<(MemberReference, MutExpression)>,
     /// The animation for properties which are animated
     pub animations: HashMap<LocalMemberReference, Expression>,
     /// The two way bindings that map the first property to the second wih optional field access
-    pub two_way_bindings: Vec<(LocalMemberReference, MemberReference, Vec<SmolStr>)>,
+    pub two_way_bindings: Vec<(MemberReference, MemberReference, Vec<SmolStr>)>,
     pub const_properties: Vec<LocalMemberReference>,
     /// Code that is run in the sub component constructor, after property initializations
     pub init_code: Vec<MutExpression>,
@@ -349,7 +349,7 @@ pub struct SubComponent {
     /// Maps item index to a list of encoded element infos of the element  (type name, qualified ids).
     pub element_infos: BTreeMap<u32, String>,
 
-    pub prop_analysis: HashMap<LocalMemberReference, PropAnalysis>,
+    pub prop_analysis: HashMap<MemberReference, PropAnalysis>,
 }
 
 #[derive(Debug)]
@@ -401,10 +401,16 @@ impl SubComponent {
     }
 
     /// Return if a local property is used. (unused property shouldn't be generated)
-    pub fn prop_used(&self, prop: &LocalMemberReference, cu: &CompilationUnit) -> bool {
-        if let LocalMemberIndex::Property(property_index) = &prop.reference {
+    pub fn prop_used(&self, prop: &MemberReference, cu: &CompilationUnit) -> bool {
+        let MemberReference::Relative { parent_level, local_reference } = prop else {
+            return true;
+        };
+        if *parent_level != 0 {
+            return true;
+        }
+        if let LocalMemberIndex::Property(property_index) = &local_reference.reference {
             let mut sc = self;
-            for i in &prop.sub_component_path {
+            for i in &local_reference.sub_component_path {
                 sc = &cu.sub_components[sc.sub_components[*i].ty];
             }
             if sc.properties[*property_index].use_count.get() == 0 {

internal/compiler/llr/lower_to_item_tree.rs

@@ -390,11 +390,17 @@ fn lower_sub_component(
 
     crate::generator::handle_property_bindings_init(component, |e, p, binding| {
         let nr = NamedReference::new(e, p.clone());
-        let prop = ctx.map_property_reference(&nr).local();
+        let prop = ctx.map_property_reference(&nr);
 
         if let Type::Function { .. } = nr.ty() {
-            assert!(prop.sub_component_path.is_empty());
-            let LocalMemberIndex::Function(function_index) = prop.reference else { unreachable!() };
+            let MemberReference::Relative { parent_level, local_reference } = prop else {
+                unreachable!()
+            };
+            assert!(parent_level == 0);
+            assert!(local_reference.sub_component_path.is_empty());
+            let LocalMemberIndex::Function(function_index) = local_reference.reference else {
+                unreachable!()
+            };
 
             sub_component.functions[function_index].code =
                 super::lower_expression::lower_expression(&binding.expression, &mut ctx);
@@ -454,7 +460,7 @@ fn lower_sub_component(
             if let Some(anim) = binding.animation.as_ref() {
                 match super::lower_expression::lower_animation(anim, &mut ctx) {
                     Animation::Static(anim) => {
-                        sub_component.animations.insert(prop, anim);
+                        sub_component.animations.insert(prop.local(), anim);
                     }
                     Animation::Transition(_) => {
                         // Cannot set a property with a transition anyway
@@ -499,13 +505,12 @@ fn lower_sub_component(
 
     crate::generator::for_each_const_properties(component, |elem, n| {
         let x = ctx.map_property_reference(&NamedReference::new(elem, n.clone()));
-        let x = x.local();
         // ensure that all const properties have analysis
         sub_component.prop_analysis.entry(x.clone()).or_insert_with(|| PropAnalysis {
             property_init: None,
             analysis: get_property_analysis(elem, n),
         });
-        sub_component.const_properties.push(x);
+        sub_component.const_properties.push(x.local());
     });
 
     sub_component.init_code = component
@@ -569,7 +574,7 @@ fn lower_sub_component(
                 &tree_Expression::CodeBlock(exprs),
                 &mut ctx,
             );
-            (prop.local(), expr.into())
+            (prop, expr.into())
         })
         .collect();
 

internal/compiler/llr/pretty_print.rs

@@ -65,7 +65,7 @@ impl PrettyPrinter<'_> {
             writeln!(
                 self.writer,
                 "{} <=> {}{}{};",
-                DisplayLocalRef(p1, &ctx),
+                DisplayPropertyRef(p1, &ctx),
                 DisplayPropertyRef(p2, &ctx),
                 if fields.is_empty() { "" } else { "." },
                 fields.join(".")
@@ -76,7 +76,7 @@ impl PrettyPrinter<'_> {
             writeln!(
                 self.writer,
                 "{}: {};{}",
-                DisplayLocalRef(p, &ctx),
+                DisplayPropertyRef(p, &ctx),
                 DisplayExpression(&init.expression.borrow(), &ctx),
                 if init.is_constant { " /*const*/" } else { "" }
             )?
@@ -86,7 +86,7 @@ impl PrettyPrinter<'_> {
             writeln!(
                 self.writer,
                 "changed {} => {};",
-                DisplayLocalRef(p, &ctx),
+                DisplayPropertyRef(p, &ctx),
                 DisplayExpression(&e.borrow(), &ctx),
             )?
         }

tests/cases/bindings/two_way_global.slint

@@ -1,19 +1,37 @@
 // Copyright © SixtyFPS GmbH <info@slint.dev>
 // SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
 
+// See FIXME in the js test
+//ignore: live-preview
+
 export global G1 {
     in-out property <int> data: 42;
+    in-out property <string> string-prop;
 }
 
 export global G2 {
     in-out property <int> data <=> G1.data;
 }
 
-export component TestCase inherits Window {
+component SubComponent {
+    in-out property <string> str <=> G1.string-prop;
+}
 
+export component TestCase inherits Window {
     out property <int> d1: G1.data;
     out property <int> d2: G2.data;
-    out property <bool> test: G2.data == 42;
+    sc1 := SubComponent {
+        str: "sc1";
+    }
+    sc2 := SubComponent {
+        str: "sc2";
+    }
+
+    in-out property <string> string-prop-alias <=> sc1.str;
+    out property <int> string-prop-alias-changed: 0;
+    changed string-prop-alias => { string-prop-alias-changed+=1;  }
+
+    out property <bool> test: G2.data == 42 && sc1.str == sc2.str;
 }
 
 
@@ -37,6 +55,13 @@ assert_eq!(G2::get(&instance).get_data(), -1);
 assert_eq!(instance.get_d1(), -1);
 assert_eq!(instance.get_d2(), -1);
 
+let string_prop = instance.global::<G1<'_>>().get_string_prop();
+assert!(string_prop == "sc1" || string_prop == "sc2");
+instance.set_string_prop_alias("xxx".into());
+let string_prop = instance.global::<G1<'_>>().get_string_prop();
+assert_eq!(string_prop, "xxx");
+slint_testing::mock_elapsed_time(1);
+assert_eq!(instance.get_string_prop_alias_changed(), 1);
 ```
 
 ```cpp
@@ -57,6 +82,14 @@ assert_eq(instance.global<G1>().get_data(), -1);
 assert_eq(instance.global<G2>().get_data(), -1);
 assert_eq(instance.get_d1(), -1);
 assert_eq(instance.get_d2(), -1);
+
+auto string_prop = instance.global<G1>().get_string_prop();
+assert(string_prop == "sc1" || string_prop == "sc2");
+instance.set_string_prop_alias("xxx");
+string_prop = instance.global<G1>().get_string_prop();
+assert_eq(string_prop, "xxx");
+slint_testing::mock_elapsed_time(1);
+assert_eq(instance.get_string_prop_alias_changed(), 1);
 ```
 
 ```js
@@ -76,6 +109,17 @@ assert.equal(instance.G1.data, -1);
 assert.equal(instance.G2.data, -1);
 assert.equal(instance.d1, -1);
 assert.equal(instance.d2, -1);
+
+// FIXME!  This is not working with the interpreter
+/*
+let string_prop = instance.G1.string_prop;
+assert(string_prop == "sc1" || string_prop == "sc2");
+instance.G1.string_prop = "xxx";
+string_prop = instance.G1.string_prop;
+assert.equal(string_prop, "xxx");
+slintlib.private_api.mock_elapsed_time(1);
+assert.equal(instance.string_prop_alias_changed, 1);
+*/
 ```
 
 */