GODRIVER-3924 Fix bug of unmarshaling null.

bson/array_codec.go

@@ -31,8 +31,16 @@ func (ac *arrayCodec) DecodeValue(_ DecodeContext, vr ValueReader, val reflect.V
 	if !val.CanSet() || val.Type() != tCoreArray {
 		return ValueDecoderError{Name: "CoreArrayDecodeValue", Types: []reflect.Type{tCoreArray}, Received: val}
 	}
-	if vrType := vr.Type(); vrType != TypeArray {
-		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
+	switch vr.Type() {
+	case TypeArray:
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	default:
+		return fmt.Errorf("cannot decode %v into a %s", vr.Type(), val.Type())
 	}
 
 	if val.IsNil() {

bson/default_value_decoders.go

@@ -119,6 +119,9 @@ func dDecodeValue(dc DecodeContext, vr ValueReader, val reflect.Value) error {
 	case TypeNull:
 		val.Set(reflect.Zero(val.Type()))
 		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
 	default:
 		return fmt.Errorf("cannot decode %v into a D", vrType)
 	}
@@ -1310,9 +1313,15 @@ func coreDocumentDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value)
 	if !val.CanSet() || val.Type() != tCoreDocument {
 		return ValueDecoderError{Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
 	}
-	vrType := vr.Type()
-	isDocument := vrType == Type(0) || vrType == TypeEmbeddedDocument || vrType == TypeArray
-	if !isDocument {
+	switch vrType := vr.Type(); vrType {
+	case Type(0), TypeEmbeddedDocument, TypeArray:
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	default:
 		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
 	}
 

bson/default_value_decoders_test.go

@@ -2302,6 +2302,22 @@ func TestDefaultValueDecoders(t *testing.T) {
 					readDocument,
 					errors.New("copy error"),
 				},
+				{
+					"decode null",
+					bsoncore.Document(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeNull},
+					readNull,
+					nil,
+				},
+				{
+					"decode undefined",
+					bsoncore.Document(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeUndefined},
+					readUndefined,
+					nil,
+				},
 			},
 		},
 		{
@@ -2423,6 +2439,22 @@ func TestDefaultValueDecoders(t *testing.T) {
 						Received: reflect.New(reflect.TypeOf((*bsoncore.Array)(nil))).Elem(),
 					},
 				},
+				{
+					"decode null",
+					bsoncore.Array(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeNull},
+					readNull,
+					nil,
+				},
+				{
+					"decode undefined",
+					bsoncore.Array(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeUndefined},
+					readUndefined,
+					nil,
+				},
 			},
 		},
 	}

bson/primitive_codecs.go

@@ -78,9 +78,15 @@ func rawDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value) error {
 	if !val.CanSet() || val.Type() != tRaw {
 		return ValueDecoderError{Name: "RawDecodeValue", Types: []reflect.Type{tRaw}, Received: val}
 	}
-	vrType := vr.Type()
-	isDocument := vrType == Type(0) || vrType == TypeEmbeddedDocument || vrType == TypeArray
-	if !isDocument {
+	switch vrType := vr.Type(); vrType {
+	case Type(0), TypeEmbeddedDocument, TypeArray:
+	case TypeNull:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	case TypeUndefined:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadUndefined()
+	default:
 		return fmt.Errorf("cannot decode %v into a %s", vrType, val.Type())
 	}
 

bson/primitive_codecs_test.go

@@ -574,6 +574,22 @@ func TestPrimitiveValueDecoders(t *testing.T) {
 					readDocument,
 					errors.New("copy error"),
 				},
+				{
+					"decode null",
+					Raw(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeNull},
+					readNull,
+					nil,
+				},
+				{
+					"decode undefined",
+					Raw(nil),
+					nil,
+					&valueReaderWriter{BSONType: TypeUndefined},
+					readUndefined,
+					nil,
+				},
 			},
 		},
 	}

bson/unmarshal_test.go

@@ -931,5 +931,55 @@ func TestUnmarshalTypeCompatibility(t *testing.T) {
 			assert.NoError(t, err)
 			assert.Equal(t, want, []byte(val.Foo))
 		})
+		t.Run("bson.D into bson.Raw", func(t *testing.T) {
+			t.Parallel()
+
+			data := docToBytes(D{{"foo", D{{"bar", int32(42)}}}})
+			want := []byte(bsoncore.NewDocumentBuilder().AppendInt32("bar", 42).Build())
+
+			var val struct {
+				Foo Raw
+			}
+
+			err := Unmarshal(data, &val)
+			assert.NoError(t, err)
+			assert.Equal(t, want, []byte(val.Foo))
+		})
+		t.Run("nil into bson.Raw", func(t *testing.T) {
+			t.Parallel()
+
+			data := docToBytes(D{{"foo", nil}})
+
+			var val struct {
+				Foo Raw
+			}
+			err := Unmarshal(data, &val)
+			assert.NoError(t, err)
+			assert.Nil(t, val.Foo)
+		})
+		t.Run("nil into bsoncore.Document", func(t *testing.T) {
+			t.Parallel()
+
+			data := docToBytes(D{{"foo", nil}})
+
+			var val struct {
+				Foo bsoncore.Document
+			}
+			err := Unmarshal(data, &val)
+			assert.NoError(t, err)
+			assert.Nil(t, val.Foo)
+		})
+		t.Run("nil into bsoncore.Array", func(t *testing.T) {
+			t.Parallel()
+
+			data := docToBytes(D{{"foo", nil}})
+
+			var val struct {
+				Foo bsoncore.Array
+			}
+			err := Unmarshal(data, &val)
+			assert.NoError(t, err)
+			assert.Nil(t, val.Foo)
+		})
 	})
 }