GODRIVER-2156 Enable unconvert linter. (#793)

Author: matthewdale

.golangci.yml

@@ -19,7 +19,7 @@ linters:
     # - structcheck
     - typecheck
     - unused
-    # - unconvert
+    - unconvert
     # - unparam
     # - varcheck
 

bson/bsoncodec/default_value_decoders_test.go

@@ -764,7 +764,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					"time.Time",
 					now,
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(now.UnixNano() / int64(time.Millisecond))},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: now.UnixNano() / int64(time.Millisecond)},
 					bsonrwtest.ReadDateTime,
 					nil,
 				},
@@ -828,7 +828,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{},
 					bsonrwtest.ReadDocument,
-					ErrNoDecoder{Type: reflect.TypeOf(string(""))},
+					ErrNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadElement Error",
@@ -914,7 +914,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array},
 					bsonrwtest.ReadArray,
-					ErrNoDecoder{Type: reflect.TypeOf(string(""))},
+					ErrNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadValue Error",
@@ -1008,7 +1008,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					&DecodeContext{Registry: NewRegistryBuilder().Build()},
 					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.Array},
 					bsonrwtest.ReadArray,
-					ErrNoDecoder{Type: reflect.TypeOf(string(""))},
+					ErrNoDecoder{Type: reflect.TypeOf("")},
 				},
 				{
 					"ReadValue Error",
@@ -1319,7 +1319,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					"type not *url.URL",
 					int64(0),
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("http://example.com")},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"},
 					bsonrwtest.Nothing,
 					ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}, Received: reflect.ValueOf(int64(0))},
 				},
@@ -1335,7 +1335,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					"url.Parse error",
 					url.URL{},
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("not-valid-%%%%://")},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "not-valid-%%%%://"},
 					bsonrwtest.ReadString,
 					&url.Error{
 						Op:  "parse",
@@ -1347,15 +1347,15 @@ func TestDefaultValueDecoders(t *testing.T) {
 					"can set false",
 					cansettest,
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("http://example.com")},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"},
 					bsonrwtest.Nothing,
 					ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}},
 				},
 				{
 					"url.URL",
 					url.URL{Scheme: "http", Host: "example.com"},
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("http://example.com")},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "http://example.com"},
 					bsonrwtest.ReadString,
 					nil,
 				},
@@ -1503,7 +1503,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 					"ValueUnmarshaler",
 					&testValueUnmarshaler{t: bsontype.String, val: bsoncore.AppendString(nil, "hello, world")},
 					nil,
-					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: string("hello, world")},
+					&bsonrwtest.ValueReaderWriter{BSONType: bsontype.String, Return: "hello, world"},
 					bsonrwtest.ReadString,
 					nil,
 				},
@@ -3202,7 +3202,7 @@ func TestDefaultValueDecoders(t *testing.T) {
 				},
 				{
 					"String - string",
-					string("foo bar baz"),
+					"foo bar baz",
 					bsontype.String,
 				},
 				{

bson/bsoncodec/map_codec.go

@@ -265,17 +265,15 @@ func (mc *MapCodec) decodeKey(key string, keyType reflect.Type) (reflect.Value,
 		case reflect.String:
 			keyVal = reflect.ValueOf(key).Convert(keyType)
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			s := string(key)
-			n, parseErr := strconv.ParseInt(s, 10, 64)
+			n, parseErr := strconv.ParseInt(key, 10, 64)
 			if parseErr != nil || reflect.Zero(keyType).OverflowInt(n) {
-				err = fmt.Errorf("failed to unmarshal number key %v", s)
+				err = fmt.Errorf("failed to unmarshal number key %v", key)
 			}
 			keyVal = reflect.ValueOf(n).Convert(keyType)
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-			s := string(key)
-			n, parseErr := strconv.ParseUint(s, 10, 64)
+			n, parseErr := strconv.ParseUint(key, 10, 64)
 			if parseErr != nil || reflect.Zero(keyType).OverflowUint(n) {
-				err = fmt.Errorf("failed to unmarshal number key %v", s)
+				err = fmt.Errorf("failed to unmarshal number key %v", key)
 				break
 			}
 			keyVal = reflect.ValueOf(n).Convert(keyType)

bson/bsoncodec/registry_test.go

@@ -377,13 +377,13 @@ func TestRegistry(t *testing.T) {
 	})
 	t.Run("Type Map", func(t *testing.T) {
 		reg := NewRegistryBuilder().
-			RegisterTypeMapEntry(bsontype.String, reflect.TypeOf(string(""))).
+			RegisterTypeMapEntry(bsontype.String, reflect.TypeOf("")).
 			RegisterTypeMapEntry(bsontype.Int32, reflect.TypeOf(int(0))).
 			Build()
 
 		var got, want reflect.Type
 
-		want = reflect.TypeOf(string(""))
+		want = reflect.TypeOf("")
 		got, err := reg.LookupTypeMapEntry(bsontype.String)
 		noerr(t, err)
 		if got != want {

bson/bsoncodec/time_codec_test.go

@@ -22,7 +22,7 @@ func TestTimeCodec(t *testing.T) {
 	now := time.Now().Truncate(time.Millisecond)
 
 	t.Run("UseLocalTimeZone", func(t *testing.T) {
-		reader := &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: int64(now.UnixNano() / int64(time.Millisecond))}
+		reader := &bsonrwtest.ValueReaderWriter{BSONType: bsontype.DateTime, Return: now.UnixNano() / int64(time.Millisecond)}
 		testCases := []struct {
 			name string
 			opts *bsonoptions.TimeCodecOptions

bson/bsonrw/copier_test.go

@@ -132,7 +132,7 @@ func TestCopier(t *testing.T) {
 			{
 				"String/dst/error",
 				&TestValueReaderWriter{bsontype: bsontype.String, err: errors.New("2"), errAfter: llvrwWriteString},
-				&TestValueReaderWriter{bsontype: bsontype.String, readval: string("hello, world")},
+				&TestValueReaderWriter{bsontype: bsontype.String, readval: "hello, world"},
 				errors.New("2"),
 			},
 			{
@@ -270,7 +270,7 @@ func TestCopier(t *testing.T) {
 			{
 				"Javascript/dst/error",
 				&TestValueReaderWriter{bsontype: bsontype.JavaScript, err: errors.New("2"), errAfter: llvrwWriteJavascript},
-				&TestValueReaderWriter{bsontype: bsontype.JavaScript, readval: string("hello, world")},
+				&TestValueReaderWriter{bsontype: bsontype.JavaScript, readval: "hello, world"},
 				errors.New("2"),
 			},
 			{
@@ -467,7 +467,7 @@ func TestCopier(t *testing.T) {
 			}
 		})
 		t.Run("Non BytesReader", func(t *testing.T) {
-			llvrw := &TestValueReaderWriter{t: t, bsontype: bsontype.String, readval: string("Hello, world!")}
+			llvrw := &TestValueReaderWriter{t: t, bsontype: bsontype.String, readval: "Hello, world!"}
 			btype, got, err := Copier{}.CopyValueToBytes(llvrw)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "Hello, world!")
@@ -506,7 +506,7 @@ func TestCopier(t *testing.T) {
 			}
 		})
 		t.Run("Non BytesReader", func(t *testing.T) {
-			llvrw := &TestValueReaderWriter{t: t, bsontype: bsontype.String, readval: string("Hello, world!")}
+			llvrw := &TestValueReaderWriter{t: t, bsontype: bsontype.String, readval: "Hello, world!"}
 			btype, got, err := Copier{}.AppendValueBytes(nil, llvrw)
 			noerr(t, err)
 			want := bsoncore.AppendString(nil, "Hello, world!")

bson/bsonrw/extjson_wrappers.go

@@ -19,7 +19,7 @@ import (
 )
 
 func wrapperKeyBSONType(key string) bsontype.Type {
-	switch string(key) {
+	switch key {
 	case "$numberInt":
 		return bsontype.Int32
 	case "$numberLong":
@@ -269,7 +269,7 @@ func (ejv *extJSONValue) parseDouble() (float64, error) {
 		return 0, fmt.Errorf("$numberDouble value should be string, but instead is %s", ejv.t)
 	}
 
-	switch string(ejv.v.(string)) {
+	switch ejv.v.(string) {
 	case "Infinity":
 		return math.Inf(1), nil
 	case "-Infinity":
@@ -364,7 +364,7 @@ func (ejv *extJSONValue) parseRegex() (pattern, options string, err error) {
 	for i, key := range regexObj.keys {
 		val := regexObj.values[i]
 
-		switch string(key) {
+		switch key {
 		case "pattern":
 			if patFound {
 				return "", "", errors.New("duplicate pattern key in $regularExpression")

bson/mgocompat/bson_test.go

@@ -975,7 +975,7 @@ func TestUnmarshalSetterErrSetZero(t *testing.T) {
 	assert.Nil(t, err, "expected nil error, got: %v", err)
 
 	m := map[string]*setterType{}
-	err = bson.UnmarshalWithRegistry(Registry, []byte(data), m)
+	err = bson.UnmarshalWithRegistry(Registry, data, m)
 	assert.Nil(t, err, "expected nil error, got: %v", err)
 
 	value, ok := m["field"]

bson/primitive/decimal_test.go

@@ -155,7 +155,7 @@ func TestDecimal128_JSON(t *testing.T) {
 		bytes, err := json.Marshal(decimal)
 		assert.Nil(t, err, "json.Marshal error: %v", err)
 		got := NewDecimal128(0, 0)
-		err = json.Unmarshal([]byte(bytes), &got)
+		err = json.Unmarshal(bytes, &got)
 		assert.Nil(t, err, "json.Unmarshal error: %v", err)
 		assert.Equal(t, decimal.h, got.h, "expected h: %v got: %v", decimal.h, got.h)
 		assert.Equal(t, decimal.l, got.l, "expected l: %v got: %v", decimal.l, got.l)

bson/unmarshal_test.go

@@ -188,7 +188,7 @@ func TestCachingDecodersNotSharedAcrossRegistries(t *testing.T) {
 		return nil
 	}
 	customReg := NewRegistryBuilder().
-		RegisterTypeDecoder(tInt32, bsoncodec.ValueDecoderFunc(decodeInt32)).
+		RegisterTypeDecoder(tInt32, decodeInt32).
 		Build()
 
 	docBytes := bsoncore.BuildDocumentFromElements(

mongo/change_stream.go

@@ -141,7 +141,7 @@ func newChangeStream(ctx context.Context, config changeStreamConfig, pipeline in
 		cs.cursorOptions.BatchSize = *cs.options.BatchSize
 	}
 	if cs.options.MaxAwaitTime != nil {
-		cs.cursorOptions.MaxTimeMS = int64(time.Duration(*cs.options.MaxAwaitTime) / time.Millisecond)
+		cs.cursorOptions.MaxTimeMS = int64(*cs.options.MaxAwaitTime / time.Millisecond)
 	}
 
 	switch cs.streamType {

mongo/collection.go

@@ -1045,7 +1045,7 @@ func (coll *Collection) Distinct(ctx context.Context, fieldName string, filter i
 	selector := makeReadPrefSelector(sess, coll.readSelector, coll.client.localThreshold)
 	option := options.MergeDistinctOptions(opts...)
 
-	op := operation.NewDistinct(fieldName, bsoncore.Document(f)).
+	op := operation.NewDistinct(fieldName, f).
 		Session(sess).ClusterClock(coll.client.clock).
 		Database(coll.db.name).Collection(coll.name).CommandMonitor(coll.client.monitor).
 		Deployment(coll.client.deployment).ReadConcern(rc).ReadPreference(coll.readPreference).

mongo/gridfs/download_stream.go

@@ -267,7 +267,7 @@ func (ds *DownloadStream) fillBuffer(ctx context.Context) error {
 	if ds.expectedChunk == ds.numChunks {
 		// final chunk can be fewer than ds.chunkSize bytes
 		bytesDownloaded := int64(ds.chunkSize) * (int64(ds.expectedChunk) - int64(1))
-		bytesRemaining := ds.fileLen - int64(bytesDownloaded)
+		bytesRemaining := ds.fileLen - bytesDownloaded
 
 		if int64(bytesLen) != bytesRemaining {
 			return ErrWrongSize

mongo/gridfs/upload_stream.go

@@ -161,7 +161,7 @@ func (us *UploadStream) uploadChunks(ctx context.Context, uploadPartial bool) er
 		numChunks = int(math.Floor(chunks))
 	}
 
-	docs := make([]interface{}, int(numChunks))
+	docs := make([]interface{}, numChunks)
 
 	id, err := convertFileID(us.FileID)
 	if err != nil {

mongo/integration/operation_legacy_test.go

@@ -197,7 +197,7 @@ func runFindWithOptions(mt *mtest.T) opQuery {
 		{"$orderby", sort},
 	}
 	return opQuery{
-		flags:                wiremessage.QueryFlag(wiremessage.Partial | wiremessage.TailableCursor | wiremessage.NoCursorTimeout | wiremessage.OplogReplay | wiremessage.SecondaryOK),
+		flags:                wiremessage.Partial | wiremessage.TailableCursor | wiremessage.NoCursorTimeout | wiremessage.OplogReplay | wiremessage.SecondaryOK,
 		fullCollectionName:   fullCollName(mt, mt.Coll.Name()),
 		numToSkip:            1,
 		numToReturn:          2,

mongo/integration/unified/collection_operation_execution.go

@@ -169,15 +169,15 @@ func executeCountDocuments(ctx context.Context, operation *operation) (*operatio
 			}
 			opts.SetCollation(collation)
 		case "filter":
-			filter = bson.Raw(val.Document())
+			filter = val.Document()
 		case "hint":
 			hint, err := createHint(val)
 			if err != nil {
 				return nil, fmt.Errorf("error creating hint: %v", err)
 			}
 			opts.SetHint(hint)
 		case "limit":
-			opts.SetLimit(int64(val.Int64()))
+			opts.SetLimit(val.Int64())
 		case "maxTimeMS":
 			opts.SetMaxTime(time.Duration(val.Int32()) * time.Millisecond)
 		case "skip":

mongo/mongo_test.go

@@ -179,7 +179,7 @@ func TestMongoHelpers(t *testing.T) {
 				primitive.A{"5"},
 				nil,
 				false,
-				MarshalError{Value: string(""), Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
+				MarshalError{Value: "", Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
 			},
 			{
 				"primitive.A/success",
@@ -196,7 +196,7 @@ func TestMongoHelpers(t *testing.T) {
 				bson.A{"5"},
 				nil,
 				false,
-				MarshalError{Value: string(""), Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
+				MarshalError{Value: "", Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
 			},
 			{
 				"bson.A/success",
@@ -213,7 +213,7 @@ func TestMongoHelpers(t *testing.T) {
 				[]interface{}{"5"},
 				nil,
 				false,
-				MarshalError{Value: string(""), Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
+				MarshalError{Value: "", Err: errors.New("WriteString can only write while positioned on a Element or Value but is positioned on a TopLevel")},
 			},
 			{
 				"[]interface{}/success",

mongo/writeconcern/writeconcern.go

@@ -105,7 +105,7 @@ func (wc *WriteConcern) MarshalBSONValue() (bsontype.Type, []byte, error) {
 
 			elems = bsoncore.AppendInt32Element(elems, "w", int32(t))
 		case string:
-			elems = bsoncore.AppendStringElement(elems, "w", string(t))
+			elems = bsoncore.AppendStringElement(elems, "w", t)
 		}
 	}
 

x/bsonx/bsoncore/value.go

@@ -602,7 +602,7 @@ func (v Value) Time() time.Time {
 	if !ok {
 		panic(NewInsufficientBytesError(v.Data, v.Data))
 	}
-	return time.Unix(int64(dt)/1000, int64(dt)%1000*1000000)
+	return time.Unix(dt/1000, dt%1000*1000000)
 }
 
 // TimeOK is the same as Time, except it returns a boolean instead of
@@ -615,7 +615,7 @@ func (v Value) TimeOK() (time.Time, bool) {
 	if !ok {
 		return time.Time{}, false
 	}
-	return time.Unix(int64(dt)/1000, int64(dt)%1000*1000000), true
+	return time.Unix(dt/1000, dt%1000*1000000), true
 }
 
 // Regex returns the BSON regex value the Value represents. It panics if the value is a BSON