Replace interface{} with any

internal/anynil/anynil.go

@@ -3,7 +3,7 @@ package anynil
 import "reflect"
 
 // Is returns true if value is any type of nil. e.g. nil or []byte(nil).
-func Is(value interface{}) bool {
+func Is(value any) bool {
 	if value == nil {
 		return true
 	}
@@ -18,7 +18,7 @@ func Is(value interface{}) bool {
 }
 
 // Normalize converts typed nils (e.g. []byte(nil)) into untyped nil. Other values are returned unmodified.
-func Normalize(v interface{}) interface{} {
+func Normalize(v any) any {
 	if Is(v) {
 		return nil
 	}
@@ -27,7 +27,7 @@ func Normalize(v interface{}) interface{} {
 
 // NormalizeSlice converts all typed nils (e.g. []byte(nil)) in s into untyped nils. Other values are unmodified. s is
 // mutated in place.
-func NormalizeSlice(s []interface{}) {
+func NormalizeSlice(s []any) {
 	for i := range s {
 		if Is(s[i]) {
 			s[i] = nil

internal/sanitize/sanitize.go

@@ -12,13 +12,13 @@ import (
 
 // Part is either a string or an int. A string is raw SQL. An int is a
 // argument placeholder.
-type Part interface{}
+type Part any
 
 type Query struct {
 	Parts []Part
 }
 
-func (q *Query) Sanitize(args ...interface{}) (string, error) {
+func (q *Query) Sanitize(args ...any) (string, error) {
 	argUse := make([]bool, len(args))
 	buf := &bytes.Buffer{}
 
@@ -295,7 +295,7 @@ func multilineCommentState(l *sqlLexer) stateFn {
 // SanitizeSQL replaces placeholder values with args. It quotes and escapes args
 // as necessary. This function is only safe when standard_conforming_strings is
 // on.
-func SanitizeSQL(sql string, args ...interface{}) (string, error) {
+func SanitizeSQL(sql string, args ...any) (string, error) {
 	query, err := NewQuery(sql)
 	if err != nil {
 		return "", err

internal/sanitize/sanitize_test.go

@@ -107,57 +107,57 @@ func TestNewQuery(t *testing.T) {
 func TestQuerySanitize(t *testing.T) {
 	successfulTests := []struct {
 		query    sanitize.Query
-		args     []interface{}
+		args     []any
 		expected string
 	}{
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select 42"}},
-			args:     []interface{}{},
+			args:     []any{},
 			expected: `select 42`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{int64(42)},
+			args:     []any{int64(42)},
 			expected: `select 42`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{float64(1.23)},
+			args:     []any{float64(1.23)},
 			expected: `select 1.23`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{true},
+			args:     []any{true},
 			expected: `select true`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{[]byte{0, 1, 2, 3, 255}},
+			args:     []any{[]byte{0, 1, 2, 3, 255}},
 			expected: `select '\x00010203ff'`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{nil},
+			args:     []any{nil},
 			expected: `select null`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{"foobar"},
+			args:     []any{"foobar"},
 			expected: `select 'foobar'`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{"foo'bar"},
+			args:     []any{"foo'bar"},
 			expected: `select 'foo''bar'`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{`foo\'bar`},
+			args:     []any{`foo\'bar`},
 			expected: `select 'foo\''bar'`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"insert ", 1}},
-			args:     []interface{}{time.Date(2020, time.March, 1, 23, 59, 59, 999999999, time.UTC)},
+			args:     []any{time.Date(2020, time.March, 1, 23, 59, 59, 999999999, time.UTC)},
 			expected: `insert '2020-03-01 23:59:59.999999Z'`,
 		},
 	}
@@ -176,22 +176,22 @@ func TestQuerySanitize(t *testing.T) {
 
 	errorTests := []struct {
 		query    sanitize.Query
-		args     []interface{}
+		args     []any
 		expected string
 	}{
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1, ", ", 2}},
-			args:     []interface{}{int64(42)},
+			args:     []any{int64(42)},
 			expected: `insufficient arguments`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select 'foo'"}},
-			args:     []interface{}{int64(42)},
+			args:     []any{int64(42)},
 			expected: `unused argument: 0`,
 		},
 		{
 			query:    sanitize.Query{Parts: []sanitize.Part{"select ", 1}},
-			args:     []interface{}{42},
+			args:     []any{42},
 			expected: `invalid arg type: int`,
 		},
 	}