decode: Only recursively unslice when the target is an interface{}

lib/decode/decode.go

@@ -94,11 +94,13 @@ func canonicalFieldKey(field reflect.StructField) string {
 	return parts[0]
 }
 
-// HookWeakDecodeFromSlice looks for []map[string]interface{} in the source
+// HookWeakDecodeFromSlice looks for []map[string]interface{} and []interface{}
-// data. If the target is not a slice or array it attempts to unpack 1 item
+// in the source data. If the target is not a slice or array it attempts to unpack
-// out of the slice. If there are more items the source data is left unmodified,
+// 1 item out of the slice. If there are more items the source data is left
-// allowing mapstructure to handle and report the decode error caused by
+// unmodified, allowing mapstructure to handle and report the decode error caused by
-// mismatched types.
+// mismatched types. The []interface{} is handled so that all slice types are
+// behave the same way, and for the rare case when a raw structure is re-encoded
+// to JSON, which will produce the []interface{}.
 //
 // If this hook is being used on a "second pass" decode to decode an opaque
 // configuration into a type, the DecodeConfig should set WeaklyTypedInput=true,
@@ -122,18 +124,31 @@ func HookWeakDecodeFromSlice(from, to reflect.Type, data interface{}) (interface
 
 	switch d := data.(type) {
 	case []map[string]interface{}:
-		if len(d) == 1 {
+		switch {
+		case len(d) != 1:
+			return data, nil
+		case to == typeOfEmptyInterface:
 			return unSlice(d[0])
+		default:
+			return d[0], nil
 		}
-	// the JSON decoder can apparently decode slices as []interface{}
+
+	// a slice map be encoded as []interface{} in some cases
 	case []interface{}:
-		if len(d) == 1 {
+		switch {
+		case len(d) != 1:
+			return data, nil
+		case to == typeOfEmptyInterface:
 			return unSlice(d[0])
+		default:
+			return d[0], nil
 		}
 	}
 	return data, nil
 }
 
+var typeOfEmptyInterface = reflect.TypeOf((*interface{})(nil)).Elem()
+
 func unSlice(data interface{}) (interface{}, error) {
 	err := reflectwalk.Walk(data, &unSliceWalker{})
 	return data, err
@@ -155,6 +170,11 @@ func (u *unSliceWalker) MapElem(m, k, v reflect.Value) error {
 		return nil
 	}
 
-	m.SetMapIndex(k, v.Index(0))
+	first := v.Index(0)
+	// The value should always be assignable, but double check to avoid a panic.
+	if !first.Type().AssignableTo(m.Type().Elem()) {
+		return nil
+	}
+	m.SetMapIndex(k, first)
 	return nil
 }

lib/decode/decode_test.go

@@ -198,9 +198,11 @@ func TestTranslationsForType(t *testing.T) {
 }
 
 type nested struct {
-	O     map[string]interface{}
+	O      map[string]interface{}
-	Slice []Item
+	Slice  []Item
-	Item  Item
+	Item   Item
+	OSlice []map[string]interface{}
+	Sub    *nested
 }
 
 type Item struct {
@@ -215,6 +217,14 @@ slice {
 slice {
     name = "second"
 }
+item {
+	name = "solo"
+}
+sub {
+	oslice {
+		something = "v1"
+	}
+}
 `
 	target := &nested{}
 	err := decodeHCLToMapStructure(source, target)
@@ -222,6 +232,12 @@ slice {
 
 	expected := &nested{
 		Slice: []Item{{Name: "first"}, {Name: "second"}},
+		Item:  Item{Name: "solo"},
+		Sub: &nested{
+			OSlice: []map[string]interface{}{
+				{"something": "v1"},
+			},
+		},
 	}
 	require.Equal(t, target, expected)
 }
@@ -242,6 +258,40 @@ func decodeHCLToMapStructure(source string, target interface{}) error {
 	return decoder.Decode(&raw)
 }
 
+func TestHookWeakDecodeFromSlice_DoesNotModifySliceTargetsFromSliceInterface(t *testing.T) {
+	raw := map[string]interface{}{
+		"slice": []interface{}{map[string]interface{}{"name": "first"}},
+		"item":  []interface{}{map[string]interface{}{"name": "solo"}},
+		"sub": []interface{}{
+			map[string]interface{}{
+				"OSlice": []interface{}{
+					map[string]interface{}{"something": "v1"},
+				},
+				"item": []interface{}{map[string]interface{}{"name": "subitem"}},
+			},
+		},
+	}
+	target := &nested{}
+	decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
+		DecodeHook: HookWeakDecodeFromSlice,
+		Result:     target,
+	})
+	require.NoError(t, err)
+	err = decoder.Decode(&raw)
+
+	expected := &nested{
+		Slice: []Item{{Name: "first"}},
+		Item:  Item{Name: "solo"},
+		Sub: &nested{
+			OSlice: []map[string]interface{}{
+				{"something": "v1"},
+			},
+			Item: Item{Name: "subitem"},
+		},
+	}
+	require.Equal(t, target, expected)
+}
+
 func TestHookWeakDecodeFromSlice_ErrorsWithMultipleNestedBlocks(t *testing.T) {
 	source := `
 item {