GODRIVER-2976 Remove deprecated BSON code.

bson/bson_test.go

@@ -30,28 +30,6 @@ func noerr(t *testing.T, err error) {
 	}
 }
 
-func TestCompareTimestamp(t *testing.T) {
-	testcases := []struct {
-		name     string
-		tp       Timestamp
-		tp2      Timestamp
-		expected int
-	}{
-		{"equal", Timestamp{T: 12345, I: 67890}, Timestamp{T: 12345, I: 67890}, 0},
-		{"T greater than", Timestamp{T: 12345, I: 67890}, Timestamp{T: 2345, I: 67890}, 1},
-		{"I greater than", Timestamp{T: 12345, I: 67890}, Timestamp{T: 12345, I: 7890}, 1},
-		{"T less than", Timestamp{T: 12345, I: 67890}, Timestamp{T: 112345, I: 67890}, -1},
-		{"I less than", Timestamp{T: 12345, I: 67890}, Timestamp{T: 12345, I: 167890}, -1},
-	}
-
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := CompareTimestamp(tc.tp, tc.tp2)
-			require.Equal(t, tc.expected, result)
-		})
-	}
-}
-
 func TestTimestamp(t *testing.T) {
 	t.Parallel()
 

bson/cond_addr_codec.go

@@ -32,7 +32,7 @@ func (cae *condAddrEncoder) EncodeValue(ec EncodeContext, vw ValueWriter, val re
 	if cae.elseEnc != nil {
 		return cae.elseEnc.EncodeValue(ec, vw, val)
 	}
-	return ErrNoEncoder{Type: val.Type()}
+	return errNoEncoder{Type: val.Type()}
 }
 
 // condAddrDecoder is the decoder used when a pointer to the value has a decoder.
@@ -57,5 +57,5 @@ func (cad *condAddrDecoder) DecodeValue(dc DecodeContext, vr ValueReader, val re
 	if cad.elseDec != nil {
 		return cad.elseDec.DecodeValue(dc, vr, val)
 	}
-	return ErrNoDecoder{Type: val.Type()}
+	return errNoDecoder{Type: val.Type()}
 }

bson/cond_addr_codec_test.go

@@ -52,7 +52,7 @@ func TestCondAddrCodec(t *testing.T) {
 		t.Run("error", func(t *testing.T) {
 			errEncoder := newCondAddrEncoder(encode1, nil)
 			err := errEncoder.EncodeValue(EncodeContext{}, rw, unaddressable)
-			want := ErrNoEncoder{Type: unaddressable.Type()}
+			want := errNoEncoder{Type: unaddressable.Type()}
 			assert.Equal(t, err, want, "expected error %v, got %v", want, err)
 		})
 	})
@@ -88,7 +88,7 @@ func TestCondAddrCodec(t *testing.T) {
 		t.Run("error", func(t *testing.T) {
 			errDecoder := newCondAddrDecoder(decode1, nil)
 			err := errDecoder.DecodeValue(DecodeContext{}, rw, unaddressable)
-			want := ErrNoDecoder{Type: unaddressable.Type()}
+			want := errNoDecoder{Type: unaddressable.Type()}
 			assert.Equal(t, err, want, "expected error %v, got %v", want, err)
 		})
 	})

bson/copier.go

@@ -15,9 +15,6 @@ import (
 )
 
 // copyDocument handles copying one document from the src to the dst.
-//
-// Deprecated: Copying BSON documents using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyDocument(dst ValueWriter, src ValueReader) error {
 	dr, err := src.ReadDocument()
 	if err != nil {
@@ -34,9 +31,6 @@ func copyDocument(dst ValueWriter, src ValueReader) error {
 
 // copyArrayFromBytes copies the values from a BSON array represented as a
 // []byte to a ValueWriter.
-//
-// Deprecated: Copying BSON arrays using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyArrayFromBytes(dst ValueWriter, src []byte) error {
 	aw, err := dst.WriteArray()
 	if err != nil {
@@ -53,9 +47,6 @@ func copyArrayFromBytes(dst ValueWriter, src []byte) error {
 
 // copyDocumentFromBytes copies the values from a BSON document represented as a
 // []byte to a ValueWriter.
-//
-// Deprecated: Copying BSON documents using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyDocumentFromBytes(dst ValueWriter, src []byte) error {
 	dw, err := dst.WriteDocument()
 	if err != nil {
@@ -74,9 +65,6 @@ type writeElementFn func(key string) (ValueWriter, error)
 
 // copyBytesToArrayWriter copies the values from a BSON Array represented as a []byte to an
 // ArrayWriter.
-//
-// Deprecated: Copying BSON arrays using the ArrayWriter interface will not be supported in Go
-// Driver 2.0.
 func copyBytesToArrayWriter(dst ArrayWriter, src []byte) error {
 	wef := func(_ string) (ValueWriter, error) {
 		return dst.WriteArrayElement()
@@ -87,9 +75,6 @@ func copyBytesToArrayWriter(dst ArrayWriter, src []byte) error {
 
 // copyBytesToDocumentWriter copies the values from a BSON document represented as a []byte to a
 // DocumentWriter.
-//
-// Deprecated: Copying BSON documents using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyBytesToDocumentWriter(dst DocumentWriter, src []byte) error {
 	wef := func(key string) (ValueWriter, error) {
 		return dst.WriteDocumentElement(key)
@@ -149,18 +134,12 @@ func copyBytesToValueWriter(src []byte, wef writeElementFn) error {
 
 // copyDocumentToBytes copies an entire document from the ValueReader and
 // returns it as bytes.
-//
-// Deprecated: Copying BSON documents using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyDocumentToBytes(src ValueReader) ([]byte, error) {
 	return appendDocumentBytes(nil, src)
 }
 
 // appendDocumentBytes functions the same as CopyDocumentToBytes, but will
 // append the result to dst.
-//
-// Deprecated: Copying BSON documents using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func appendDocumentBytes(dst []byte, src ValueReader) ([]byte, error) {
 	if br, ok := src.(bytesReader); ok {
 		_, dst, err := br.readValueBytes(dst)
@@ -178,9 +157,6 @@ func appendDocumentBytes(dst []byte, src ValueReader) ([]byte, error) {
 }
 
 // appendArrayBytes copies an array from the ValueReader to dst.
-//
-// Deprecated: Copying BSON arrays using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func appendArrayBytes(dst []byte, src ValueReader) ([]byte, error) {
 	if br, ok := src.(bytesReader); ok {
 		_, dst, err := br.readValueBytes(dst)
@@ -198,8 +174,6 @@ func appendArrayBytes(dst []byte, src ValueReader) ([]byte, error) {
 }
 
 // copyValueFromBytes will write the value represtend by t and src to dst.
-//
-// Deprecated: Use [go.mongodb.org/mongo-driver/bson.UnmarshalValue] instead.
 func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
 	if wvb, ok := dst.(bytesWriter); ok {
 		return wvb.writeValueBytes(t, src)
@@ -214,44 +188,28 @@ func copyValueFromBytes(dst ValueWriter, t Type, src []byte) error {
 	return copyValue(dst, vr)
 }
 
-// CopyValueToBytes copies a value from src and returns it as a Type and a
+// copyValueToBytes copies a value from src and returns it as a Type and a
 // []byte.
-//
-// Deprecated: Use [go.mongodb.org/mongo-driver/bson.MarshalValue] instead.
-func CopyValueToBytes(src ValueReader) (Type, []byte, error) {
-	return appendValueBytes(nil, src)
-}
-
-// appendValueBytes functions the same as CopyValueToBytes, but will append the
-// result to dst.
-//
-// Deprecated: Appending individual BSON elements to an existing slice will not be supported in Go
-// Driver 2.0.
-func appendValueBytes(dst []byte, src ValueReader) (Type, []byte, error) {
+func copyValueToBytes(src ValueReader) (Type, []byte, error) {
 	if br, ok := src.(bytesReader); ok {
-		return br.readValueBytes(dst)
+		return br.readValueBytes(nil)
 	}
 
 	vw := vwPool.Get().(*valueWriter)
 	defer putValueWriter(vw)
 
-	start := len(dst)
-
-	vw.reset(dst)
+	vw.reset(nil)
 	vw.push(mElement)
 
 	err := copyValue(vw, src)
 	if err != nil {
-		return 0, dst, err
+		return 0, nil, err
 	}
 
-	return Type(vw.buf[start]), vw.buf[start+2:], nil
+	return Type(vw.buf[0]), vw.buf[2:], nil
 }
 
 // copyValue will copy a single value from src to dst.
-//
-// Deprecated: Copying BSON values using the ValueWriter and ValueReader interfaces will not be
-// supported in Go Driver 2.0.
 func copyValue(dst ValueWriter, src ValueReader) error {
 	var err error
 	switch src.Type() {
@@ -461,3 +419,15 @@ func copyDocumentCore(dw DocumentWriter, dr DocumentReader) error {
 
 	return dw.WriteDocumentEnd()
 }
+
+// bytesReader is the interface used to read BSON bytes from a valueReader.
+//
+// The bytes of the value will be appended to dst.
+type bytesReader interface {
+	readValueBytes(dst []byte) (Type, []byte, error)
+}
+
+// bytesWriter is the interface used to write BSON bytes to a valueWriter.
+type bytesWriter interface {
+	writeValueBytes(t Type, b []byte) error
+}

bson/copier_test.go

@@ -455,7 +455,7 @@ func TestCopier(t *testing.T) {
 			noerr(t, err)
 			_, _, err = vr.ReadElement()
 			noerr(t, err)
-			btype, got, err := CopyValueToBytes(vr)
+			btype, got, err := copyValueToBytes(vr)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "world")
 			if btype != TypeString {
@@ -467,7 +467,7 @@ func TestCopier(t *testing.T) {
 		})
 		t.Run("Non BytesReader", func(t *testing.T) {
 			llvrw := &TestValueReaderWriter{t: t, bsontype: TypeString, readval: "Hello, world!"}
-			btype, got, err := CopyValueToBytes(llvrw)
+			btype, got, err := copyValueToBytes(llvrw)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "Hello, world!")
 			if btype != TypeString {
@@ -478,51 +478,4 @@ func TestCopier(t *testing.T) {
 			}
 		})
 	})
-	t.Run("AppendValueBytes", func(t *testing.T) {
-		t.Run("BytesReader", func(t *testing.T) {
-			var idx int32
-			b, err := bsoncore.AppendDocumentEnd(
-				bsoncore.AppendStringElement(
-					bsoncore.AppendDocumentStartInline(nil, &idx),
-					"hello", "world",
-				),
-				idx,
-			)
-			noerr(t, err)
-			vr := newValueReader(b)
-			_, err = vr.ReadDocument()
-			noerr(t, err)
-			_, _, err = vr.ReadElement()
-			noerr(t, err)
-			btype, got, err := appendValueBytes(nil, vr)
-			noerr(t, err)
-			want := bsoncore.AppendString(nil, "world")
-			if btype != TypeString {
-				t.Errorf("Incorrect type returned. got %v; want %v", btype, TypeString)
-			}
-			if !bytes.Equal(got, want) {
-				t.Errorf("Bytes do not match. got %v; want %v", got, want)
-			}
-		})
-		t.Run("Non BytesReader", func(t *testing.T) {
-			llvrw := &TestValueReaderWriter{t: t, bsontype: TypeString, readval: "Hello, world!"}
-			btype, got, err := appendValueBytes(nil, llvrw)
-			noerr(t, err)
-			want := bsoncore.AppendString(nil, "Hello, world!")
-			if btype != TypeString {
-				t.Errorf("Incorrect type returned. got %v; want %v", btype, TypeString)
-			}
-			if !bytes.Equal(got, want) {
-				t.Errorf("Bytes do not match. got %v; want %v", got, want)
-			}
-		})
-		t.Run("CopyValue error", func(t *testing.T) {
-			want := errors.New("CopyValue error")
-			llvrw := &TestValueReaderWriter{t: t, bsontype: TypeString, err: want, errAfter: llvrwReadString}
-			_, _, got := appendValueBytes(make([]byte, 0), llvrw)
-			if !assert.CompareErrors(got, want) {
-				t.Errorf("Errors do not match. got %v; want %v", got, want)
-			}
-		})
-	})
 }

bson/decoder_test.go

@@ -224,7 +224,7 @@ func TestDecoderv2(t *testing.T) {
 
 			cdeih := func(string, string) string { return "certainlydoesntexistelsewhereihope" }
 			dec := NewDecoder(NewValueReader([]byte{}))
-			want := ErrNoDecoder{Type: reflect.TypeOf(cdeih)}
+			want := errNoDecoder{Type: reflect.TypeOf(cdeih)}
 			got := dec.Decode(&cdeih)
 			assert.Equal(t, want, got, "Received unexpected error.")
 		})

bson/default_value_decoders.go

@@ -1180,7 +1180,7 @@ func valueUnmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Va
 		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
 	}
 
-	t, src, err := CopyValueToBytes(vr)
+	t, src, err := copyValueToBytes(vr)
 	if err != nil {
 		return err
 	}
@@ -1206,7 +1206,7 @@ func unmarshalerDecodeValue(_ DecodeContext, vr ValueReader, val reflect.Value)
 		val.Set(reflect.New(val.Type().Elem()))
 	}
 
-	_, src, err := CopyValueToBytes(vr)
+	_, src, err := copyValueToBytes(vr)
 	if err != nil {
 		return err
 	}

bson/default_value_decoders_test.go

@@ -818,7 +818,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: newTestRegistry()},
 					&valueReaderWriter{},
 					readDocument,
-					ErrNoDecoder{Type: reflect.TypeOf("")},
+					errNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadElement Error",
@@ -904,7 +904,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: newTestRegistry()},
 					&valueReaderWriter{BSONType: TypeArray},
 					readArray,
-					ErrNoDecoder{Type: reflect.TypeOf("")},
+					errNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadValue Error",
@@ -998,7 +998,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: newTestRegistry()},
 					&valueReaderWriter{BSONType: TypeArray},
 					readArray,
-					ErrNoDecoder{Type: reflect.TypeOf("")},
+					errNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadValue Error",
@@ -1558,7 +1558,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 				},
 				{
 					"No Decoder", &wrong, &DecodeContext{Registry: buildDefaultRegistry()}, nil, nothing,
-					ErrNoDecoder{Type: reflect.TypeOf(wrong)},
+					errNoDecoder{Type: reflect.TypeOf(wrong)},
 				},
 				{
 					"decode null",
@@ -3307,7 +3307,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 						}
 						val := reflect.New(tEmpty).Elem()
 						dc := DecodeContext{Registry: newTestRegistry()}
-						want := ErrNoTypeMapEntry{Type: tc.bsontype}
+						want := errNoTypeMapEntry{Type: tc.bsontype}
 						got := (&emptyInterfaceCodec{}).DecodeValue(dc, llvr, val)
 						if !assert.CompareErrors(got, want) {
 							t.Errorf("Errors are not equal. got %v; want %v", got, want)
@@ -3324,7 +3324,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 						dc := DecodeContext{
 							Registry: reg,
 						}
-						want := ErrNoDecoder{Type: reflect.TypeOf(tc.val)}
+						want := errNoDecoder{Type: reflect.TypeOf(tc.val)}
 						got := (&emptyInterfaceCodec{}).DecodeValue(dc, llvr, val)
 						if !assert.CompareErrors(got, want) {
 							t.Errorf("Errors are not equal. got %v; want %v", got, want)
@@ -3389,7 +3389,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 
 		t.Run("no type registered", func(t *testing.T) {
 			llvr := &valueReaderWriter{BSONType: TypeDouble}
-			want := ErrNoTypeMapEntry{Type: TypeDouble}
+			want := errNoTypeMapEntry{Type: TypeDouble}
 			val := reflect.New(tEmpty).Elem()
 			got := (&emptyInterfaceCodec{}).DecodeValue(DecodeContext{Registry: newTestRegistry()}, llvr, val)
 			if !assert.CompareErrors(got, want) {
@@ -3538,7 +3538,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 		}
 		stringStructErr := &DecodeError{
 			keys:    []string{"foo"},
-			wrapped: ErrNoDecoder{reflect.TypeOf("")},
+			wrapped: errNoDecoder{reflect.TypeOf("")},
 		}
 
 		// Test a deeply nested struct mixed with maps and slices.