fix: merge property descriptors when getter and setter come from different interfaces (#23939) (#23942)

BeanUtil's dedup loop was replacing a read-only descriptor with a
write-only one (or vice versa) instead of merging them. This caused
BeanPropertySet to lose the getter when a parent interface provided it
and a child interface provided the setter.

Fixes #20814

Co-authored-by: Artur Signell <artur@vaadin.com>

Author: vaadin-bot

flow-data/src/test/java/com/vaadin/flow/data/binder/BeanPropertySetTest.java

@@ -27,6 +27,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -467,6 +468,72 @@ public void setFirstName(String firstName) {
         }
     }
 
+    public interface Measurement {
+        double getValue();
+    }
+
+    public interface MutableMeasurement extends Measurement {
+        void setValue(double value);
+    }
+
+    @Test
+    public void propertyWithGetterAndSetterFromSeparateInterfaces() {
+        // When getter is in a parent interface and setter in a sub-interface,
+        // the property should be discovered with both accessors.
+        // This tests the interface type directly, as used e.g. in
+        // Grid<MutableMeasurement>.
+        PropertySet<MutableMeasurement> set = BeanPropertySet
+                .get(MutableMeasurement.class);
+
+        Assert.assertTrue(
+                "Property 'value' should be discovered when getter is in "
+                        + "a parent interface and setter in a sub-interface",
+                set.getProperty("value").isPresent());
+        PropertyDefinition<MutableMeasurement, ?> def = set.getProperty("value")
+                .get();
+        Assert.assertNotNull(def.getGetter());
+        Assert.assertTrue(def.getSetter().isPresent());
+    }
+
+    // Reproducer from https://github.com/vaadin/flow/issues/20814
+    interface BaseInfo {
+        String getInfo();
+    }
+
+    interface ExtendedInfo extends BaseInfo {
+        void setInfo(String value);
+    }
+
+    interface ExtendedInfoWithOverride extends BaseInfo {
+        @Override
+        String getInfo();
+
+        void setInfo(String value);
+    }
+
+    @Test
+    public void setterInChildInterfaceWithoutGetterOverride() {
+        PropertySet<ExtendedInfo> set = BeanPropertySet.get(ExtendedInfo.class);
+
+        Optional<PropertyDefinition<ExtendedInfo, ?>> info = set
+                .getProperty("info");
+        Assert.assertTrue(info.isPresent());
+        Assert.assertNotNull(info.get().getGetter());
+        Assert.assertTrue(info.get().getSetter().isPresent());
+    }
+
+    @Test
+    public void setterInChildInterfaceWithGetterOverride() {
+        PropertySet<ExtendedInfoWithOverride> set = BeanPropertySet
+                .get(ExtendedInfoWithOverride.class);
+
+        Optional<PropertyDefinition<ExtendedInfoWithOverride, ?>> info = set
+                .getProperty("info");
+        Assert.assertTrue(info.isPresent());
+        Assert.assertNotNull(info.get().getGetter());
+        Assert.assertTrue(info.get().getSetter().isPresent());
+    }
+
     @Test
     public void includesDefaultMethodsFromInterfaces() {
         PropertySet<MyClass> set = BeanPropertySet.get(MyClass.class);

flow-server/src/main/java/com/vaadin/flow/internal/BeanUtil.java

@@ -87,13 +87,31 @@ public static List<PropertyDescriptor> getBeanPropertyDescriptors(
                         .getReadMethod().getDeclaringClass().isInterface()) {
                     continue;
                 }
+                // Merge read/write methods from separate descriptors
+                descriptor = mergeDescriptors(existing, descriptor);
             }
             descriptors.put(name, descriptor);
         }
 
         return new ArrayList<>(descriptors.values());
     }
 
+    private static PropertyDescriptor mergeDescriptors(
+            PropertyDescriptor existing, PropertyDescriptor incoming) {
+        Method read = incoming.getReadMethod() != null
+                ? incoming.getReadMethod()
+                : existing.getReadMethod();
+        Method write = incoming.getWriteMethod() != null
+                ? incoming.getWriteMethod()
+                : existing.getWriteMethod();
+        try {
+            return new PropertyDescriptor(incoming.getName(), read, write);
+        } catch (IntrospectionException e) {
+            // Fall back to incoming if merge fails
+            return incoming;
+        }
+    }
+
     private static List<PropertyDescriptor> internalGetBeanPropertyDescriptors(
             Class<?> beanType) throws IntrospectionException {
 

flow-server/src/test/java/com/vaadin/flow/internal/BeanUtilTest.java

@@ -1,5 +1,6 @@
 package com.vaadin.flow.internal;
 
+import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
 import java.util.List;
 
@@ -73,4 +74,27 @@ public void duplicatesAreRemoved() throws Exception {
                 oneInterfaceProperty.getReadMethod().getDeclaringClass());
 
     }
+
+    public interface ReadOnlyMeasurement {
+        double getValue();
+    }
+
+    public interface WritableMeasurement extends ReadOnlyMeasurement {
+        void setValue(double value);
+    }
+
+    @Test
+    public void getterAndSetterFromSeparateInterfacesAreMerged()
+            throws IntrospectionException {
+        List<PropertyDescriptor> descriptors = BeanUtil
+                .getBeanPropertyDescriptors(WritableMeasurement.class);
+
+        PropertyDescriptor valueDescriptor = descriptors.stream()
+                .filter(d -> "value".equals(d.getName())).findFirst()
+                .orElse(null);
+
+        Assert.assertNotNull("Should find 'value' property", valueDescriptor);
+        Assert.assertNotNull("Should have read method from parent interface", valueDescriptor.getReadMethod());
+        Assert.assertNotNull("Should have write method from child interface", valueDescriptor.getWriteMethod());
+    }
 }