GODRIVER-1423 bson should marshal nil interfaces (#243)

Author: iwysiu

bson/bsoncodec/default_value_encoders.go

@@ -26,6 +26,8 @@ var defaultValueEncoders DefaultValueEncoders
 
 var bvwPool = bsonrw.NewBSONValueWriterPool()
 
+var errInvalidValue = errors.New("cannot encode invalid element")
+
 var sliceWriterPool = sync.Pool{
 	New: func() interface{} {
 		sw := make(bsonrw.SliceWriter, 0, 0)
@@ -301,16 +303,24 @@ func (dve DefaultValueEncoders) mapEncodeValue(ec EncodeContext, dw bsonrw.Docum
 			return fmt.Errorf("Key %s of inlined map conflicts with a struct field name", key)
 		}
 
-		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.MapIndex(key))
-		if err != nil {
-			return err
+		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.MapIndex(key))
+		if lookupErr != nil && lookupErr != errInvalidValue {
+			return lookupErr
 		}
 
 		vw, err := dw.WriteDocumentElement(key.String())
 		if err != nil {
 			return err
 		}
 
+		if lookupErr == errInvalidValue {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
 		if enc, ok := currEncoder.(ValueEncoder); ok {
 			err = enc.EncodeValue(ec, vw, currVal)
 			if err != nil {
@@ -363,16 +373,24 @@ func (dve DefaultValueEncoders) ArrayEncodeValue(ec EncodeContext, vw bsonrw.Val
 	}
 
 	for idx := 0; idx < val.Len(); idx++ {
-		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
-		if err != nil {
-			return err
+		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
+		if lookupErr != nil && lookupErr != errInvalidValue {
+			return lookupErr
 		}
 
 		vw, err := aw.WriteArrayElement()
 		if err != nil {
 			return err
 		}
 
+		if lookupErr == errInvalidValue {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
 		err = currEncoder.EncodeValue(ec, vw, currVal)
 		if err != nil {
 			return err
@@ -422,16 +440,24 @@ func (dve DefaultValueEncoders) SliceEncodeValue(ec EncodeContext, vw bsonrw.Val
 	}
 
 	for idx := 0; idx < val.Len(); idx++ {
-		currEncoder, currVal, err := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
-		if err != nil {
-			return err
+		currEncoder, currVal, lookupErr := dve.lookupElementEncoder(ec, encoder, val.Index(idx))
+		if lookupErr != nil && lookupErr != errInvalidValue {
+			return lookupErr
 		}
 
 		vw, err := aw.WriteArrayElement()
 		if err != nil {
 			return err
 		}
 
+		if lookupErr == errInvalidValue {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
 		err = currEncoder.EncodeValue(ec, vw, currVal)
 		if err != nil {
 			return err
@@ -446,7 +472,7 @@ func (dve DefaultValueEncoders) lookupElementEncoder(ec EncodeContext, origEncod
 	}
 	currVal = currVal.Elem()
 	if !currVal.IsValid() {
-		return nil, currVal, fmt.Errorf("cannot encode invalid element")
+		return nil, currVal, errInvalidValue
 	}
 	currEncoder, err := ec.LookupEncoder(currVal.Type())
 

bson/bsoncodec/default_value_encoders_test.go

@@ -249,11 +249,11 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 				{
 					"Lookup Error",
-					map[string]interface{}{"foo": nil},
+					map[string]int{"foo": 1},
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteDocument,
-					fmt.Errorf("cannot encode invalid element"),
+					fmt.Errorf("no encoder found for int"),
 				},
 				{
 					"WriteDocumentElement Error",
@@ -287,6 +287,14 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteDocumentEnd,
 					nil,
 				},
+				{
+					"with interface/nil/success",
+					map[string]myInterface{"foo": nil},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteDocumentEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -311,11 +319,11 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 				{
 					"Lookup Error",
-					[1]interface{}{},
+					[1]int{1},
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteArray,
-					fmt.Errorf("cannot encode invalid element"),
+					fmt.Errorf("no encoder found for int"),
 				},
 				{
 					"WriteArrayElement Error",
@@ -357,6 +365,14 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteArrayEnd,
 					nil,
 				},
+				{
+					"[1]interface/nil/success",
+					[1]myInterface{nil},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteArrayEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -381,11 +397,11 @@ func TestDefaultValueEncoders(t *testing.T) {
 				},
 				{
 					"Lookup Error",
-					[]interface{}{nil},
+					[]int{1},
 					&EncodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.WriteArray,
-					fmt.Errorf("cannot encode invalid element"),
+					fmt.Errorf("no encoder found for int"),
 				},
 				{
 					"WriteArrayElement Error",
@@ -435,6 +451,14 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteArrayEnd,
 					nil,
 				},
+				{
+					"interface/success",
+					[]myInterface{nil},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteArrayEnd,
+					nil,
+				},
 			},
 		},
 		{
@@ -935,6 +959,14 @@ func TestDefaultValueEncoders(t *testing.T) {
 					bsonrwtest.WriteDocumentEnd,
 					nil,
 				},
+				{
+					"nil interface value",
+					struct{ Foo myInterface }{Foo: nil},
+					&EncodeContext{Registry: buildDefaultRegistry()},
+					nil,
+					bsonrwtest.WriteDocumentEnd,
+					nil,
+				},
 			},
 		},
 		{

bson/bsoncodec/struct_codec.go

@@ -98,6 +98,25 @@ func (sc *StructCodec) EncodeValue(r EncodeContext, vw bsonrw.ValueWriter, val r
 
 		desc.encoder, rv, err = defaultValueEncoders.lookupElementEncoder(r, desc.encoder, rv)
 
+		if err != nil && err != errInvalidValue {
+			return err
+		}
+
+		if err == errInvalidValue {
+			if desc.omitEmpty {
+				continue
+			}
+			vw2, err := dw.WriteDocumentElement(desc.name)
+			if err != nil {
+				return err
+			}
+			err = vw2.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
 		if desc.encoder == nil {
 			return ErrNoEncoder{Type: rv.Type()}
 		}