GODRIVER-1682 - Use typeDecoder in recursive decoders

Author: Divjot Arora

bson/bsoncodec/bsoncodec.go

@@ -184,12 +184,28 @@ var _ typeDecoder = decodeAdapter{}
 // decodeTypeOrValue calls decoder.decodeType is decoder is a typeDecoder. Otherwise, it allocates a new element of type
 // t and calls decoder.DecodeValue on it.
 func decodeTypeOrValue(decoder ValueDecoder, dc DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
-	if typeDecoder, ok := decoder.(typeDecoder); ok {
-		return typeDecoder.decodeType(dc, vr, t)
+	td, _ := decoder.(typeDecoder)
+	return decodeTypeOrValueWithInfo(decoder, td, dc, vr, t, true)
+}
+
+func decodeTypeOrValueWithInfo(vd ValueDecoder, td typeDecoder, dc DecodeContext, vr bsonrw.ValueReader, t reflect.Type, convert bool) (reflect.Value, error) {
+	if td != nil {
+		val, err := td.decodeType(dc, vr, t)
+		if err == nil && convert && val.Type() != t {
+			// This conversion step is necessary for slices and maps. If a user declares variables like:
+			//
+			// type myBool bool
+			// var m map[string]myBool
+			//
+			// and tries to decode BSON bytes into the map, the decoding will fail if this conversion is not present
+			// because we'll try to assign a value of type bool to one of type myBool.
+			val = val.Convert(t)
+		}
+		return val, err
 	}
 
 	val := reflect.New(t).Elem()
-	err := decoder.DecodeValue(dc, vr, val)
+	err := vd.DecodeValue(dc, vr, val)
 	return val, err
 }
 

bson/bsoncodec/default_value_decoders.go

@@ -130,7 +130,7 @@ func (dvd DefaultValueDecoders) DDecodeValue(dc DecodeContext, vr bsonrw.ValueRe
 	if err != nil {
 		return err
 	}
-	typeDecoder, isTypeDecoder := decoder.(typeDecoder)
+	tEmptyTypeDecoder, _ := decoder.(typeDecoder)
 
 	// Use the elements in the provided value if it's non nil. Otherwise, allocate a new D instance.
 	var elems primitive.D
@@ -149,17 +149,8 @@ func (dvd DefaultValueDecoders) DDecodeValue(dc DecodeContext, vr bsonrw.ValueRe
 			return err
 		}
 
-		// Delegate out to the typeDecoder for interface{} if it exists. If not, create a new interface{} value and
-		// delegate out to the ValueDecoder. This could be accomplished by calling decodeTypeOrValue, but this would
-		// require casting decoder to typeDecoder for every element. Because decoder isn't changing, we can optimize and
-		// only cast once.
-		var elem reflect.Value
-		if isTypeDecoder {
-			elem, err = typeDecoder.decodeType(dc, elemVr, tEmpty)
-		} else {
-			elem = reflect.New(tEmpty).Elem()
-			err = decoder.DecodeValue(dc, elemVr, elem)
-		}
+		// Pass false for convert because we don't need to call reflect.Value.Convert for tEmpty.
+		elem, err := decodeTypeOrValueWithInfo(decoder, tEmptyTypeDecoder, dc, elemVr, tEmpty, false)
 		if err != nil {
 			return err
 		}
@@ -1273,6 +1264,7 @@ func (dvd DefaultValueDecoders) decodeDefault(dc DecodeContext, vr bsonrw.ValueR
 	if err != nil {
 		return nil, err
 	}
+	eTypeDecoder, _ := decoder.(typeDecoder)
 
 	idx := 0
 	for {
@@ -1284,9 +1276,7 @@ func (dvd DefaultValueDecoders) decodeDefault(dc DecodeContext, vr bsonrw.ValueR
 			return nil, err
 		}
 
-		elem := reflect.New(eType).Elem()
-
-		err = decoder.DecodeValue(dc, vr, elem)
+		elem, err := decodeTypeOrValueWithInfo(decoder, eTypeDecoder, dc, vr, eType, true)
 		if err != nil {
 			return nil, newDecodeError(strconv.Itoa(idx), err)
 		}

bson/bsoncodec/map_codec.go

@@ -178,6 +178,7 @@ func (mc *MapCodec) DecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val ref
 	if err != nil {
 		return err
 	}
+	eTypeDecoder, _ := decoder.(typeDecoder)
 
 	if eType == tEmpty {
 		dc.Ancestor = val.Type()
@@ -199,8 +200,7 @@ func (mc *MapCodec) DecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val ref
 			return err
 		}
 
-		elem := reflect.New(eType).Elem()
-		err = decoder.DecodeValue(dc, vr, elem)
+		elem, err := decodeTypeOrValueWithInfo(decoder, eTypeDecoder, dc, vr, eType, true)
 		if err != nil {
 			return newDecodeError(key, err)
 		}