Merge branch '3.2' into 3.x

Author: cowtowncoder

release-notes/CREDITS

@@ -147,3 +147,8 @@ Veit-Hendrik Schlenker (@vhschlenker)
 Charles Moulliard (@cmoulliard)
  * Reported #795: `HttpHeader` object (= <httpHeaders>) is not wrapped by the XML `<property>` tag
   (3.2.0)
+
+Christian Beikov (@beikov)
+ * Reported #871: `XmlMapper` regression in 3.2.0: `xsi:nil` collection element on
+   unwrapped collection wrongly read as null collection
+  (3.3.0)

release-notes/VERSION

@@ -7,7 +7,11 @@ Version: 3.x (for earlier see VERSION-2.x)
 
 3.3.0 (not yet released)
 
-No changes since 3.2
+#871: `XmlMapper` regression in 3.2.0: `xsi:nil` collection element on unwrapped
+  collection wrongly read as null collection (instead of collection with one
+  null element); null unwrapped collection now omitted on write
+ (reported by Christian B, @beikov)
+ (fix by @cowtowncoder, w/ Claude code)
 
 3.2.0 (08-Jun-2026)
 

src/main/java/tools/jackson/dataformat/xml/deser/FromXmlParser.java

@@ -675,14 +675,13 @@ public JsonToken nextToken() throws JacksonException
             _streamReadContext.setCurrentName(name);
 
             // Ok: virtual wrapping can be done by simply repeating current START_ELEMENT.
-            // Couple of ways to do it; but start by making _xmlTokens replay the thing...
             if (_streamReadContext.shouldWrap(name)) {
-                // [dataformat-xml#627]: But if xsi:nil="true" found, do NOT wrap —
-                // let the normal xsi:nil handling produce VALUE_NULL for the property
-                // instead of creating a list with one empty element.
-                if (!_xmlTokens.hasXsiNil()) {
-                    _xmlTokens.repeatStartElement();
-                }
+                // [dataformat-xml#871]: Always repeat START_ELEMENT to form the
+                // virtual array wrapper.
+                // [dataformats-xml#627] skipped wrapping on xsi:nil, but that made
+                // valid `<e xsi:nil="true"/>` collection items wrongly read as null
+                // collections and silently dropped leading null elements.
+                _xmlTokens.repeatStartElement();
             }
 
             _mayBeLeaf = true;

src/main/java/tools/jackson/dataformat/xml/ser/XmlBeanSerializerModifier.java

@@ -77,6 +77,15 @@ public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
 
             // first things first: no wrapping?
             if (wrapperName == null || wrapperName == PropertyName.NO_NAME) {
+                // [dataformat-xml#627]/[dataformat-xml#871]: For an unwrapped
+                // Collection/array property, a null value must be omitted (as in the
+                // wrapped case below) rather than written as an `xsi:nil` element --
+                // otherwise it is indistinguishable, on read, from a collection holding
+                // a single null element. Only applies to concrete indexed types (not the
+                // dynamic Object-typed case) and only to plain BeanPropertyWriters.
+                if (!dynamicWrapping && bpw.getClass() == BeanPropertyWriter.class) {
+                    beanProperties.set(i, new XmlNullSuppressingBeanPropertyWriter(bpw));
+                }
                 continue;
             }
             // no local name? Just double the wrapped name for wrapper

src/main/java/tools/jackson/dataformat/xml/ser/XmlNullSuppressingBeanPropertyWriter.java

@@ -0,0 +1,45 @@
+package tools.jackson.dataformat.xml.ser;
+
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.ser.BeanPropertyWriter;
+
+/**
+ * Property writer sub-class used for unwrapped (no wrapper element) Collection/array
+ * properties. It suppresses output of {@code null} values entirely, so that a null
+ * collection is simply omitted -- consistent with the wrapped-collection case handled
+ * by {@link XmlBeanPropertyWriter} (which also omits null collections).
+ *<p>
+ * Without this, an unwrapped null collection would be written via the standard null
+ * handling as an {@code xsi:nil} element (when {@code WRITE_NULLS_AS_XSI_NIL} is enabled,
+ * which it is by default in 3.x). That output is indistinguishable, on read, from a
+ * collection containing a single null element (see [dataformat-xml#871]), so for null
+ * collections we omit the element instead.
+ *
+ * @since 3.2.1
+ */
+public class XmlNullSuppressingBeanPropertyWriter
+    extends BeanPropertyWriter
+{
+    public XmlNullSuppressingBeanPropertyWriter(BeanPropertyWriter wrapped)
+    {
+        super(wrapped);
+    }
+
+    @Override
+    public void serializeAsProperty(Object bean, JsonGenerator g, SerializationContext ctxt)
+        throws Exception
+    {
+        // [dataformat-xml#627]/[dataformat-xml#871]: omit a null unwrapped collection
+        // (rather than writing it as an `xsi:nil` element), matching wrapped behavior.
+        if (get(bean) == null) {
+            return;
+        }
+        super.serializeAsProperty(bean, g, ctxt);
+    }
+
+    // NOTE: intentionally do NOT override `serializeAsElement()` (used for Array/tabular
+    // shape, e.g. `@JsonFormat(shape = ARRAY)`): there, null entries are positional and
+    // must be written (as `null`), not suppressed -- otherwise following entries would
+    // shift. Only the Object-shape `serializeAsProperty()` path suppresses nulls here.
+}

src/test/java/tools/jackson/dataformat/xml/lists/Issue627NullListTest.java

@@ -42,8 +42,11 @@ public void testNullListRoundTripNoWrapper() throws Exception
         assertNull(a.getChildren());
 
         String xml = mapper.writeValueAsString(a);
-        assertTrue(xml.contains("xsi:nil=\"true\""),
-                "Null list should serialize with xsi:nil");
+        // [dataformat-xml#871]: a null unwrapped collection is omitted (not written as
+        // an `xsi:nil` element, which would be ambiguous with a single null element);
+        // consistent with the wrapped-collection case.
+        assertFalse(xml.contains("children"),
+                "Null unwrapped list should be omitted, was: " + xml);
 
         Parent b = mapper.readValue(xml, Parent.class);
 
@@ -86,7 +89,9 @@ public void testNonNullListRoundTripNoWrapper() throws Exception
         assertEquals("test", b.getChildren().get(0).getName());
     }
 
-    // Verify deserializing explicit xsi:nil on unwrapped list property
+    // [dataformat-xml#871]: an explicit xsi:nil on an unwrapped collection element
+    // denotes a single null *element* within the collection -- NOT a null collection.
+    // (A null collection is instead omitted on serialization; see round-trip tests above.)
     @Test
     public void testXsiNilUnwrappedListDeser() throws Exception
     {
@@ -97,7 +102,9 @@ public void testXsiNilUnwrappedListDeser() throws Exception
         String xml = "<Parent><children xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:nil=\"true\"/></Parent>";
         Parent b = mapper.readValue(xml, Parent.class);
 
-        assertNull(b.getChildren(),
-                "xsi:nil on unwrapped list element should produce null list");
+        assertNotNull(b.getChildren(),
+                "xsi:nil on unwrapped list element should produce a list with one null element");
+        assertEquals(1, b.getChildren().size());
+        assertNull(b.getChildren().get(0));
     }
 }

src/test/java/tools/jackson/dataformat/xml/lists/Issue871NullElementTest.java

@@ -0,0 +1,58 @@
+package tools.jackson.dataformat.xml.lists;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.annotation.JsonRootName;
+
+import tools.jackson.dataformat.xml.XmlMapper;
+import tools.jackson.dataformat.xml.XmlTestUtil;
+import tools.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
+import tools.jackson.dataformat.xml.annotation.JacksonXmlProperty;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test for [dataformat-xml#871]: an `xsi:nil="true"` collection element on an unwrapped
+ * collection must read as a single null *element* within the collection, not as a null
+ * collection (regression from the original #627 attempt).
+ */
+public class Issue871NullElementTest extends XmlTestUtil
+{
+    @JsonRootName(value = "Collection")
+    static class CollectionWrapper {
+        @JacksonXmlElementWrapper(useWrapping = false)
+        @JacksonXmlProperty(localName = "e")
+        public Collection<String> value;
+
+        public CollectionWrapper() { this.value = new ArrayList<>(); }
+    }
+
+    private final XmlMapper MAPPER = new XmlMapper();
+
+    private static final String NS = "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"";
+
+    @Test
+    public void testSingleNullElement() throws Exception
+    {
+        String xml = "<Collection><e " + NS + " xsi:nil=\"true\"/></Collection>";
+        CollectionWrapper cw = MAPPER.readValue(xml, CollectionWrapper.class);
+
+        assertNotNull(cw.value);
+        assertEquals(1, cw.value.size());
+        assertNull(cw.value.iterator().next());
+    }
+
+    @Test
+    public void testLeadingNullElementNotDropped() throws Exception
+    {
+        String xml = "<Collection><e " + NS + " xsi:nil=\"true\"/><e>x</e></Collection>";
+        CollectionWrapper cw = MAPPER.readValue(xml, CollectionWrapper.class);
+
+        assertNotNull(cw.value);
+        assertEquals(2, cw.value.size());
+        assertEquals(java.util.Arrays.asList(null, "x"), new ArrayList<>(cw.value));
+    }
+}