Fix #2475

cowtowncoder · cowtowncoder · commit ca1867e64494 · 2019-09-29T18:20:45.000-07:00
diff --git a/release-notes/CREDITS-2.x b/release-notes/CREDITS-2.x
@@ -975,3 +975,8 @@ Martín Coll (colltoaction@github)
 Andrey Kulikov (ankulikov@github)
   * Reported #2457: Extended enum values are not handled as enums when used as Map keys
   (2.10.1)
+
+Ryan Bohn (bohnman@github)
+  * Reported `StringCollectionSerializer` calls `JsonGenerator.setCurrentValue(value)`,
+   which messes up current value for sibling properties
+  (2.10.1)
diff --git a/release-notes/VERSION-2.x b/release-notes/VERSION-2.x
@@ -8,6 +8,9 @@ Project: jackson-databind
 
 #2457: Extended enum values are not handled as enums when used as Map keys
  (reported by Andrey K)
+#2475: `StringCollectionSerializer` calls `JsonGenerator.setCurrentValue(value)`,
+  which messes up current value for sibling properties
+ (reported by Ryan B)
 
 2.10.0 (26-Sep-2019)
 
diff --git a/src/main/java/com/fasterxml/jackson/databind/deser/std/FromStringDeserializer.java b/src/main/java/com/fasterxml/jackson/databind/deser/std/FromStringDeserializer.java
@@ -24,7 +24,7 @@
  * can be coerced into text, like Numbers and Booleans).
  * Simple JSON String values are trimmed using {@link java.lang.String#trim}.
  * Partial deserializer implementation will try to first access current token as
- * a String, calls {@link #_deserialize(String,DeserializationContext)} and
+ * a String, calls {@code _deserialize(String,DeserializationContext)} and
  * returns return value.
  * If this does not work (current token not a simple scalar type), attempts
  * are made so that:
diff --git a/src/main/java/com/fasterxml/jackson/databind/node/ArrayNode.java b/src/main/java/com/fasterxml/jackson/databind/node/ArrayNode.java
@@ -173,7 +173,7 @@ public void serialize(JsonGenerator f, SerializerProvider provider) throws IOExc
     {
         final List<JsonNode> c = _children;
         final int size = c.size();
-        f.writeStartArray(size);
+        f.writeStartArray(this, size);
         for (int i = 0; i < size; ++i) { // we'll typically have array list
             // For now, assuming it's either BaseJsonNode, JsonSerializable
             JsonNode n = c.get(i);
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/BeanAsArraySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/BeanAsArraySerializer.java
@@ -136,9 +136,9 @@ public void serializeWithType(Object bean, JsonGenerator gen,
             _serializeWithObjectId(bean, gen, provider, typeSer);
             return;
         }
-        gen.setCurrentValue(bean);
         WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_ARRAY);
         typeSer.writeTypePrefix(gen, typeIdDef);
+        gen.setCurrentValue(bean);
         serializeAsArray(bean, gen, provider);
         typeSer.writeTypeSuffix(gen, typeIdDef);
     }
@@ -161,9 +161,7 @@ && hasSingleElement(provider)) {
          * any getter, filtering) have already been checked; so code here
          * is trivial.
          */
-        gen.writeStartArray();
-        // [databind#631]: Assign current value, to be accessible by custom serializers
-        gen.setCurrentValue(bean);
+        gen.writeStartArray(bean);
         serializeAsArray(bean, gen, provider);
         gen.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/IndexedListSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/IndexedListSerializer.java
@@ -75,7 +75,7 @@ public final void serialize(List<?> value, JsonGenerator gen, SerializerProvider
                 return;
             }
         }
-        gen.writeStartArray(len);
+        gen.writeStartArray(value, len);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
@@ -182,7 +182,6 @@ public void serializeTypedContents(List<?> value, JsonGenerator jgen, Serializer
                 }
             }
         } catch (Exception e) {
-            // [JACKSON-55] Need to add reference information
             wrapAndThrow(provider, e, value, i);
         }
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/IndexedStringListSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/IndexedStringListSerializer.java
@@ -73,7 +73,7 @@ public void serialize(List<String> value, JsonGenerator g,
                 return;
             }
         }
-        g.writeStartArray(len);
+        g.writeStartArray(value, len);
         serializeContents(value, g, provider, len);
         g.writeEndArray();
     }
@@ -85,14 +85,14 @@ public void serializeWithType(List<String> value, JsonGenerator g, SerializerPro
     {
         WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
                 typeSer.typeId(value, JsonToken.START_ARRAY));
+        g.setCurrentValue(value);
         serializeContents(value, g, provider, value.size());
         typeSer.writeTypeSuffix(g, typeIdDef);
     }
 
     private final void serializeContents(List<String> value, JsonGenerator g,
             SerializerProvider provider, int len) throws IOException
     {
-        g.setCurrentValue(value);
         int i = 0;
         try {
             for (; i < len; ++i) {
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/IteratorSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/IteratorSerializer.java
@@ -63,7 +63,7 @@ public final void serialize(Iterator<?> value, JsonGenerator gen,
             }
         }
         */
-        gen.writeStartArray();
+        gen.writeStartArray(value);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringArraySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringArraySerializer.java
@@ -167,7 +167,7 @@ public final void serialize(String[] value, JsonGenerator gen, SerializerProvide
                 return;
             }
         }
-        gen.writeStartArray(len);
+        gen.writeStartArray(value, len);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringCollectionSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringCollectionSerializer.java
@@ -67,7 +67,6 @@ protected void acceptContentVisitor(JsonArrayFormatVisitor visitor) throws JsonM
     public void serialize(Collection<String> value, JsonGenerator g,
             SerializerProvider provider) throws IOException
     {
-        g.setCurrentValue(value);
         final int len = value.size();
         if (len == 1) {
             if (((_unwrapSingle == null) &&
@@ -77,7 +76,7 @@ public void serialize(Collection<String> value, JsonGenerator g,
                 return;
             }
         }
-        g.writeStartArray(len);
+        g.writeStartArray(value, len);
         serializeContents(value, g, provider);
         g.writeEndArray();
     }
@@ -87,9 +86,9 @@ public void serializeWithType(Collection<String> value, JsonGenerator g,
             SerializerProvider provider, TypeSerializer typeSer)
         throws IOException
     {
-        g.setCurrentValue(value);
         WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
                 typeSer.typeId(value, JsonToken.START_ARRAY));
+        g.setCurrentValue(value);
         serializeContents(value, g, provider);
         typeSer.writeTypeSuffix(g, typeIdDef);
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/UnknownSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/UnknownSerializer.java
@@ -33,7 +33,7 @@ public void serialize(Object value, JsonGenerator gen, SerializerProvider provid
             failForEmpty(provider, value);
         }
         // But if it's fine, we'll just output empty JSON Object:
-        gen.writeStartObject();
+        gen.writeStartObject(value, 0);
         gen.writeEndObject();
     }
 
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/ArraySerializerBase.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/ArraySerializerBase.java
@@ -118,9 +118,7 @@ public void serialize(T value, JsonGenerator gen, SerializerProvider provider) t
                 return;
             }
         }
-        gen.setCurrentValue(value);
-        gen.writeStartArray();
-        // [databind#631]: Assign current value, to be accessible by custom serializers
+        gen.writeStartArray(value);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
@@ -130,10 +128,10 @@ public final void serializeWithType(T value, JsonGenerator g, SerializerProvider
             TypeSerializer typeSer)
         throws IOException
     {
-        // [databind#631]: Assign current value, to be accessible by custom serializers
-        g.setCurrentValue(value);
         WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
                 typeSer.typeId(value, JsonToken.START_ARRAY));
+        // [databind#631]: Assign current value, to be accessible by custom serializers
+        g.setCurrentValue(value);
         serializeContents(value, g, provider);
         typeSer.writeTypeSuffix(g, typeIdDef);
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/AsArraySerializerBase.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/AsArraySerializerBase.java
@@ -244,9 +244,7 @@ && hasSingleElement(value)) {
             serializeContents(value, gen, provider);
             return;
         }
-        gen.writeStartArray();
-        // [databind#631]: Assign current value, to be accessible by custom serializers
-        gen.setCurrentValue(value);
+        gen.writeStartArray(value);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
@@ -255,10 +253,10 @@ && hasSingleElement(value)) {
     public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
             TypeSerializer typeSer) throws IOException
     {
-        // [databind#631]: Assign current value, to be accessible by custom serializers
-        g.setCurrentValue(value);
         WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
                 typeSer.typeId(value, JsonToken.START_ARRAY));
+        // [databind#631]: Assign current value, to be accessible by custom serializers
+        g.setCurrentValue(value);
         serializeContents(value, g, provider);
         typeSer.writeTypeSuffix(g, typeIdDef);
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/CollectionSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/CollectionSerializer.java
@@ -103,7 +103,7 @@ public final void serialize(Collection<?> value, JsonGenerator g, SerializerProv
                 return;
             }
         }
-        g.writeStartArray(len);
+        g.writeStartArray(value, len);
         serializeContents(value, g, provider);
         g.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/EnumSetSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/EnumSetSerializer.java
@@ -60,7 +60,7 @@ public final void serialize(EnumSet<? extends Enum<?>> value, JsonGenerator gen,
                 return;
             }
         }
-        gen.writeStartArray(len);
+        gen.writeStartArray(value, len);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
@@ -77,9 +77,8 @@ public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator ge
          */
         for (Enum<?> en : value) {
             if (enumSer == null) {
-                /* 12-Jan-2010, tatu: Since enums cannot be polymorphic, let's
-                 *   not bother with typed serializer variant here
-                 */
+                // 12-Jan-2010, tatu: Since enums cannot be polymorphic, let's
+                //   not bother with typed serializer variant here
                 enumSer = provider.findValueSerializer(en.getDeclaringClass(), _property);
             }
             enumSer.serialize(en, gen, provider);
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/IterableSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/IterableSerializer.java
@@ -70,7 +70,7 @@ public final void serialize(Iterable<?> value, JsonGenerator gen,
                 return;
             }
         }
-        gen.writeStartArray();
+        gen.writeStartArray(value);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/ObjectArraySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/ObjectArraySerializer.java
@@ -209,7 +209,7 @@ public final void serialize(Object[] value, JsonGenerator gen, SerializerProvide
                 return;
             }
         }
-        gen.writeStartArray(len);
+        gen.writeStartArray(value, len);
         serializeContents(value, gen, provider);
         gen.writeEndArray();
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/StdArraySerializers.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/StdArraySerializers.java
@@ -141,8 +141,7 @@ public final void serialize(boolean[] value, JsonGenerator g, SerializerProvider
                 serializeContents(value, g, provider);
                 return;
             }
-            g.writeStartArray(len);
-            g.setCurrentValue(value);
+            g.writeStartArray(value, len);
             serializeContents(value, g, provider);
             g.writeEndArray();
         }
@@ -219,8 +218,7 @@ public final void serialize(short[] value, JsonGenerator g, SerializerProvider p
                 serializeContents(value, g, provider);
                 return;
             }
-            g.writeStartArray(len);
-            g.setCurrentValue(value);
+            g.writeStartArray(value, len);
             serializeContents(value, g, provider);
             g.writeEndArray();
         }
@@ -274,8 +272,7 @@ public void serialize(char[] value, JsonGenerator g, SerializerProvider provider
         {
             // [JACKSON-289] allows serializing as 'sparse' char array too:
             if (provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
-                g.writeStartArray(value.length);
-                g.setCurrentValue(value);
+                g.writeStartArray(value, value.length);
                 _writeArrayContents(g, value);
                 g.writeEndArray();
             } else {
@@ -389,7 +386,6 @@ public final void serialize(int[] value, JsonGenerator g, SerializerProvider pro
                 return;
             }
             // 11-May-2016, tatu: As per [core#277] we have efficient `writeArray(...)` available
-            g.setCurrentValue(value);
             g.writeArray(value, 0, value.length);
         }
 
@@ -462,7 +458,6 @@ public final void serialize(long[] value, JsonGenerator g, SerializerProvider pr
                 return;
             }
             // 11-May-2016, tatu: As per [core#277] we have efficient `writeArray(...)` available
-            g.setCurrentValue(value);
             g.writeArray(value, 0, value.length);
         }
         
@@ -539,8 +534,7 @@ public final void serialize(float[] value, JsonGenerator g, SerializerProvider p
                 serializeContents(value, g, provider);
                 return;
             }
-            g.writeStartArray(len);
-            g.setCurrentValue(value);
+            g.writeStartArray(value, len);
             serializeContents(value, g, provider);
             g.writeEndArray();
         }
@@ -626,7 +620,6 @@ public final void serialize(double[] value, JsonGenerator g, SerializerProvider
                 serializeContents(value, g, provider);
                 return;
             }
-            g.setCurrentValue(value);
             // 11-May-2016, tatu: As per [core#277] we have efficient `writeArray(...)` available
             g.writeArray(value, 0, value.length);
         }
diff --git a/src/main/java/com/fasterxml/jackson/databind/util/TokenBuffer.java b/src/main/java/com/fasterxml/jackson/databind/util/TokenBuffer.java
@@ -679,8 +679,20 @@ public final void writeStartArray(int size) throws IOException
         _writeContext = _writeContext.createChildArrayContext();
     }
 
-    // // TODO: add 2 more `writeStartArray()` methods from 2.10 (in 2.11 or later)
-    
+    @Override // since 2.10.1
+    public void writeStartArray(Object forValue) throws IOException {
+        _writeContext.writeValue();
+        _appendStartMarker(JsonToken.START_ARRAY);
+        _writeContext = _writeContext.createChildArrayContext();
+    }
+
+    @Override // since 2.10.1
+    public void writeStartArray(Object forValue, int size) throws IOException {
+        _writeContext.writeValue();
+        _appendStartMarker(JsonToken.START_ARRAY);
+        _writeContext = _writeContext.createChildArrayContext(forValue);
+    }
+
     @Override
     public final void writeEndArray() throws IOException
     {
@@ -705,16 +717,19 @@ public void writeStartObject(Object forValue) throws IOException
     {
         _writeContext.writeValue();
         _appendStartMarker(JsonToken.START_OBJECT);
-        // 15-Aug-2019, tatu: Matching method only added in 2.10, don't yet call
-        JsonWriteContext ctxt = _writeContext.createChildObjectContext();
+        JsonWriteContext ctxt = _writeContext.createChildObjectContext(forValue);
+        _writeContext = ctxt;
+    }
+
+    @Override // since 2.10.1
+    public void writeStartObject(Object forValue, int size) throws IOException
+    {
+        _writeContext.writeValue();
+        _appendStartMarker(JsonToken.START_OBJECT);
+        JsonWriteContext ctxt = _writeContext.createChildObjectContext(forValue);
         _writeContext = ctxt;
-        if (forValue != null) {
-            ctxt.setCurrentValue(forValue);
-        }
     }
 
-    // // TODO: add 1 more `writeStartObject()` methods from 2.10 (in 2.11 or later)
-    
     @Override
     public final void writeEndObject() throws IOException
     {
diff --git a/src/test/java/com/fasterxml/jackson/databind/ser/TestCustomSerializers.java b/src/test/java/com/fasterxml/jackson/databind/ser/TestCustomSerializers.java

Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ public void serialize(JsonGenerator f, SerializerProvider provider) throws IOExc`
`173`	`173`	`{`
`174`	`174`	`final List<JsonNode> c = _children;`
`175`	`175`	`final int size = c.size();`
`176`		`- f.writeStartArray(size);`
	`176`	`+ f.writeStartArray(this, size);`
`177`	`177`	`for (int i = 0; i < size; ++i) { // we'll typically have array list`
`178`	`178`	`// For now, assuming it's either BaseJsonNode, JsonSerializable`
`179`	`179`	`JsonNode n = c.get(i);`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public final void serialize(List<?> value, JsonGenerator gen, SerializerProvider`
`75`	`75`	`return;`
`76`	`76`	`}`
`77`	`77`	`}`
`78`		`- gen.writeStartArray(len);`
	`78`	`+ gen.writeStartArray(value, len);`
`79`	`79`	`serializeContents(value, gen, provider);`
`80`	`80`	`gen.writeEndArray();`
`81`	`81`	`}`
`@@ -182,7 +182,6 @@ public void serializeTypedContents(List<?> value, JsonGenerator jgen, Serializer`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`	`} catch (Exception e) {`
`185`		`- // [JACKSON-55] Need to add reference information`
`186`	`185`	`wrapAndThrow(provider, e, value, i);`
`187`	`186`	`}`
`188`	`187`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void serialize(List<String> value, JsonGenerator g,`
`73`	`73`	`return;`
`74`	`74`	`}`
`75`	`75`	`}`
`76`		`- g.writeStartArray(len);`
	`76`	`+ g.writeStartArray(value, len);`
`77`	`77`	`serializeContents(value, g, provider, len);`
`78`	`78`	`g.writeEndArray();`
`79`	`79`	`}`
`@@ -85,14 +85,14 @@ public void serializeWithType(List<String> value, JsonGenerator g, SerializerPro`
`85`	`85`	`{`
`86`	`86`	`WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,`
`87`	`87`	`typeSer.typeId(value, JsonToken.START_ARRAY));`
	`88`	`+ g.setCurrentValue(value);`
`88`	`89`	`serializeContents(value, g, provider, value.size());`
`89`	`90`	`typeSer.writeTypeSuffix(g, typeIdDef);`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`private final void serializeContents(List<String> value, JsonGenerator g,`
`93`	`94`	`SerializerProvider provider, int len) throws IOException`
`94`	`95`	`{`
`95`		`- g.setCurrentValue(value);`
`96`	`96`	`int i = 0;`
`97`	`97`	`try {`
`98`	`98`	`for (; i < len; ++i) {`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public final void serialize(Iterator<?> value, JsonGenerator gen,`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`*/`
`66`		`- gen.writeStartArray();`
	`66`	`+ gen.writeStartArray(value);`
`67`	`67`	`serializeContents(value, gen, provider);`
`68`	`68`	`gen.writeEndArray();`
`69`	`69`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ public final void serialize(String[] value, JsonGenerator gen, SerializerProvide`
`167`	`167`	`return;`
`168`	`168`	`}`
`169`	`169`	`}`
`170`		`- gen.writeStartArray(len);`
	`170`	`+ gen.writeStartArray(value, len);`
`171`	`171`	`serializeContents(value, gen, provider);`
`172`	`172`	`gen.writeEndArray();`
`173`	`173`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,6 @@ protected void acceptContentVisitor(JsonArrayFormatVisitor visitor) throws JsonM`
`67`	`67`	`public void serialize(Collection<String> value, JsonGenerator g,`
`68`	`68`	`SerializerProvider provider) throws IOException`
`69`	`69`	`{`
`70`		`- g.setCurrentValue(value);`
`71`	`70`	`final int len = value.size();`
`72`	`71`	`if (len == 1) {`
`73`	`72`	`if (((_unwrapSingle == null) &&`
`@@ -77,7 +76,7 @@ public void serialize(Collection<String> value, JsonGenerator g,`
`77`	`76`	`return;`
`78`	`77`	`}`
`79`	`78`	`}`
`80`		`- g.writeStartArray(len);`
	`79`	`+ g.writeStartArray(value, len);`
`81`	`80`	`serializeContents(value, g, provider);`
`82`	`81`	`g.writeEndArray();`
`83`	`82`	`}`
`@@ -87,9 +86,9 @@ public void serializeWithType(Collection<String> value, JsonGenerator g,`
`87`	`86`	`SerializerProvider provider, TypeSerializer typeSer)`
`88`	`87`	`throws IOException`
`89`	`88`	`{`
`90`		`- g.setCurrentValue(value);`
`91`	`89`	`WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,`
`92`	`90`	`typeSer.typeId(value, JsonToken.START_ARRAY));`
	`91`	`+ g.setCurrentValue(value);`
`93`	`92`	`serializeContents(value, g, provider);`
`94`	`93`	`typeSer.writeTypeSuffix(g, typeIdDef);`
`95`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void serialize(Object value, JsonGenerator gen, SerializerProvider provid`
`33`	`33`	`failForEmpty(provider, value);`
`34`	`34`	`}`
`35`	`35`	`// But if it's fine, we'll just output empty JSON Object:`
`36`		`- gen.writeStartObject();`
	`36`	`+ gen.writeStartObject(value, 0);`
`37`	`37`	`gen.writeEndObject();`
`38`	`38`	`}`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -118,9 +118,7 @@ public void serialize(T value, JsonGenerator gen, SerializerProvider provider) t`
`118`	`118`	`return;`
`119`	`119`	`}`
`120`	`120`	`}`
`121`		`- gen.setCurrentValue(value);`
`122`		`- gen.writeStartArray();`
`123`		`- // [databind#631]: Assign current value, to be accessible by custom serializers`
	`121`	`+ gen.writeStartArray(value);`
`124`	`122`	`serializeContents(value, gen, provider);`
`125`	`123`	`gen.writeEndArray();`
`126`	`124`	`}`
`@@ -130,10 +128,10 @@ public final void serializeWithType(T value, JsonGenerator g, SerializerProvider`
`130`	`128`	`TypeSerializer typeSer)`
`131`	`129`	`throws IOException`
`132`	`130`	`{`
`133`		`- // [databind#631]: Assign current value, to be accessible by custom serializers`
`134`		`- g.setCurrentValue(value);`
`135`	`131`	`WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,`
`136`	`132`	`typeSer.typeId(value, JsonToken.START_ARRAY));`
	`133`	`+ // [databind#631]: Assign current value, to be accessible by custom serializers`
	`134`	`+ g.setCurrentValue(value);`
`137`	`135`	`serializeContents(value, g, provider);`
`138`	`136`	`typeSer.writeTypeSuffix(g, typeIdDef);`
`139`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -244,9 +244,7 @@ && hasSingleElement(value)) {`
`244`	`244`	`serializeContents(value, gen, provider);`
`245`	`245`	`return;`
`246`	`246`	`}`
`247`		`- gen.writeStartArray();`
`248`		`- // [databind#631]: Assign current value, to be accessible by custom serializers`
`249`		`- gen.setCurrentValue(value);`
	`247`	`+ gen.writeStartArray(value);`
`250`	`248`	`serializeContents(value, gen, provider);`
`251`	`249`	`gen.writeEndArray();`
`252`	`250`	`}`
`@@ -255,10 +253,10 @@ && hasSingleElement(value)) {`
`255`	`253`	`public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,`
`256`	`254`	`TypeSerializer typeSer) throws IOException`
`257`	`255`	`{`
`258`		`- // [databind#631]: Assign current value, to be accessible by custom serializers`
`259`		`- g.setCurrentValue(value);`
`260`	`256`	`WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,`
`261`	`257`	`typeSer.typeId(value, JsonToken.START_ARRAY));`
	`258`	`+ // [databind#631]: Assign current value, to be accessible by custom serializers`
	`259`	`+ g.setCurrentValue(value);`
`262`	`260`	`serializeContents(value, g, provider);`
`263`	`261`	`typeSer.writeTypeSuffix(g, typeIdDef);`
`264`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public final void serialize(Collection<?> value, JsonGenerator g, SerializerProv`
`103`	`103`	`return;`
`104`	`104`	`}`
`105`	`105`	`}`
`106`		`- g.writeStartArray(len);`
	`106`	`+ g.writeStartArray(value, len);`
`107`	`107`	`serializeContents(value, g, provider);`
`108`	`108`	`g.writeEndArray();`
`109`	`109`	`}`