🐛 xmlgen: avoid generating duplicate receive_*_changed methods

When given an interface definition with a property named `Foo` and a
signal named `FooChanged`, `zbus_xmlgen` would generate duplicate
`receive_foo_changed` methods, causing compilation errors.

In practice, the colliding `*Changed` signal is used to override the
behavior of the property's implicit change signal, so it's preferable to
use the overridden one and leave off the implicit rather than keeping it
as a compilation error.

Resolves `Case 2` of #231

Author: antonok-edm

zbus_xmlgen/src/lib.rs

@@ -1,5 +1,6 @@
 use snakecase::ascii::to_snakecase;
 use std::{
+    collections::HashMap,
     error::Error,
     fmt::{Display, Formatter, Write},
     process::{Command, Stdio},
@@ -185,6 +186,19 @@ impl GenTrait<'_> {
 
         let mut signals = iface.signals().to_vec();
         signals.sort_by(|a, b| a.name().partial_cmp(&b.name()).unwrap());
+
+        // collect signal method names for collision detection with implicit property change
+        // receivers
+        let signal_method_names: HashMap<String, String> = signals
+            .iter()
+            .map(|s| {
+                (
+                    to_identifier(&to_snakecase(s.name().as_str())),
+                    s.name().as_str().to_owned(),
+                )
+            })
+            .collect();
+
         for signal in &signals {
             let args = parse_signal_args(signal.args());
             let name = to_identifier(&to_snakecase(signal.name().as_str()));
@@ -202,14 +216,30 @@ impl GenTrait<'_> {
         props.sort_by(|a, b| a.name().partial_cmp(&b.name()).unwrap());
         for p in props {
             let name = to_identifier(&to_snakecase(p.name().as_str()));
-            let fn_attribute = if pascal_case(&name) != p.name().as_str() {
-                format!("    #[zbus(property, name = \"{}\")]", p.name())
+
+            let prop_change_receiver_name = format!("{name}_changed");
+            let signal_collision = signal_method_names.get(&prop_change_receiver_name);
+
+            let property_args = if signal_collision.is_some() {
+                "(emits_changed_signal = \"false\")"
+            } else {
+                ""
+            };
+            let name_arg = if pascal_case(&name) != p.name().as_str() {
+                format!(", name = \"{}\"", p.name())
             } else {
-                "    #[zbus(property)]".to_string()
+                "".to_string()
             };
+            let fn_attribute = format!("    #[zbus(property{property_args}{name_arg})]");
 
             writeln!(w)?;
             writeln!(w, "    /// {} property", p.name())?;
+            if let Some(signal_collision) = signal_collision {
+                writeln!(
+                    w,
+                    "    // Note: change signal is shadowed by imported `{signal_collision}` signal"
+                )?;
+            }
             if p.access().read() {
                 writeln!(w, "{fn_attribute}")?;
                 let output = to_rust_type(p.ty(), false, false);

zbus_xmlgen/tests/data/sample_object0.rs

@@ -68,6 +68,10 @@ pub trait SampleInterface0 {
     #[zbus(signal)]
     fn signal_value(&self, value: zbus::zvariant::Value<'_>) -> zbus::Result<()>;
 
+    /// StateChanged signal
+    #[zbus(signal)]
+    fn state_changed(&self, state: u32, something_else: u32) -> zbus::Result<()>;
+
     /// Bar property
     #[zbus(property)]
     fn bar(&self) -> zbus::Result<u8>;
@@ -94,4 +98,9 @@ pub trait SampleInterface0 {
             std::collections::HashMap<String, zbus::zvariant::OwnedValue>,
         )>,
     >;
+
+    /// State property
+    // Note: change signal is shadowed by imported `StateChanged` signal
+    #[zbus(property(emits_changed_signal = "false"))]
+    fn state(&self) -> zbus::Result<u32>;
 }

zbus_xmlgen/tests/data/sample_object0.xml

@@ -52,6 +52,12 @@
      <signal name="SignalDictStringToValue">
        <arg type="a{sv}" name="dict"/>
      </signal>
+     <!-- Signal `StateChanged` should override `State`'s implicit `receive_state_changed` method -->
+     <signal name="StateChanged">
+       <arg name="state" type="u"/>
+       <arg name="something_else" type="u"/>
+     </signal>
+     <property name="State" type="u" access="read"/>
      <property name="Bar" type="y" access="readwrite"/>
      <property name="Foo-Bar" type="y" access="readwrite"/>
      <property name="Matryoshkas" type="a(oiasta{sv})" access="read"/>