Ask the collection branch the question its siblings already ask

Three places bind an element into a collection, and two of them keep the item
when the element type is already assignable from it: the array branch above and
the Map branch below both do it, and SimpleDataBinder does it too. Only the
collection branch went straight to instantiating, which is why a raw collection
lost its data there and nowhere else.

Asking the same question there fixes it in the same shape as its neighbours,
rather than adding a special case for Object, and needs no change to
instantiateAndBindNestedOrUseMapConstructor: a raw collection's component type
is Object, Object is assignable from everything, so the element is kept.

The SimpleDataBinder guard from the first commit is dropped with this: that
class already asks at line 373 and was never affected.

Author: codeconsole

grails-databinding-core/src/main/groovy/grails/databinding/SimpleDataBinder.groovy

@@ -426,16 +426,6 @@ class SimpleDataBinder implements DataBinder {
     }
 
     protected Object instantiateAndBindOrUseMapConstructor(Class referencedType, Map values, DataBindingListener listener) {
-        if (referencedType == null || referencedType == Object) {
-            // A raw collection -- List/Set/Map written without a type argument -- reports Object as
-            // its component type: Basic#componentType falls back to Object.class when a property
-            // carries no generic signature. Object declares no properties, so instantiating one and
-            // binding into it has nowhere to put the element's data and the element silently becomes
-            // an empty Object. A value that is never used as a property source cannot mass-assign
-            // anything, so it is kept as it stands, which is also how these collections bound before
-            // deny-by-default.
-            return values
-        }
         def instance
         try {
             instance = referencedType.getDeclaredConstructor().newInstance()

grails-web-databinding/src/main/groovy/grails/web/databinding/GrailsWebDataBinder.groovy

@@ -545,7 +545,17 @@ class GrailsWebDataBinder extends SimpleDataBinder {
                                 }
                             }
                             if (persistentInstance == null) {
-                                if (item instanceof Map || item instanceof DataBindingSource) {
+                                if (item == null || referencedType.isAssignableFrom(item.getClass())) {
+                                    // Already of the element type, so there is nothing to instantiate
+                                    // and nothing to bind into. A raw collection always lands here:
+                                    // Basic#componentType falls back to Object.class when a property
+                                    // carries no generic signature, and Object is assignable from
+                                    // everything. The array branch above and the Map branch below ask
+                                    // the same question before instantiating; only this one did not,
+                                    // so a map element was replaced by an empty Object and its
+                                    // contents were dropped.
+                                    itemsWhichNeedBinding << item
+                                } else if (item instanceof Map || item instanceof DataBindingSource) {
                                     DataBindingSource itemBindingSource = item instanceof DataBindingSource ?
                                             (DataBindingSource) item : new SimpleMapDataBindingSource((Map) item)
                                     def instance = instantiateAndBindNestedOrUseMapConstructor(
@@ -634,16 +644,6 @@ class GrailsWebDataBinder extends SimpleDataBinder {
 
     private Object instantiateAndBindNestedOrUseMapConstructor(Class referencedType, Object value,
             DataBindingSource source, List includeList, DataBindingListener listener) {
-        if (referencedType == null || referencedType == Object) {
-            // A raw collection -- List/Set/Map written without a type argument -- reports Object as
-            // its component type: Basic#componentType falls back to Object.class when a property
-            // carries no generic signature. Object declares no properties, so instantiating one and
-            // binding into it has nowhere to put the element's data and the element silently becomes
-            // an empty Object. A value that is never used as a property source cannot mass-assign
-            // anything, so it is kept as it stands, which is also how these collections bound before
-            // deny-by-default.
-            return value
-        }
         def instance
         try {
             instance = referencedType.getDeclaredConstructor().newInstance()