GODRIVER-3455 Order LookupEncoder correctly

Author: prestonvasquez

bson/default_value_encoders.go

@@ -63,6 +63,7 @@ func registerDefaultEncoders(reg *Registry) {
 	// Register the reflect-free default type encoders.
 	reg.registerReflectFreeTypeEncoder(tByteSlice, byteSliceEncodeValueRF(false))
 	reg.registerReflectFreeTypeEncoder(tTime, reflectFreeValueEncoderFunc(timeEncodeValueRF))
+	reg.registerReflectFreeTypeEncoder(tEmpty, reflectFreeValueEncoderFunc(emptyInterfaceValueRF))
 	reg.registerReflectFreeTypeEncoder(tCoreArray, reflectFreeValueEncoderFunc(coreArrayEncodeValueRF))
 	reg.registerReflectFreeTypeEncoder(tNull, reflectFreeValueEncoderFunc(nullEncodeValueX))
 	reg.registerReflectFreeTypeEncoder(tOID, reflectFreeValueEncoderFunc(objectIDEncodeValueX))
@@ -89,7 +90,7 @@ func registerDefaultEncoders(reg *Registry) {
 	//
 	reg.RegisterTypeEncoder(tByteSlice, byteSliceEncodeValue(false))
 	reg.RegisterTypeEncoder(tTime, defaultValueEncoderFunc(timeEncodeValue))
-	reg.RegisterTypeEncoder(tEmpty, &emptyInterfaceCodec{}) // TODO: extend this to reflection free
+	reg.RegisterTypeEncoder(tEmpty, defaultValueEncoderFunc(emptyInterfaceValue)) // TODO: extend this to reflection free
 	reg.RegisterTypeEncoder(tCoreArray, defaultValueEncoderFunc(coreArrayEncodeValue))
 	reg.RegisterTypeEncoder(tOID, defaultValueEncoderFunc(objectIDEncodeValue))
 	reg.RegisterTypeEncoder(tDecimal, defaultValueEncoderFunc(decimal128EncodeValue))
@@ -258,10 +259,6 @@ func jsonNumberEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value)
 }
 
 func jsonNumberEncodeValueX(ec EncodeContext, vw ValueWriter, val any) error {
-	//if !val.IsValid() || val.Type() != tJSONNumber {
-	//	return ValueEncoderError{Name: "JSONNumberEncodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
-	//}
-	//jsnum := val.Interface().(json.Number)
 	jsnum, ok := val.(json.Number)
 	if !ok {
 		return ValueEncoderError{Name: "JSONNumberEncodeValue", Types: []reflect.Type{tJSONNumber}, Received: reflect.ValueOf(val)}
@@ -708,7 +705,6 @@ func codeWithScopeEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Valu
 	scopeVW.reset(scopeVW.buf[:0])
 	scopeVW.w = sw
 	defer bvwPool.Put(scopeVW)
-
 	encoder, err := ec.LookupEncoder(reflect.TypeOf(cws.Scope))
 	if err != nil {
 		return err
@@ -745,7 +741,6 @@ func codeWithScopeEncodeValueX(ec EncodeContext, vw ValueWriter, val any) error
 	scopeVW.reset(scopeVW.buf[:0])
 	scopeVW.w = sw
 	defer bvwPool.Put(scopeVW)
-
 	encoder, err := ec.LookupEncoder(reflect.TypeOf(cws.Scope))
 	if err != nil {
 		return err
@@ -823,3 +818,19 @@ func coreArrayEncodeValueRF(ec EncodeContext, vw ValueWriter, val any) error {
 func coreArrayEncodeValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
 	return coreArrayEncodeValueRF(ec, vw, val.Interface())
 }
+
+func emptyInterfaceValueRF(ec EncodeContext, vw ValueWriter, val any) error {
+	if val == nil {
+		return vw.WriteNull()
+	}
+	encoder, err := ec.LookupEncoder(reflect.TypeOf(val))
+	if err != nil {
+		return err
+	}
+
+	return encoder.EncodeValue(ec, vw, reflect.ValueOf(val))
+}
+
+func emptyInterfaceValue(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+	return emptyInterfaceValueRF(ec, vw, val.Interface())
+}

bson/mgoregistry.go

@@ -44,7 +44,6 @@ func NewMgoRegistry() *Registry {
 	reg.RegisterKindDecoder(reflect.String, ValueDecoderFunc(mgoStringDecodeValue))
 	reg.RegisterKindDecoder(reflect.Struct, structCodec)
 	reg.RegisterKindDecoder(reflect.Map, mapCodec)
-	//reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: true})
 	reg.RegisterKindEncoder(reflect.Struct, structCodec)
 	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{encodeNilAsEmpty: true})
 	reg.RegisterKindEncoder(reflect.Map, mapCodec)
@@ -74,7 +73,6 @@ func NewRespectNilValuesMgoRegistry() *Registry {
 	reg.registerReflectFreeTypeEncoder(tByteSlice, byteSliceEncodeValueRF(false))
 
 	reg.RegisterKindDecoder(reflect.Map, mapCodec)
-	//reg.RegisterTypeEncoder(tByteSlice, &byteSliceCodec{encodeNilAsEmpty: false})
 	reg.RegisterKindEncoder(reflect.Slice, &sliceCodec{})
 	reg.RegisterKindEncoder(reflect.Map, mapCodec)
 	return reg

bson/registry.go

@@ -7,15 +7,10 @@
 package bson
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
-	"net/url"
 	"reflect"
 	"sync"
-	"time"
-
-	"go.mongodb.org/mongo-driver/v2/x/bsonx/bsoncore"
 )
 
 // defaultRegistry is the default Registry. It contains the default codecs and the
@@ -246,130 +241,6 @@ func (r *Registry) RegisterTypeMapEntry(bt Type, rt reflect.Type) {
 	r.typeMap.Store(bt, rt)
 }
 
-func getReflectTypeFromAny(val any) (reflect.Type, error) {
-	switch v := val.(type) {
-	case bool:
-		return tBool, nil
-	case float64:
-		return tFloat64, nil
-	case int32:
-		return tInt32, nil
-	case int64:
-		return tInt64, nil
-	case string:
-		return tString, nil
-	case time.Time:
-		return tTime, nil
-	case interface{}:
-		return tEmpty, nil
-	case []byte:
-		return tByteSlice, nil
-	case byte:
-		return tByte, nil
-	case url.URL:
-		return tURL, nil
-	case json.Number:
-		return tJSONNumber, nil
-	case ValueMarshaler:
-		return tValueMarshaler, nil
-	case ValueUnmarshaler:
-		return tValueUnmarshaler, nil
-	case Marshaler:
-		return tMarshaler, nil
-	case Unmarshaler:
-		return tUnmarshaler, nil
-	case Zeroer:
-		return tZeroer, nil
-	case Binary:
-		return tBinary, nil
-	case Undefined:
-		return tUndefined, nil
-	case ObjectID:
-		return tOID, nil
-	case DateTime:
-		return tDateTime, nil
-	case Null:
-		return tNull, nil
-	case Regex:
-		return tRegex, nil
-	case CodeWithScope:
-		return tCodeWithScope, nil
-	case DBPointer:
-		return tDBPointer, nil
-	case JavaScript:
-		return tJavaScript, nil
-	case Symbol:
-		return tSymbol, nil
-	case Timestamp:
-		return tTimestamp, nil
-	case Decimal128:
-		return tDecimal, nil
-	case Vector:
-		return tVector, nil
-	case MinKey:
-		return tMinKey, nil
-	case MaxKey:
-		return tMaxKey, nil
-	case D:
-		return tD, nil
-	case A:
-		return tA, nil
-	case E:
-		return tE, nil
-	case bsoncore.Document:
-		return tCoreDocument, nil
-	case bsoncore.Array:
-		return tCoreArray, nil
-	default:
-		return nil, fmt.Errorf("no default encoder for type %T", v)
-	}
-}
-
-//func lookupReflectFreeEncoder(r *Registry, typ reflect.Type) (reflectFreeValueEncoder, error) {
-//}
-
-func lookupEncoderReflectFree(r *Registry, typ reflect.Type, val any) (reflectFreeValueEncoder, error) {
-	if typ == nil {
-		var err error
-
-		typ, err = getReflectTypeFromAny(val)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	rfeEnc, found := r.reflectFreeTypeEncoders.Load(typ)
-	if !found {
-		return nil, errNoEncoder{Type: typ}
-	}
-
-	return rfeEnc, nil
-}
-
-func lookupUserDefinedEncoder(r *Registry, val any) (ValueEncoder, reflect.Type, bool, error) {
-	typ, err := getReflectTypeFromAny(val)
-	if err != nil {
-		return nil, nil, false, err
-	}
-
-	enc, found := r.lookupTypeEncoder(typ)
-	if found {
-		if enc == nil {
-			return nil, typ, false, errNoEncoder{Type: typ}
-		}
-
-		// We do not use ValueEncoder in the default case, preferring a reflect-free
-		// solution.
-		if _, ok := enc.(defaultValueEncoderFunc); ok {
-			return nil, typ, false, nil
-		}
-
-		return enc, typ, true, nil
-	}
-
-	return nil, typ, false, nil
-}
-
 // LookupEncoder returns the first matching encoder in the Registry. It uses the following lookup
 // order:
 //
@@ -392,30 +263,27 @@ func (r *Registry) LookupEncoder(valueType reflect.Type) (ValueEncoder, error) {
 		return nil, errNoEncoder{Type: valueType}
 	}
 
-	// First attempt to lookup a reflect-free default encoder.
-	// TODO: This will be moved in favor of the lookup* solution.
-	rfeEnc, found := r.reflectFreeTypeEncoders.Load(valueType)
-	if found {
-		if rfeEnc != nil {
-			wrapper := func(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
-				return rfeEnc.EncodeValue(ec, vw, val.Interface())
-			}
+	// First attempt to get a user-defined type encoder.
+	if enc, found := r.lookupTypeEncoder(valueType); found {
+		if enc == nil {
+			return nil, errNoEncoder{Type: valueType}
+		}
 
-			return ValueEncoderFunc(wrapper), nil
+		if _, ok := enc.(defaultValueEncoderFunc); !ok {
+			return enc, nil
 		}
 	}
 
-	// Then lookup a user-defined encoder.
-	enc, found := r.lookupTypeEncoder(valueType)
-	if found {
-		if enc == nil {
-			return nil, errNoEncoder{Type: valueType}
+	// Next try to get a reflection-free encoder.
+	if rfeEnc, found := r.reflectFreeTypeEncoders.Load(valueType); found && rfeEnc != nil {
+		wrapper := func(ec EncodeContext, vw ValueWriter, val reflect.Value) error {
+			return rfeEnc.EncodeValue(ec, vw, val.Interface())
 		}
-		return enc, nil
+
+		return ValueEncoderFunc(wrapper), nil
 	}
 
-	enc, found = r.lookupInterfaceEncoder(valueType, true)
-	if found {
+	if enc, found := r.lookupInterfaceEncoder(valueType, true); found {
 		return r.typeEncoders.LoadOrStore(valueType, enc), nil
 	}