all: gofmt -w -r 'interface{} -> any' .

Updates #9687

9 files changed, 100 insertions, 100 deletions

diff --git a/parser/frontmatter.go b/parser/frontmatter.go
index a99829521..150ce038f 100644
--- a/parser/frontmatter.go
+++ b/parser/frontmatter.go
@@ -32,7 +32,7 @@ const (
 	tomlDelimLf = "+++\n"
 )
 
-func InterfaceToConfig(in interface{}, format metadecoders.Format, w io.Writer) error {
+func InterfaceToConfig(in any, format metadecoders.Format, w io.Writer) error {
 	if in == nil {
 		return errors.New("input was nil")
 	}
@@ -77,7 +77,7 @@ func InterfaceToConfig(in interface{}, format metadecoders.Format, w io.Writer)
 	}
 }
 
-func InterfaceToFrontMatter(in interface{}, format metadecoders.Format, w io.Writer) error {
+func InterfaceToFrontMatter(in any, format metadecoders.Format, w io.Writer) error {
 	if in == nil {
 		return errors.New("input was nil")
 	}
diff --git a/parser/frontmatter_test.go b/parser/frontmatter_test.go
index dfbc695d8..7b3ffc100 100644
--- a/parser/frontmatter_test.go
+++ b/parser/frontmatter_test.go
@@ -23,33 +23,33 @@ import (
 
 func TestInterfaceToConfig(t *testing.T) {
 	cases := []struct {
-		input  interface{}
+		input  any
 		format metadecoders.Format
 		want   []byte
 		isErr  bool
 	}{
 		// TOML
-		{map[string]interface{}{}, metadecoders.TOML, nil, false},
+		{map[string]any{}, metadecoders.TOML, nil, false},
 		{
-			map[string]interface{}{"title": "test' 1"},
+			map[string]any{"title": "test' 1"},
 			metadecoders.TOML,
 			[]byte("title = \"test' 1\"\n"),
 			false,
 		},
 
 		// YAML
-		{map[string]interface{}{}, metadecoders.YAML, []byte("{}\n"), false},
+		{map[string]any{}, metadecoders.YAML, []byte("{}\n"), false},
 		{
-			map[string]interface{}{"title": "test 1"},
+			map[string]any{"title": "test 1"},
 			metadecoders.YAML,
 			[]byte("title: test 1\n"),
 			false,
 		},
 
 		// JSON
-		{map[string]interface{}{}, metadecoders.JSON, []byte("{}\n"), false},
+		{map[string]any{}, metadecoders.JSON, []byte("{}\n"), false},
 		{
-			map[string]interface{}{"title": "test 1"},
+			map[string]any{"title": "test 1"},
 			metadecoders.JSON,
 			[]byte("{\n   \"title\": \"test 1\"\n}\n"),
 			false,
@@ -57,7 +57,7 @@ func TestInterfaceToConfig(t *testing.T) {
 
 		// Errors
 		{nil, metadecoders.TOML, nil, true},
-		{map[string]interface{}{}, "foo", nil, true},
+		{map[string]any{}, "foo", nil, true},
 	}
 
 	for i, c := range cases {
diff --git a/parser/lowercase_camel_json.go b/parser/lowercase_camel_json.go
index fb283a1c4..e6605c803 100644
--- a/parser/lowercase_camel_json.go
+++ b/parser/lowercase_camel_json.go
@@ -29,7 +29,7 @@ var (
 
 // Code adapted from https://gist.github.com/piersy/b9934790a8892db1a603820c0c23e4a7
 type LowerCaseCamelJSONMarshaller struct {
-	Value interface{}
+	Value any
 }
 
 func (c LowerCaseCamelJSONMarshaller) MarshalJSON() ([]byte, error) {
diff --git a/parser/metadecoders/decoder.go b/parser/metadecoders/decoder.go
index f0dcb0856..5bf96b2d8 100644
--- a/parser/metadecoders/decoder.go
+++ b/parser/metadecoders/decoder.go
@@ -58,8 +58,8 @@ var Default = Decoder{
 
 // UnmarshalToMap will unmarshall data in format f into a new map. This is
 // what's needed for Hugo's front matter decoding.
-func (d Decoder) UnmarshalToMap(data []byte, f Format) (map[string]interface{}, error) {
-	m := make(map[string]interface{})
+func (d Decoder) UnmarshalToMap(data []byte, f Format) (map[string]any, error) {
+	m := make(map[string]any)
 	if data == nil {
 		return m, nil
 	}
@@ -71,7 +71,7 @@ func (d Decoder) UnmarshalToMap(data []byte, f Format) (map[string]interface{},
 
 // UnmarshalFileToMap is the same as UnmarshalToMap, but reads the data from
 // the given filename.
-func (d Decoder) UnmarshalFileToMap(fs afero.Fs, filename string) (map[string]interface{}, error) {
+func (d Decoder) UnmarshalFileToMap(fs afero.Fs, filename string) (map[string]any, error) {
 	format := FormatFromString(filename)
 	if format == "" {
 		return nil, errors.Errorf("%q is not a valid configuration format", filename)
@@ -85,16 +85,16 @@ func (d Decoder) UnmarshalFileToMap(fs afero.Fs, filename string) (map[string]in
 }
 
 // UnmarshalStringTo tries to unmarshal data to a new instance of type typ.
-func (d Decoder) UnmarshalStringTo(data string, typ interface{}) (interface{}, error) {
+func (d Decoder) UnmarshalStringTo(data string, typ any) (any, error) {
 	data = strings.TrimSpace(data)
 	// We only check for the possible types in YAML, JSON and TOML.
 	switch typ.(type) {
 	case string:
 		return data, nil
-	case map[string]interface{}:
+	case map[string]any:
 		format := d.FormatFromContentString(data)
 		return d.UnmarshalToMap([]byte(data), format)
-	case []interface{}:
+	case []any:
 		// A standalone slice. Let YAML handle it.
 		return d.Unmarshal([]byte(data), YAML)
 	case bool:
@@ -112,23 +112,23 @@ func (d Decoder) UnmarshalStringTo(data string, typ interface{}) (interface{}, e
 
 // Unmarshal will unmarshall data in format f into an interface{}.
 // This is what's needed for Hugo's /data handling.
-func (d Decoder) Unmarshal(data []byte, f Format) (interface{}, error) {
+func (d Decoder) Unmarshal(data []byte, f Format) (any, error) {
 	if data == nil {
 		switch f {
 		case CSV:
 			return make([][]string, 0), nil
 		default:
-			return make(map[string]interface{}), nil
+			return make(map[string]any), nil
 		}
 	}
-	var v interface{}
+	var v any
 	err := d.UnmarshalTo(data, f, &v)
 
 	return v, err
 }
 
 // UnmarshalTo unmarshals data in format f into v.
-func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
+func (d Decoder) UnmarshalTo(data []byte, f Format, v any) error {
 	var err error
 
 	switch f {
@@ -140,19 +140,19 @@ func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
 		var xmlRoot xml.Map
 		xmlRoot, err = xml.NewMapXml(data)
 
-		var xmlValue map[string]interface{}
+		var xmlValue map[string]any
 		if err == nil {
 			xmlRootName, err := xmlRoot.Root()
 			if err != nil {
 				return toFileError(f, errors.Wrap(err, "failed to unmarshal XML"))
 			}
-			xmlValue = xmlRoot[xmlRootName].(map[string]interface{})
+			xmlValue = xmlRoot[xmlRootName].(map[string]any)
 		}
 
 		switch v := v.(type) {
-		case *map[string]interface{}:
+		case *map[string]any:
 			*v = xmlValue
-		case *interface{}:
+		case *any:
 			*v = xmlValue
 		}
 	case TOML:
@@ -167,12 +167,12 @@ func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
 		// map[interface{}]interface{}. Here we recurse through the result
 		// and change all maps to map[string]interface{} like we would've
 		// gotten from `json`.
-		var ptr interface{}
+		var ptr any
 		switch v.(type) {
-		case *map[string]interface{}:
-			ptr = *v.(*map[string]interface{})
-		case *interface{}:
-			ptr = *v.(*interface{})
+		case *map[string]any:
+			ptr = *v.(*map[string]any)
+		case *any:
+			ptr = *v.(*any)
 		default:
 			// Not a map.
 		}
@@ -180,10 +180,10 @@ func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
 		if ptr != nil {
 			if mm, changed := stringifyMapKeys(ptr); changed {
 				switch v.(type) {
-				case *map[string]interface{}:
-					*v.(*map[string]interface{}) = mm.(map[string]interface{})
-				case *interface{}:
-					*v.(*interface{}) = mm
+				case *map[string]any:
+					*v.(*map[string]any) = mm.(map[string]any)
+				case *any:
+					*v.(*any) = mm
 				}
 			}
 		}
@@ -201,7 +201,7 @@ func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
 	return toFileError(f, errors.Wrap(err, "unmarshal failed"))
 }
 
-func (d Decoder) unmarshalCSV(data []byte, v interface{}) error {
+func (d Decoder) unmarshalCSV(data []byte, v any) error {
 	r := csv.NewReader(bytes.NewReader(data))
 	r.Comma = d.Delimiter
 	r.Comment = d.Comment
@@ -212,8 +212,8 @@ func (d Decoder) unmarshalCSV(data []byte, v interface{}) error {
 	}
 
 	switch v.(type) {
-	case *interface{}:
-		*v.(*interface{}) = records
+	case *any:
+		*v.(*any) = records
 	default:
 		return errors.Errorf("CSV cannot be unmarshaled into %T", v)
 
@@ -230,14 +230,14 @@ func parseORGDate(s string) string {
 	return s
 }
 
-func (d Decoder) unmarshalORG(data []byte, v interface{}) error {
+func (d Decoder) unmarshalORG(data []byte, v any) error {
 	config := org.New()
 	config.Log = jww.WARN
 	document := config.Parse(bytes.NewReader(data), "")
 	if document.Error != nil {
 		return document.Error
 	}
-	frontMatter := make(map[string]interface{}, len(document.BufferSettings))
+	frontMatter := make(map[string]any, len(document.BufferSettings))
 	for k, v := range document.BufferSettings {
 		k = strings.ToLower(k)
 		if strings.HasSuffix(k, "[]") {
@@ -252,10 +252,10 @@ func (d Decoder) unmarshalORG(data []byte, v interface{}) error {
 		}
 	}
 	switch v.(type) {
-	case *map[string]interface{}:
-		*v.(*map[string]interface{}) = frontMatter
+	case *map[string]any:
+		*v.(*map[string]any) = frontMatter
 	default:
-		*v.(*interface{}) = frontMatter
+		*v.(*any) = frontMatter
 	}
 	return nil
 }
@@ -270,22 +270,22 @@ func toFileError(f Format, err error) error {
 // described here: https://github.com/go-yaml/yaml/issues/139
 //
 // Inspired by https://github.com/stripe/stripe-mock, MIT licensed
-func stringifyMapKeys(in interface{}) (interface{}, bool) {
+func stringifyMapKeys(in any) (any, bool) {
 	switch in := in.(type) {
-	case []interface{}:
+	case []any:
 		for i, v := range in {
 			if vv, replaced := stringifyMapKeys(v); replaced {
 				in[i] = vv
 			}
 		}
-	case map[string]interface{}:
+	case map[string]any:
 		for k, v := range in {
 			if vv, changed := stringifyMapKeys(v); changed {
 				in[k] = vv
 			}
 		}
-	case map[interface{}]interface{}:
-		res := make(map[string]interface{})
+	case map[any]any:
+		res := make(map[string]any)
 		var (
 			ok  bool
 			err error
diff --git a/parser/metadecoders/decoder_test.go b/parser/metadecoders/decoder_test.go
index 8cd5513b2..7b762667c 100644
--- a/parser/metadecoders/decoder_test.go
+++ b/parser/metadecoders/decoder_test.go
@@ -45,13 +45,13 @@ func TestUnmarshalXML(t *testing.T) {
 		</channel>
 	</rss>`
 
-	expect := map[string]interface{}{
+	expect := map[string]any{
 		"-atom": "http://www.w3.org/2005/Atom", "-version": "2.0",
-		"channel": map[string]interface{}{
+		"channel": map[string]any{
 			"copyright":   "Example",
 			"description": "Example feed",
 			"generator":   "Hugo -- gohugo.io",
-			"item": map[string]interface{}{
+			"item": map[string]any{
 				"description": "Example description",
 				"guid":        "https://example.com/2021/11/30/example-title/",
 				"link":        "https://example.com/2021/11/30/example-title/",
@@ -59,7 +59,7 @@ func TestUnmarshalXML(t *testing.T) {
 				"title":       "Example title"},
 			"language":      "en-us",
 			"lastBuildDate": "Fri, 08 Jan 2021 14:44:10 +0000",
-			"link": []interface{}{"https://example.com/", map[string]interface{}{
+			"link": []any{"https://example.com/", map[string]any{
 				"-href": "https://example.com/feed.xml",
 				"-rel":  "self",
 				"-type": "application/rss+xml"}},
@@ -76,20 +76,20 @@ func TestUnmarshalXML(t *testing.T) {
 func TestUnmarshalToMap(t *testing.T) {
 	c := qt.New(t)
 
-	expect := map[string]interface{}{"a": "b"}
+	expect := map[string]any{"a": "b"}
 
 	d := Default
 
 	for i, test := range []struct {
 		data   string
 		format Format
-		expect interface{}
+		expect any
 	}{
 		{`a = "b"`, TOML, expect},
 		{`a: "b"`, YAML, expect},
 		// Make sure we get all string keys, even for YAML
-		{"a: Easy!\nb:\n  c: 2\n  d: [3, 4]", YAML, map[string]interface{}{"a": "Easy!", "b": map[string]interface{}{"c": 2, "d": []interface{}{3, 4}}}},
-		{"a:\n  true: 1\n  false: 2", YAML, map[string]interface{}{"a": map[string]interface{}{"true": 1, "false": 2}}},
+		{"a: Easy!\nb:\n  c: 2\n  d: [3, 4]", YAML, map[string]any{"a": "Easy!", "b": map[string]any{"c": 2, "d": []any{3, 4}}}},
+		{"a:\n  true: 1\n  false: 2", YAML, map[string]any{"a": map[string]any{"true": 1, "false": 2}}},
 		{`{ "a": "b" }`, JSON, expect},
 		{`<root><a>b</a></root>`, XML, expect},
 		{`#+a: b`, ORG, expect},
@@ -111,24 +111,24 @@ func TestUnmarshalToMap(t *testing.T) {
 func TestUnmarshalToInterface(t *testing.T) {
 	c := qt.New(t)
 
-	expect := map[string]interface{}{"a": "b"}
+	expect := map[string]any{"a": "b"}
 
 	d := Default
 
 	for i, test := range []struct {
 		data   string
 		format Format
-		expect interface{}
+		expect any
 	}{
-		{`[ "Brecker", "Blake", "Redman" ]`, JSON, []interface{}{"Brecker", "Blake", "Redman"}},
+		{`[ "Brecker", "Blake", "Redman" ]`, JSON, []any{"Brecker", "Blake", "Redman"}},
 		{`{ "a": "b" }`, JSON, expect},
 		{`#+a: b`, ORG, expect},
-		{`#+DATE: <2020-06-26 Fri>`, ORG, map[string]interface{}{"date": "2020-06-26"}},
+		{`#+DATE: <2020-06-26 Fri>`, ORG, map[string]any{"date": "2020-06-26"}},
 		{`a = "b"`, TOML, expect},
 		{`a: "b"`, YAML, expect},
 		{`<root><a>b</a></root>`, XML, expect},
 		{`a,b,c`, CSV, [][]string{{"a", "b", "c"}}},
-		{"a: Easy!\nb:\n  c: 2\n  d: [3, 4]", YAML, map[string]interface{}{"a": "Easy!", "b": map[string]interface{}{"c": 2, "d": []interface{}{3, 4}}}},
+		{"a: Easy!\nb:\n  c: 2\n  d: [3, 4]", YAML, map[string]any{"a": "Easy!", "b": map[string]any{"c": 2, "d": []any{3, 4}}}},
 		// errors
 		{`a = "`, TOML, false},
 	} {
@@ -149,20 +149,20 @@ func TestUnmarshalStringTo(t *testing.T) {
 
 	d := Default
 
-	expectMap := map[string]interface{}{"a": "b"}
+	expectMap := map[string]any{"a": "b"}
 
 	for i, test := range []struct {
 		data   string
-		to     interface{}
-		expect interface{}
+		to     any
+		expect any
 	}{
 		{"a string", "string", "a string"},
-		{`{ "a": "b" }`, make(map[string]interface{}), expectMap},
+		{`{ "a": "b" }`, make(map[string]any), expectMap},
 		{"32", int64(1234), int64(32)},
 		{"32", int(1234), int(32)},
 		{"3.14159", float64(1), float64(3.14159)},
-		{"[3,7,9]", []interface{}{}, []interface{}{3, 7, 9}},
-		{"[3.1,7.2,9.3]", []interface{}{}, []interface{}{3.1, 7.2, 9.3}},
+		{"[3,7,9]", []any{}, []any{3, 7, 9}},
+		{"[3.1,7.2,9.3]", []any{}, []any{3.1, 7.2, 9.3}},
 	} {
 		msg := qt.Commentf("%d: %T", i, test.to)
 		m, err := d.UnmarshalStringTo(test.data, test.to)
@@ -178,43 +178,43 @@ func TestUnmarshalStringTo(t *testing.T) {
 
 func TestStringifyYAMLMapKeys(t *testing.T) {
 	cases := []struct {
-		input    interface{}
-		want     interface{}
+		input    any
+		want     any
 		replaced bool
 	}{
 		{
-			map[interface{}]interface{}{"a": 1, "b": 2},
-			map[string]interface{}{"a": 1, "b": 2},
+			map[any]any{"a": 1, "b": 2},
+			map[string]any{"a": 1, "b": 2},
 			true,
 		},
 		{
-			map[interface{}]interface{}{"a": []interface{}{1, map[interface{}]interface{}{"b": 2}}},
-			map[string]interface{}{"a": []interface{}{1, map[string]interface{}{"b": 2}}},
+			map[any]any{"a": []any{1, map[any]any{"b": 2}}},
+			map[string]any{"a": []any{1, map[string]any{"b": 2}}},
 			true,
 		},
 		{
-			map[interface{}]interface{}{true: 1, "b": false},
-			map[string]interface{}{"true": 1, "b": false},
+			map[any]any{true: 1, "b": false},
+			map[string]any{"true": 1, "b": false},
 			true,
 		},
 		{
-			map[interface{}]interface{}{1: "a", 2: "b"},
-			map[string]interface{}{"1": "a", "2": "b"},
+			map[any]any{1: "a", 2: "b"},
+			map[string]any{"1": "a", "2": "b"},
 			true,
 		},
 		{
-			map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": 1}},
-			map[string]interface{}{"a": map[string]interface{}{"b": 1}},
+			map[any]any{"a": map[any]any{"b": 1}},
+			map[string]any{"a": map[string]any{"b": 1}},
 			true,
 		},
 		{
-			map[string]interface{}{"a": map[string]interface{}{"b": 1}},
-			map[string]interface{}{"a": map[string]interface{}{"b": 1}},
+			map[string]any{"a": map[string]any{"b": 1}},
+			map[string]any{"a": map[string]any{"b": 1}},
 			false,
 		},
 		{
-			[]interface{}{map[interface{}]interface{}{1: "a", 2: "b"}},
-			[]interface{}{map[string]interface{}{"1": "a", "2": "b"}},
+			[]any{map[any]any{1: "a", 2: "b"}},
+			[]any{map[string]any{"1": "a", "2": "b"}},
 			false,
 		},
 	}
@@ -235,18 +235,18 @@ func TestStringifyYAMLMapKeys(t *testing.T) {
 }
 
 func BenchmarkStringifyMapKeysStringsOnlyInterfaceMaps(b *testing.B) {
-	maps := make([]map[interface{}]interface{}, b.N)
+	maps := make([]map[any]any, b.N)
 	for i := 0; i < b.N; i++ {
-		maps[i] = map[interface{}]interface{}{
-			"a": map[interface{}]interface{}{
+		maps[i] = map[any]any{
+			"a": map[any]any{
 				"b": 32,
 				"c": 43,
-				"d": map[interface{}]interface{}{
+				"d": map[any]any{
 					"b": 32,
 					"c": 43,
 				},
 			},
-			"b": []interface{}{"a", "b"},
+			"b": []any{"a", "b"},
 			"c": "d",
 		}
 	}
@@ -257,16 +257,16 @@ func BenchmarkStringifyMapKeysStringsOnlyInterfaceMaps(b *testing.B) {
 }
 
 func BenchmarkStringifyMapKeysStringsOnlyStringMaps(b *testing.B) {
-	m := map[string]interface{}{
-		"a": map[string]interface{}{
+	m := map[string]any{
+		"a": map[string]any{
 			"b": 32,
 			"c": 43,
-			"d": map[string]interface{}{
+			"d": map[string]any{
 				"b": 32,
 				"c": 43,
 			},
 		},
-		"b": []interface{}{"a", "b"},
+		"b": []any{"a", "b"},
 		"c": "d",
 	}
 
@@ -277,18 +277,18 @@ func BenchmarkStringifyMapKeysStringsOnlyStringMaps(b *testing.B) {
 }
 
 func BenchmarkStringifyMapKeysIntegers(b *testing.B) {
-	maps := make([]map[interface{}]interface{}, b.N)
+	maps := make([]map[any]any, b.N)
 	for i := 0; i < b.N; i++ {
-		maps[i] = map[interface{}]interface{}{
-			1: map[interface{}]interface{}{
+		maps[i] = map[any]any{
+			1: map[any]any{
 				4: 32,
 				5: 43,
-				6: map[interface{}]interface{}{
+				6: map[any]any{
 					7: 32,
 					8: 43,
 				},
 			},
-			2: []interface{}{"a", "b"},
+			2: []any{"a", "b"},
 			3: "d",
 		}
 	}
diff --git a/parser/metadecoders/format_test.go b/parser/metadecoders/format_test.go
index d45b8c52c..db33a7d8c 100644
--- a/parser/metadecoders/format_test.go
+++ b/parser/metadecoders/format_test.go
@@ -64,7 +64,7 @@ func TestFormatFromContentString(t *testing.T) {
 
 	for i, test := range []struct {
 		data   string
-		expect interface{}
+		expect any
 	}{
 		{`foo = "bar"`, TOML},
 		{`   foo = "bar"`, TOML},
diff --git a/parser/pageparser/item.go b/parser/pageparser/item.go
index 9224fba94..f23341ea8 100644
--- a/parser/pageparser/item.go
+++ b/parser/pageparser/item.go
@@ -33,7 +33,7 @@ func (i Item) ValStr() string {
 	return string(i.Val)
 }
 
-func (i Item) ValTyped() interface{} {
+func (i Item) ValTyped() any {
 	str := i.ValStr()
 	if i.isString {
 		// A quoted value that is a string even if it looks like a number etc.
diff --git a/parser/pageparser/pagelexer.go b/parser/pageparser/pagelexer.go
index 266fb50f5..20965ac0e 100644
--- a/parser/pageparser/pagelexer.go
+++ b/parser/pageparser/pagelexer.go
@@ -176,7 +176,7 @@ func (l *pageLexer) ignore() {
 var lf = []byte("\n")
 
 // nil terminates the parser
-func (l *pageLexer) errorf(format string, args ...interface{}) stateFunc {
+func (l *pageLexer) errorf(format string, args ...any) stateFunc {
 	l.items = append(l.items, Item{tError, l.start, []byte(fmt.Sprintf(format, args...)), true})
 	return nil
 }
diff --git a/parser/pageparser/pageparser.go b/parser/pageparser/pageparser.go
index 7bfcfd698..3338e063e 100644
--- a/parser/pageparser/pageparser.go
+++ b/parser/pageparser/pageparser.go
@@ -42,7 +42,7 @@ func Parse(r io.Reader, cfg Config) (Result, error) {
 
 type ContentFrontMatter struct {
 	Content           []byte
-	FrontMatter       map[string]interface{}
+	FrontMatter       map[string]any
 	FrontMatterFormat metadecoders.Format
 }