Minor style changes

Author: oschwald

decoder.go

@@ -151,12 +151,12 @@ func (d *decoder) decodeFromType(
 	result reflect.Value,
 	depth int,
 ) (uint, error) {
-	result = d.indirect(result)
+	result = indirect(result)
 
 	// For these types, size has a special meaning
 	switch dtype {
 	case _Bool:
-		return d.unmarshalBool(size, offset, result)
+		return unmarshalBool(size, offset, result)
 	case _Map:
 		return d.unmarshalMap(size, offset, result, depth)
 	case _Pointer:
@@ -203,7 +203,7 @@ func (d *decoder) decodeFromTypeToDeserializer(
 	// For these types, size has a special meaning
 	switch dtype {
 	case _Bool:
-		v, offset := d.decodeBool(size, offset)
+		v, offset := decodeBool(size, offset)
 		return offset, dser.Bool(v)
 	case _Map:
 		return d.decodeMapToDeserializer(size, offset, dser, depth)
@@ -255,14 +255,14 @@ func (d *decoder) decodeFromTypeToDeserializer(
 	}
 }
 
-func (d *decoder) unmarshalBool(size, offset uint, result reflect.Value) (uint, error) {
+func unmarshalBool(size, offset uint, result reflect.Value) (uint, error) {
 	if size > 1 {
 		return 0, newInvalidDatabaseError(
 			"the MaxMind DB file's data section contains bad data (bool size of %v)",
 			size,
 		)
 	}
-	value, newOffset := d.decodeBool(size, offset)
+	value, newOffset := decodeBool(size, offset)
 
 	switch result.Kind() {
 	case reflect.Bool:
@@ -281,7 +281,7 @@ func (d *decoder) unmarshalBool(size, offset uint, result reflect.Value) (uint,
 // heavily based on encoding/json as my original version had a subtle
 // bug. This method should be considered to be licensed under
 // https://golang.org/LICENSE
-func (d *decoder) indirect(result reflect.Value) reflect.Value {
+func indirect(result reflect.Value) reflect.Value {
 	for {
 		// Load value from interface, but only if the result will be
 		// usefully addressable.
@@ -415,7 +415,7 @@ func (d *decoder) unmarshalMap(
 	result reflect.Value,
 	depth int,
 ) (uint, error) {
-	result = d.indirect(result)
+	result = indirect(result)
 	switch result.Kind() {
 	default:
 		return 0, newUnmarshalTypeError("map", result.Type())
@@ -425,7 +425,7 @@ func (d *decoder) unmarshalMap(
 		return d.decodeMap(size, offset, result, depth)
 	case reflect.Interface:
 		if result.NumMethod() == 0 {
-			rv := reflect.ValueOf(make(map[string]interface{}, size))
+			rv := reflect.ValueOf(make(map[string]any, size))
 			newOffset, err := d.decodeMap(size, offset, rv, depth)
 			result.Set(rv)
 			return newOffset, err
@@ -458,7 +458,7 @@ func (d *decoder) unmarshalSlice(
 		return d.decodeSlice(size, offset, result, depth)
 	case reflect.Interface:
 		if result.NumMethod() == 0 {
-			a := []interface{}{}
+			a := []any{}
 			rv := reflect.ValueOf(&a).Elem()
 			newOffset, err := d.decodeSlice(size, offset, rv, depth)
 			result.Set(rv)
@@ -551,7 +551,7 @@ func (d *decoder) unmarshalUint128(size, offset uint, result reflect.Value) (uin
 	return newOffset, newUnmarshalTypeError(value, result.Type())
 }
 
-func (d *decoder) decodeBool(size, offset uint) (bool, uint) {
+func decodeBool(size, offset uint) (bool, uint) {
 	return size != 0, offset
 }
 

decoder_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func TestBool(t *testing.T) {
-	bools := map[string]interface{}{
+	bools := map[string]any{
 		"0007": false,
 		"0107": true,
 	}
@@ -22,7 +22,7 @@ func TestBool(t *testing.T) {
 }
 
 func TestDouble(t *testing.T) {
-	doubles := map[string]interface{}{
+	doubles := map[string]any{
 		"680000000000000000": 0.0,
 		"683FE0000000000000": 0.5,
 		"68400921FB54442EEA": 3.14159265359,
@@ -36,7 +36,7 @@ func TestDouble(t *testing.T) {
 }
 
 func TestFloat(t *testing.T) {
-	floats := map[string]interface{}{
+	floats := map[string]any{
 		"040800000000": float32(0.0),
 		"04083F800000": float32(1.0),
 		"04083F8CCCCD": float32(1.1),
@@ -51,7 +51,7 @@ func TestFloat(t *testing.T) {
 }
 
 func TestInt32(t *testing.T) {
-	int32s := map[string]interface{}{
+	int32s := map[string]any{
 		"0001":         0,
 		"0401ffffffff": -1,
 		"0101ff":       255,
@@ -69,33 +69,33 @@ func TestInt32(t *testing.T) {
 }
 
 func TestMap(t *testing.T) {
-	maps := map[string]interface{}{
-		"e0":                             map[string]interface{}{},
-		"e142656e43466f6f":               map[string]interface{}{"en": "Foo"},
-		"e242656e43466f6f427a6843e4baba": map[string]interface{}{"en": "Foo", "zh": "人"},
-		"e1446e616d65e242656e43466f6f427a6843e4baba": map[string]interface{}{
-			"name": map[string]interface{}{"en": "Foo", "zh": "人"},
+	maps := map[string]any{
+		"e0":                             map[string]any{},
+		"e142656e43466f6f":               map[string]any{"en": "Foo"},
+		"e242656e43466f6f427a6843e4baba": map[string]any{"en": "Foo", "zh": "人"},
+		"e1446e616d65e242656e43466f6f427a6843e4baba": map[string]any{
+			"name": map[string]any{"en": "Foo", "zh": "人"},
 		},
-		"e1496c616e677561676573020442656e427a68": map[string]interface{}{
-			"languages": []interface{}{"en", "zh"},
+		"e1496c616e677561676573020442656e427a68": map[string]any{
+			"languages": []any{"en", "zh"},
 		},
 	}
 	validateDecoding(t, maps)
 }
 
 func TestSlice(t *testing.T) {
-	slice := map[string]interface{}{
-		"0004":                 []interface{}{},
-		"010443466f6f":         []interface{}{"Foo"},
-		"020443466f6f43e4baba": []interface{}{"Foo", "人"},
+	slice := map[string]any{
+		"0004":                 []any{},
+		"010443466f6f":         []any{"Foo"},
+		"020443466f6f43e4baba": []any{"Foo", "人"},
 	}
 	validateDecoding(t, slice)
 }
 
 var testStrings = makeTestStrings()
 
-func makeTestStrings() map[string]interface{} {
-	str := map[string]interface{}{
+func makeTestStrings() map[string]any {
+	str := map[string]any{
 		"40":       "",
 		"4131":     "1",
 		"43E4BABA": "人",
@@ -118,7 +118,7 @@ func TestString(t *testing.T) {
 }
 
 func TestByte(t *testing.T) {
-	b := make(map[string]interface{})
+	b := make(map[string]any)
 	for key, val := range testStrings {
 		oldCtrl, err := hex.DecodeString(key[0:2])
 		require.NoError(t, err)
@@ -131,7 +131,7 @@ func TestByte(t *testing.T) {
 }
 
 func TestUint16(t *testing.T) {
-	uint16s := map[string]interface{}{
+	uint16s := map[string]any{
 		"a0":     uint64(0),
 		"a1ff":   uint64(255),
 		"a201f4": uint64(500),
@@ -142,7 +142,7 @@ func TestUint16(t *testing.T) {
 }
 
 func TestUint32(t *testing.T) {
-	uint32s := map[string]interface{}{
+	uint32s := map[string]any{
 		"c0":         uint64(0),
 		"c1ff":       uint64(255),
 		"c201f4":     uint64(500),
@@ -158,7 +158,7 @@ func TestUint64(t *testing.T) {
 	ctrlByte := "02"
 	bits := uint64(64)
 
-	uints := map[string]interface{}{
+	uints := map[string]any{
 		"00" + ctrlByte:          uint64(0),
 		"02" + ctrlByte + "01f4": uint64(500),
 		"02" + ctrlByte + "2a78": uint64(10872),
@@ -178,7 +178,7 @@ func TestUint128(t *testing.T) {
 	ctrlByte := "03"
 	bits := uint(128)
 
-	uints := map[string]interface{}{
+	uints := map[string]any{
 		"00" + ctrlByte:          big.NewInt(0),
 		"02" + ctrlByte + "01f4": big.NewInt(500),
 		"02" + ctrlByte + "2a78": big.NewInt(10872),
@@ -204,13 +204,13 @@ func powBigInt(bi *big.Int, pow uint) *big.Int {
 	return newInt
 }
 
-func validateDecoding(t *testing.T, tests map[string]interface{}) {
+func validateDecoding(t *testing.T, tests map[string]any) {
 	for inputStr, expected := range tests {
 		inputBytes, err := hex.DecodeString(inputStr)
 		require.NoError(t, err)
 		d := decoder{inputBytes}
 
-		var result interface{}
+		var result any
 		_, err = d.decode(0, reflect.ValueOf(&result), 0)
 		assert.NoError(t, err)
 

deserializer_test.go

@@ -20,26 +20,26 @@ func TestDecodingToDeserializer(t *testing.T) {
 }
 
 type stackValue struct {
-	value  interface{}
+	value  any
 	curNum int
 }
 
 type testDeserializer struct {
 	stack []*stackValue
-	rv    interface{}
+	rv    any
 	key   *string
 }
 
-func (d *testDeserializer) ShouldSkip(_ uintptr) (bool, error) {
+func (*testDeserializer) ShouldSkip(_ uintptr) (bool, error) {
 	return false, nil
 }
 
 func (d *testDeserializer) StartSlice(size uint) error {
-	return d.add(make([]interface{}, size))
+	return d.add(make([]any, size))
 }
 
 func (d *testDeserializer) StartMap(_ uint) error {
-	return d.add(map[string]interface{}{})
+	return d.add(map[string]any{})
 }
 
 //nolint:unparam // This is to meet the requirements of the interface.
@@ -88,13 +88,13 @@ func (d *testDeserializer) Float32(v float32) error {
 	return d.add(v)
 }
 
-func (d *testDeserializer) add(v interface{}) error {
+func (d *testDeserializer) add(v any) error {
 	if len(d.stack) == 0 {
 		d.rv = v
 	} else {
 		top := d.stack[len(d.stack)-1]
 		switch parent := top.value.(type) {
-		case map[string]interface{}:
+		case map[string]any:
 			if d.key == nil {
 				key := v.(string)
 				d.key = &key
@@ -103,15 +103,15 @@ func (d *testDeserializer) add(v interface{}) error {
 				d.key = nil
 			}
 
-		case []interface{}:
+		case []any:
 			parent[top.curNum] = v
 			top.curNum++
 		default:
 		}
 	}
 
 	switch v := v.(type) {
-	case map[string]interface{}, []interface{}:
+	case map[string]any, []any:
 		d.stack = append(d.stack, &stackValue{value: v})
 	default:
 	}

errors.go

@@ -15,7 +15,7 @@ func newOffsetError() InvalidDatabaseError {
 	return InvalidDatabaseError{"unexpected end of database"}
 }
 
-func newInvalidDatabaseError(format string, args ...interface{}) InvalidDatabaseError {
+func newInvalidDatabaseError(format string, args ...any) InvalidDatabaseError {
 	return InvalidDatabaseError{fmt.Sprintf(format, args...)}
 }
 
@@ -30,7 +30,7 @@ type UnmarshalTypeError struct {
 	Value string
 }
 
-func newUnmarshalTypeError(value interface{}, rType reflect.Type) UnmarshalTypeError {
+func newUnmarshalTypeError(value any, rType reflect.Type) UnmarshalTypeError {
 	return UnmarshalTypeError{
 		Value: fmt.Sprintf("%v", value),
 		Type:  rType,

example_test.go

@@ -33,7 +33,7 @@ func ExampleReader_Lookup_struct() {
 	// GB
 }
 
-// This example demonstrates how to decode to an interface{}.
+// This example demonstrates how to decode to an any.
 func ExampleReader_Lookup_interface() {
 	db, err := maxminddb.Open("test-data/test-data/GeoIP2-City-Test.mmdb")
 	if err != nil {
@@ -43,7 +43,7 @@ func ExampleReader_Lookup_interface() {
 
 	ip := net.ParseIP("81.2.69.142")
 
-	var record interface{}
+	var record any
 	err = db.Lookup(ip, &record)
 	if err != nil {
 		log.Panic(err)

reader.go

@@ -130,7 +130,7 @@ func (r *Reader) setIPv4Start() {
 // because of type differences, an UnmarshalTypeError is returned. If the
 // database is invalid or otherwise cannot be read, an InvalidDatabaseError
 // is returned.
-func (r *Reader) Lookup(ip net.IP, result interface{}) error {
+func (r *Reader) Lookup(ip net.IP, result any) error {
 	if r.buffer == nil {
 		return errors.New("cannot call Lookup on a closed database")
 	}
@@ -152,7 +152,7 @@ func (r *Reader) Lookup(ip net.IP, result interface{}) error {
 // cannot be read, an InvalidDatabaseError is returned.
 func (r *Reader) LookupNetwork(
 	ip net.IP,
-	result interface{},
+	result any,
 ) (network *net.IPNet, ok bool, err error) {
 	if r.buffer == nil {
 		return nil, false, errors.New("cannot call Lookup on a closed database")
@@ -204,7 +204,7 @@ func (r *Reader) cidr(ip net.IP, prefixLength int) *net.IPNet {
 // Decode the record at |offset| into |result|. The result value pointed to
 // must be a data value that corresponds to a record in the database. This may
 // include a struct representation of the data, a map capable of holding the
-// data or an empty interface{} value.
+// data or an empty any value.
 //
 // If result is a pointer to a struct, the struct need not include a field
 // for every value that may be in the database. If a field is not present in
@@ -217,14 +217,14 @@ func (r *Reader) cidr(ip net.IP, prefixLength int) *net.IPNet {
 // the City database, all records of the same country will reference a
 // single representative record for that country. This uintptr behavior allows
 // clients to leverage this normalization in their own sub-record caching.
-func (r *Reader) Decode(offset uintptr, result interface{}) error {
+func (r *Reader) Decode(offset uintptr, result any) error {
 	if r.buffer == nil {
 		return errors.New("cannot call Decode on a closed database")
 	}
 	return r.decode(offset, result)
 }
 
-func (r *Reader) decode(offset uintptr, result interface{}) error {
+func (r *Reader) decode(offset uintptr, result any) error {
 	rv := reflect.ValueOf(result)
 	if rv.Kind() != reflect.Ptr || rv.IsNil() {
 		return errors.New("result param must be a pointer")
@@ -292,7 +292,7 @@ func (r *Reader) traverseTree(ip net.IP, node, bitCount uint) (uint, int) {
 	return node, int(i)
 }
 
-func (r *Reader) retrieveData(pointer uint, result interface{}) error {
+func (r *Reader) retrieveData(pointer uint, result any) error {
 	offset, err := r.resolveDataPointer(pointer)
 	if err != nil {
 		return err