refactor: change interface{} to any (#181)

Author: JoshGuarino

json.go

@@ -7,7 +7,7 @@ import (
 	"time"
 )
 
-func (l *Logger) jsonFormatter(keyvals ...interface{}) {
+func (l *Logger) jsonFormatter(keyvals ...any) {
 	jw := &jsonWriter{w: &l.b}
 	jw.start()
 

json_test.go

@@ -19,8 +19,8 @@ func TestJson(t *testing.T) {
 		name     string
 		expected string
 		msg      string
-		kvs      []interface{}
-		f        func(msg interface{}, kvs ...interface{})
+		kvs      []any
+		f        func(msg any, kvs ...any)
 	}{
 		{
 			name:     "default logger info with timestamp",
@@ -54,70 +54,70 @@ func TestJson(t *testing.T) {
 			name:     "multiline kvs",
 			expected: "{\"level\":\"error\",\"msg\":\"info\",\"multiline\":\"info\\ninfo\"}\n",
 			msg:      "info",
-			kvs:      []interface{}{"multiline", "info\ninfo"},
+			kvs:      []any{"multiline", "info\ninfo"},
 			f:        l.Error,
 		},
 		{
 			name:     "odd number of kvs",
 			expected: "{\"level\":\"error\",\"msg\":\"info\",\"foo\":\"bar\",\"baz\":\"missing value\"}\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", "bar", "baz"},
+			kvs:      []any{"foo", "bar", "baz"},
 			f:        l.Error,
 		},
 		{
 			name:     "error field",
 			expected: "{\"level\":\"error\",\"msg\":\"info\",\"error\":\"error message\"}\n",
 			msg:      "info",
-			kvs:      []interface{}{"error", errors.New("error message")},
+			kvs:      []any{"error", errors.New("error message")},
 			f:        l.Error,
 		},
 		{
 			name:     "struct field",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"struct\":{}}\n",
 			msg:      "info",
-			kvs:      []interface{}{"struct", struct{ foo string }{foo: "bar"}},
+			kvs:      []any{"struct", struct{ foo string }{foo: "bar"}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice field",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"slice\":[1,2,3]}\n",
 			msg:      "info",
-			kvs:      []interface{}{"slice", []int{1, 2, 3}},
+			kvs:      []any{"slice", []int{1, 2, 3}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of structs",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"slice\":[{},{}]}\n",
 			msg:      "info",
-			kvs:      []interface{}{"slice", []struct{ foo string }{{foo: "bar"}, {foo: "baz"}}},
+			kvs:      []any{"slice", []struct{ foo string }{{foo: "bar"}, {foo: "baz"}}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of strings",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"slice\":[\"foo\",\"bar\"]}\n",
 			msg:      "info",
-			kvs:      []interface{}{"slice", []string{"foo", "bar"}},
+			kvs:      []any{"slice", []string{"foo", "bar"}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of errors",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"slice\":[{},{}]}\n",
 			msg:      "info",
-			kvs:      []interface{}{"slice", []error{errors.New("error message1"), errors.New("error message2")}},
+			kvs:      []any{"slice", []error{errors.New("error message1"), errors.New("error message2")}},
 			f:        l.Info,
 		},
 		{
 			name:     "map of strings",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"map\":{\"a\":\"b\",\"foo\":\"bar\"}}\n",
 			msg:      "info",
-			kvs:      []interface{}{"map", map[string]string{"a": "b", "foo": "bar"}},
+			kvs:      []any{"map", map[string]string{"a": "b", "foo": "bar"}},
 			f:        l.Info,
 		},
 		{
 			name:     "slog any value error type",
 			expected: "{\"level\":\"info\",\"msg\":\"info\",\"error\":\"error message\"}\n",
 			msg:      "info",
-			kvs:      []interface{}{"error", slogAnyValue(fmt.Errorf("error message"))},
+			kvs:      []any{"error", slogAnyValue(fmt.Errorf("error message"))},
 			f:        l.Info,
 		},
 	}
@@ -141,9 +141,9 @@ func TestJsonCaller(t *testing.T) {
 		name     string
 		expected string
 		msg      string
-		kvs      []interface{}
+		kvs      []any
 
-		f func(msg interface{}, kvs ...interface{})
+		f func(msg any, kvs ...any)
 	}{
 		{
 			name:     "simple caller",
@@ -157,7 +157,7 @@ func TestJsonCaller(t *testing.T) {
 			expected: fmt.Sprintf("{\"level\":\"info\",\"caller\":\"log/%s:%d\",\"msg\":\"info\"}\n", filepath.Base(file), line+30),
 			msg:      "info",
 			kvs:      nil,
-			f: func(msg interface{}, kvs ...interface{}) {
+			f: func(msg any, kvs ...any) {
 				l.Helper()
 				l.Info(msg, kvs...)
 			},

logfmt.go

@@ -8,7 +8,7 @@ import (
 	"github.com/go-logfmt/logfmt"
 )
 
-func (l *Logger) logfmtFormatter(keyvals ...interface{}) {
+func (l *Logger) logfmtFormatter(keyvals ...any) {
 	e := logfmt.NewEncoder(&l.b)
 
 	for i := 0; i < len(keyvals); i += 2 {

logfmt_test.go

@@ -16,8 +16,8 @@ func TestLogfmt(t *testing.T) {
 		name     string
 		expected string
 		msg      string
-		kvs      []interface{}
-		f        func(msg interface{}, kvs ...interface{})
+		kvs      []any
+		f        func(msg any, kvs ...any)
 	}{
 		{
 			name:     "simple",
@@ -37,14 +37,14 @@ func TestLogfmt(t *testing.T) {
 			name:     "message with keyvals",
 			expected: "level=info msg=info foo=bar\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", "bar"},
+			kvs:      []any{"foo", "bar"},
 			f:        l.Info,
 		},
 		{
 			name:     "message with multiline keyvals",
 			expected: "level=info msg=info foo=\"bar\\nbaz\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", "bar\nbaz"},
+			kvs:      []any{"foo", "bar\nbaz"},
 			f:        l.Info,
 		},
 		{
@@ -58,63 +58,63 @@ func TestLogfmt(t *testing.T) {
 			name:     "message with error",
 			expected: "level=info msg=info err=\"foo: bar\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"err", errors.New("foo: bar")},
+			kvs:      []any{"err", errors.New("foo: bar")},
 			f:        l.Info,
 		},
 		{
 			name:     "odd number of keyvals",
 			expected: "level=info msg=info foo=bar baz=\"missing value\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", "bar", "baz"},
+			kvs:      []any{"foo", "bar", "baz"},
 			f:        l.Info,
 		},
 		{
 			name:     "struct field",
 			expected: "level=info msg=info foo=\"{bar:foo bar}\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", struct{ bar string }{"foo bar"}},
+			kvs:      []any{"foo", struct{ bar string }{"foo bar"}},
 			f:        l.Info,
 		},
 		{
 			name:     "multiple struct fields",
 			expected: "level=info msg=info foo={bar:baz} foo2={bar:baz}\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", struct{ bar string }{"baz"}, "foo2", struct{ bar string }{"baz"}},
+			kvs:      []any{"foo", struct{ bar string }{"baz"}, "foo2", struct{ bar string }{"baz"}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of structs",
 			expected: "level=info msg=info foo=\"[{bar:baz} {bar:baz}]\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", []struct{ bar string }{{"baz"}, {"baz"}}},
+			kvs:      []any{"foo", []struct{ bar string }{{"baz"}, {"baz"}}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of strings",
 			expected: "level=info msg=info foo=\"[bar baz]\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", []string{"bar", "baz"}},
+			kvs:      []any{"foo", []string{"bar", "baz"}},
 			f:        l.Info,
 		},
 		{
 			name:     "slice of errors",
 			expected: "level=info msg=info foo=\"[error1 error2]\"\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", []error{errors.New("error1"), errors.New("error2")}},
+			kvs:      []any{"foo", []error{errors.New("error1"), errors.New("error2")}},
 			f:        l.Info,
 		},
 		{
 			name:     "map of strings",
 			expected: "level=info msg=info foo=map[bar:baz]\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", map[string]string{"bar": "baz"}},
+			kvs:      []any{"foo", map[string]string{"bar": "baz"}},
 			f:        l.Info,
 		},
 		{
 			name:     "map with interface",
 			expected: "level=info msg=info foo=map[bar:baz]\n",
 			msg:      "info",
-			kvs:      []interface{}{"foo", map[string]interface{}{"bar": "baz"}},
+			kvs:      []any{"foo", map[string]any{"bar": "baz"}},
 			f:        l.Info,
 		},
 	}

logger.go

@@ -41,19 +41,19 @@ type Logger struct {
 	reportCaller    bool
 	reportTimestamp bool
 
-	fields []interface{}
+	fields []any
 
 	helpers *sync.Map
 	styles  *Styles
 }
 
 // Logf logs a message with formatting.
-func (l *Logger) Logf(level Level, format string, args ...interface{}) {
+func (l *Logger) Logf(level Level, format string, args ...any) {
 	l.Log(level, fmt.Sprintf(format, args...))
 }
 
 // Log logs the given message with the given keyvals for the given level.
-func (l *Logger) Log(level Level, msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Log(level Level, msg any, keyvals ...any) {
 	if atomic.LoadUint32(&l.isDiscard) != 0 {
 		return
 	}
@@ -81,8 +81,8 @@ func (l *Logger) Log(level Level, msg interface{}, keyvals ...interface{}) {
 	l.handle(level, l.timeFunc(time.Now()), []runtime.Frame{frame}, msg, keyvals...)
 }
 
-func (l *Logger) handle(level Level, ts time.Time, frames []runtime.Frame, msg interface{}, keyvals ...interface{}) {
-	var kvs []interface{}
+func (l *Logger) handle(level Level, ts time.Time, frames []runtime.Frame, msg any, keyvals ...any) {
+	var kvs []any
 	if l.reportTimestamp && !ts.IsZero() {
 		kvs = append(kvs, TimestampKey, ts)
 	}
@@ -327,7 +327,7 @@ func (l *Logger) SetStyles(s *Styles) {
 }
 
 // With returns a new logger with the given keyvals added.
-func (l *Logger) With(keyvals ...interface{}) *Logger {
+func (l *Logger) With(keyvals ...any) *Logger {
 	var st Styles
 	l.mu.Lock()
 	sl := *l
@@ -336,7 +336,7 @@ func (l *Logger) With(keyvals ...interface{}) *Logger {
 	sl.b = bytes.Buffer{}
 	sl.mu = &sync.RWMutex{}
 	sl.helpers = &sync.Map{}
-	sl.fields = append(make([]interface{}, 0, len(l.fields)+len(keyvals)), l.fields...)
+	sl.fields = append(make([]any, 0, len(l.fields)+len(keyvals)), l.fields...)
 	sl.fields = append(sl.fields, keyvals...)
 	sl.styles = &st
 	return &sl
@@ -350,63 +350,63 @@ func (l *Logger) WithPrefix(prefix string) *Logger {
 }
 
 // Debug prints a debug message.
-func (l *Logger) Debug(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Debug(msg any, keyvals ...any) {
 	l.Log(DebugLevel, msg, keyvals...)
 }
 
 // Info prints an info message.
-func (l *Logger) Info(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Info(msg any, keyvals ...any) {
 	l.Log(InfoLevel, msg, keyvals...)
 }
 
 // Warn prints a warning message.
-func (l *Logger) Warn(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Warn(msg any, keyvals ...any) {
 	l.Log(WarnLevel, msg, keyvals...)
 }
 
 // Error prints an error message.
-func (l *Logger) Error(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Error(msg any, keyvals ...any) {
 	l.Log(ErrorLevel, msg, keyvals...)
 }
 
 // Fatal prints a fatal message and exits.
-func (l *Logger) Fatal(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Fatal(msg any, keyvals ...any) {
 	l.Log(FatalLevel, msg, keyvals...)
 	os.Exit(1)
 }
 
 // Print prints a message with no level.
-func (l *Logger) Print(msg interface{}, keyvals ...interface{}) {
+func (l *Logger) Print(msg any, keyvals ...any) {
 	l.Log(noLevel, msg, keyvals...)
 }
 
 // Debugf prints a debug message with formatting.
-func (l *Logger) Debugf(format string, args ...interface{}) {
+func (l *Logger) Debugf(format string, args ...any) {
 	l.Log(DebugLevel, fmt.Sprintf(format, args...))
 }
 
 // Infof prints an info message with formatting.
-func (l *Logger) Infof(format string, args ...interface{}) {
+func (l *Logger) Infof(format string, args ...any) {
 	l.Log(InfoLevel, fmt.Sprintf(format, args...))
 }
 
 // Warnf prints a warning message with formatting.
-func (l *Logger) Warnf(format string, args ...interface{}) {
+func (l *Logger) Warnf(format string, args ...any) {
 	l.Log(WarnLevel, fmt.Sprintf(format, args...))
 }
 
 // Errorf prints an error message with formatting.
-func (l *Logger) Errorf(format string, args ...interface{}) {
+func (l *Logger) Errorf(format string, args ...any) {
 	l.Log(ErrorLevel, fmt.Sprintf(format, args...))
 }
 
 // Fatalf prints a fatal message with formatting and exits.
-func (l *Logger) Fatalf(format string, args ...interface{}) {
+func (l *Logger) Fatalf(format string, args ...any) {
 	l.Log(FatalLevel, fmt.Sprintf(format, args...))
 	os.Exit(1)
 }
 
 // Printf prints a message with no level and formatting.
-func (l *Logger) Printf(format string, args ...interface{}) {
+func (l *Logger) Printf(format string, args ...any) {
 	l.Log(noLevel, fmt.Sprintf(format, args...))
 }

logger_121.go

@@ -36,7 +36,7 @@ func (l *Logger) Handle(ctx context.Context, record slog.Record) error {
 		return nil
 	}
 
-	fields := make([]interface{}, 0, record.NumAttrs()*2)
+	fields := make([]any, 0, record.NumAttrs()*2)
 	record.Attrs(func(a slog.Attr) bool {
 		fields = append(fields, a.Key, a.Value)
 		return true
@@ -52,7 +52,7 @@ func (l *Logger) Handle(ctx context.Context, record slog.Record) error {
 //
 // Implements slog.Handler.
 func (l *Logger) WithAttrs(attrs []slog.Attr) slog.Handler {
-	fields := make([]interface{}, 0, len(attrs)*2)
+	fields := make([]any, 0, len(attrs)*2)
 	for _, attr := range attrs {
 		fields = append(fields, attr.Key, attr.Value)
 	}

logger_121_test.go

@@ -195,7 +195,7 @@ func TestSlogAttr(t *testing.T) {
 	cases := []struct {
 		name     string
 		expected string
-		kvs      []interface{}
+		kvs      []any
 	}{
 		{
 			name:     "any",