fix: merge property descriptors when getter and setter come from different interfaces

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,71 @@ public void setFirstName(String firstName) {
         }
     }
 
+    public interface Measurement {
+        double getValue();
+    }
+
+    public interface MutableMeasurement extends Measurement {
+        void setValue(double value);
+    }
+
+    @Test
+    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);
+
+        assertTrue(set.getProperty("value").isPresent(),
+                "Property 'value' should be discovered when getter is in "
+                        + "a parent interface and setter in a sub-interface");
+        PropertyDefinition<MutableMeasurement, ?> def = set.getProperty("value")
+                .get();
+        assertNotNull(def.getGetter());
+        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
+    void setterInChildInterfaceWithoutGetterOverride() {
+        PropertySet<ExtendedInfo> set = BeanPropertySet.get(ExtendedInfo.class);
+
+        Optional<PropertyDefinition<ExtendedInfo, ?>> info = set
+                .getProperty("info");
+        assertTrue(info.isPresent());
+        assertNotNull(info.get().getGetter());
+        assertTrue(info.get().getSetter().isPresent());
+    }
+
+    @Test
+    void setterInChildInterfaceWithGetterOverride() {
+        PropertySet<ExtendedInfoWithOverride> set = BeanPropertySet
+                .get(ExtendedInfoWithOverride.class);
+
+        Optional<PropertyDefinition<ExtendedInfoWithOverride, ?>> info = set
+                .getProperty("info");
+        assertTrue(info.isPresent());
+        assertNotNull(info.get().getGetter());
+        assertTrue(info.get().getSetter().isPresent());
+    }
+
     @Test
     void includesDefaultMethodsFromInterfaces() {
         PropertySet<MyClass> set = BeanPropertySet.get(MyClass.class);

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

@@ -89,13 +89,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

@@ -382,4 +382,29 @@ void duplicatesAreRemoved() throws Exception {
                 oneInterfaceProperty.getReadMethod().getDeclaringClass());
 
     }
+
+    public interface ReadOnlyMeasurement {
+        double getValue();
+    }
+
+    public interface WritableMeasurement extends ReadOnlyMeasurement {
+        void setValue(double value);
+    }
+
+    @Test
+    void getterAndSetterFromSeparateInterfacesAreMerged()
+            throws IntrospectionException {
+        List<PropertyDescriptor> descriptors = BeanUtil
+                .getBeanPropertyDescriptors(WritableMeasurement.class);
+
+        PropertyDescriptor valueDescriptor = descriptors.stream()
+                .filter(d -> "value".equals(d.getName())).findFirst()
+                .orElse(null);
+
+        assertNotNull(valueDescriptor, "Should find 'value' property");
+        assertNotNull(valueDescriptor.getReadMethod(),
+                "Should have read method from parent interface");
+        assertNotNull(valueDescriptor.getWriteMethod(),
+                "Should have write method from child interface");
+    }
 }