Ensure ancestor information is used when decoding

A new Ancestor field is added to the DecodeContext and is used when
decoding a BSON Embedded Document into an interface{}.

GODRIVER-699

Change-Id: Ie364ff52106e231950b83d3c9a197363d76cf19f

Author: skriptble

bson/bsoncodec/bsoncodec.go

@@ -114,6 +114,11 @@ type EncodeContext struct {
 type DecodeContext struct {
 	*Registry
 	Truncate bool
+	// Ancestor is the type of a containing document. This is mainly used to determine what type
+	// should be used when decoding an embedded document into an empty interface. For example, if
+	// Ancestor is a bson.M, BSON embedded document values being decoded into an empty interface
+	// will be decoded into a bson.M.
+	Ancestor reflect.Type
 }
 
 // ValueCodec is the interface that groups the methods to encode and decode

bson/bsoncodec/default_value_decoders.go

@@ -83,7 +83,6 @@ func (dvd DefaultValueDecoders) RegisterDefaultDecoders(rb *RegistryBuilder) {
 		RegisterDefaultDecoder(reflect.Ptr, NewPointerCodec()).
 		RegisterTypeMapEntry(bsontype.Double, tFloat64).
 		RegisterTypeMapEntry(bsontype.String, tString).
-		RegisterTypeMapEntry(bsontype.EmbeddedDocument, tD).
 		RegisterTypeMapEntry(bsontype.Array, tA).
 		RegisterTypeMapEntry(bsontype.Binary, tBinary).
 		RegisterTypeMapEntry(bsontype.Undefined, tUndefined).
@@ -675,6 +674,10 @@ func (dvd DefaultValueDecoders) MapDecodeValue(dc DecodeContext, vr bsonrw.Value
 		return err
 	}
 
+	if eType == tEmpty {
+		dc.Ancestor = val.Type()
+	}
+
 	for {
 		key, vr, err := dr.ReadElement()
 		if err == bsonrw.ErrEOD {
@@ -758,6 +761,7 @@ func (dvd DefaultValueDecoders) SliceDecodeValue(dc DecodeContext, vr bsonrw.Val
 	var elemsFunc func(DecodeContext, bsonrw.ValueReader, reflect.Value) ([]reflect.Value, error)
 	switch val.Type().Elem() {
 	case tE:
+		dc.Ancestor = val.Type()
 		elemsFunc = dvd.decodeD
 	default:
 		elemsFunc = dvd.decodeDefault
@@ -852,11 +856,19 @@ func (dvd DefaultValueDecoders) EmptyInterfaceDecodeValue(dc DecodeContext, vr b
 
 	rtype, err := dc.LookupTypeMapEntry(vr.Type())
 	if err != nil {
-		if vr.Type() == bsontype.Null {
+		switch vr.Type() {
+		case bsontype.EmbeddedDocument:
+			if dc.Ancestor != nil {
+				rtype = dc.Ancestor
+				break
+			}
+			rtype = tD
+		case bsontype.Null:
 			val.Set(reflect.Zero(val.Type()))
 			return vr.ReadNull()
+		default:
+			return err
 		}
-		return err
 	}
 
 	decoder, err := dc.LookupDecoder(rtype)

bson/bsoncodec/default_value_decoders_test.go

@@ -2274,6 +2274,11 @@ func TestDefaultValueDecoders(t *testing.T) {
 					AS []byte
 					AT map[string]interface{}
 					AU primitive.CodeWithScope
+					AV primitive.M
+					AW primitive.D
+					AX map[string]interface{}
+					AY []primitive.E
+					AZ interface{}
 				}{
 					A: true,
 					B: 123,
@@ -2315,6 +2320,11 @@ func TestDefaultValueDecoders(t *testing.T) {
 					AS: nil,
 					AT: nil,
 					AU: primitive.CodeWithScope{Code: "var hello = 'world';", Scope: primitive.D{{"pi", 3.14159}}},
+					AV: primitive.M{"foo": primitive.M{"bar": "baz"}},
+					AW: primitive.D{{"foo", primitive.D{{"bar", "baz"}}}},
+					AX: map[string]interface{}{"foo": map[string]interface{}{"bar": "baz"}},
+					AY: []primitive.E{{"foo", []primitive.E{{"bar", "baz"}}}},
+					AZ: primitive.D{{"foo", primitive.D{{"bar", "baz"}}}},
 				},
 				buildDocument(func(doc []byte) []byte {
 					doc = bsoncore.AppendBooleanElement(doc, "a", true)
@@ -2361,6 +2371,13 @@ func TestDefaultValueDecoders(t *testing.T) {
 					doc = bsoncore.AppendCodeWithScopeElement(doc, "au",
 						"var hello = 'world';", buildDocument(bsoncore.AppendDoubleElement(nil, "pi", 3.14159)),
 					)
+					for _, name := range [5]string{"av", "aw", "ax", "ay", "az"} {
+						doc = bsoncore.AppendDocumentElement(doc, name, buildDocument(
+							bsoncore.AppendDocumentElement(nil, "foo", buildDocument(
+								bsoncore.AppendStringElement(nil, "bar", "baz"),
+							)),
+						))
+					}
 					return doc
 				}(nil)),
 				nil,
@@ -2576,11 +2593,6 @@ func TestDefaultValueDecoders(t *testing.T) {
 					string("foo bar baz"),
 					bsontype.String,
 				},
-				{
-					"Embedded Document - primitive.D",
-					primitive.D{{"foo", nil}},
-					bsontype.EmbeddedDocument,
-				},
 				{
 					"Array - primitive.A",
 					primitive.A{3.14159},

bson/bsoncodec/registry.go

@@ -191,6 +191,12 @@ func (rb *RegistryBuilder) RegisterDefaultDecoder(kind reflect.Kind, dec ValueDe
 // RegisterTypeMapEntry will register the provided type to the BSON type. The primary usage for this
 // mapping is decoding situations where an empty interface is used and a default type needs to be
 // created and decoded into.
+//
+// NOTE: It is unlikely that registering a type for BSON Embedded Document is actually desired. By
+// registering a type map entry for BSON Embedded Document the type registered will be used in any
+// case where a BSON Embedded Document will be decoded into an empty interface. For example, if you
+// register primitive.M, the EmptyInterface decoder will always use primitive.M, even if an ancestor
+// was a primitive.D.
 func (rb *RegistryBuilder) RegisterTypeMapEntry(bt bsontype.Type, rt reflect.Type) *RegistryBuilder {
 	rb.typeMap[bt] = rt
 	return rb