Upgrade modernize version to 0.21.0 (#7159)

SungJin1212 · web-flow · commit b9f9f77e3d5a · 2025-12-15T10:04:27.000-08:00
Signed-off-by: SungJin1212 &lt;tjdwls1201@gmail.com&gt;
diff --git a/Makefile b/Makefile
@@ -252,7 +252,7 @@ web-deploy:
 	./tools/website/web-deploy.sh
 
 modernize:
-	go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@v0.20.0 -fix ./...
+	GOTOOLCHAIN=auto go run golang.org/x/tools/gopls/internal/analysis/modernize/cmd/modernize@v0.21.0 -fix ./...
 
 # Generates the config file documentation.
 doc: clean-doc
diff --git a/pkg/alertmanager/api.go b/pkg/alertmanager/api.go
@@ -344,74 +344,74 @@ func validateAlertmanagerConfig(cfg any) error {
 	// Check if the input config is a data type for which we have a specific validation.
 	// At this point the value can't be a pointer anymore.
 	switch t {
-	case reflect.TypeOf(config.GlobalConfig{}):
+	case reflect.TypeFor[config.GlobalConfig]():
 		if err := validateGlobalConfig(v.Interface().(config.GlobalConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(commoncfg.HTTPClientConfig{}):
+	case reflect.TypeFor[commoncfg.HTTPClientConfig]():
 		if err := validateReceiverHTTPConfig(v.Interface().(commoncfg.HTTPClientConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(config.OpsGenieConfig{}):
+	case reflect.TypeFor[config.OpsGenieConfig]():
 		if err := validateOpsGenieConfig(v.Interface().(config.OpsGenieConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(commoncfg.TLSConfig{}):
+	case reflect.TypeFor[commoncfg.TLSConfig]():
 		if err := validateReceiverTLSConfig(v.Interface().(commoncfg.TLSConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(config.SlackConfig{}):
+	case reflect.TypeFor[config.SlackConfig]():
 		if err := validateSlackConfig(v.Interface().(config.SlackConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(config.VictorOpsConfig{}):
+	case reflect.TypeFor[config.VictorOpsConfig]():
 		if err := validateVictorOpsConfig(v.Interface().(config.VictorOpsConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(config.PagerdutyConfig{}):
+	case reflect.TypeFor[config.PagerdutyConfig]():
 		if err := validatePagerdutyConfig(v.Interface().(config.PagerdutyConfig)); err != nil {
 			return err
 		}
 
-	case reflect.TypeOf(config.WebhookConfig{}):
+	case reflect.TypeFor[config.WebhookConfig]():
 		if err := validateWebhookConfig(v.Interface().(config.WebhookConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.PushoverConfig{}):
+	case reflect.TypeFor[config.PushoverConfig]():
 		if err := validatePushOverConfig(v.Interface().(config.PushoverConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.TelegramConfig{}):
+	case reflect.TypeFor[config.TelegramConfig]():
 		if err := validateTelegramConfig(v.Interface().(config.TelegramConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.MSTeamsConfig{}):
+	case reflect.TypeFor[config.MSTeamsConfig]():
 		if err := validateMSTeamsConfig(v.Interface().(config.MSTeamsConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.MSTeamsV2Config{}):
+	case reflect.TypeFor[config.MSTeamsV2Config]():
 		if err := validateMSTeamsV2Config(v.Interface().(config.MSTeamsV2Config)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.RocketchatConfig{}):
+	case reflect.TypeFor[config.RocketchatConfig]():
 		if err := validateRocketChatConfig(v.Interface().(config.RocketchatConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.DiscordConfig{}):
+	case reflect.TypeFor[config.DiscordConfig]():
 		if err := validateDiscordConfig(v.Interface().(config.DiscordConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.EmailConfig{}):
+	case reflect.TypeFor[config.EmailConfig]():
 		if err := validateEmailConfig(v.Interface().(config.EmailConfig)); err != nil {
 			return err
 		}
-	case reflect.TypeOf(config.IncidentioConfig{}):
+	case reflect.TypeFor[config.IncidentioConfig]():
 		if err := validateIncidentIOConfig(v.Interface().(config.IncidentioConfig)); err != nil {
 			return err
 		}
diff --git a/pkg/alertmanager/state_replication.go b/pkg/alertmanager/state_replication.go
@@ -327,9 +327,9 @@ func (c *stateChannel) Broadcast(b []byte) {
 
 // getStateTypeFromKey used for get the state type out of the state key.
 func getStateTypeFromKey(key string) string {
-	index := strings.IndexByte(key, ':')
-	if index < 0 {
+	before, _, ok := strings.Cut(key, ":")
+	if !ok {
 		return key
 	}
-	return key[:index]
+	return before
 }
diff --git a/pkg/ingester/ingester_test.go b/pkg/ingester/ingester_test.go
@@ -6309,13 +6309,13 @@ func TestExpendedPostingsCacheMatchers(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		testName := ""
+		var testName strings.Builder
 		for _, matcher := range tc.matchers {
 			t, _ := matcher.MatcherType()
-			testName += matcher.Name + t.String() + matcher.Value + "|"
+			testName.WriteString(matcher.Name + t.String() + matcher.Value + "|")
 
 		}
-		t.Run(fmt.Sprintf("%v", testName), func(t *testing.T) {
+		t.Run(fmt.Sprintf("%v", testName.String()), func(t *testing.T) {
 			for _, r := range ranges {
 				t.Run(fmt.Sprintf("start=%v,end=%v", r.startTs, r.endTs), func(t *testing.T) {
 					db.postingCache.Clear()
diff --git a/pkg/util/validation/limits_test.go b/pkg/util/validation/limits_test.go
@@ -231,7 +231,7 @@ func TestLimitsLoadingFromJson(t *testing.T) {
 }
 
 func TestLimitsTagsYamlMatchJson(t *testing.T) {
-	limits := reflect.TypeOf(Limits{})
+	limits := reflect.TypeFor[Limits]()
 	n := limits.NumField()
 	var mismatch []string
 
@@ -301,8 +301,8 @@ max_query_length: 1s
 }
 
 func TestLimitsAlwaysUsesPromDuration(t *testing.T) {
-	stdlibDuration := reflect.TypeOf(time.Duration(0))
-	limits := reflect.TypeOf(Limits{})
+	stdlibDuration := reflect.TypeFor[time.Duration]()
+	limits := reflect.TypeFor[Limits]()
 	n := limits.NumField()
 	var badDurationType []string
 
diff --git a/tools/doc-generator/main.go b/tools/doc-generator/main.go
@@ -57,152 +57,152 @@ var (
 	rootBlocks = []rootBlock{
 		{
 			name:       "alertmanager_config",
-			structType: reflect.TypeOf(alertmanager.MultitenantAlertmanagerConfig{}),
+			structType: reflect.TypeFor[alertmanager.MultitenantAlertmanagerConfig](),
 			desc:       "The alertmanager_config configures the Cortex alertmanager.",
 		},
 		{
 			name:       "alertmanager_storage_config",
-			structType: reflect.TypeOf(alertstore.Config{}),
+			structType: reflect.TypeFor[alertstore.Config](),
 			desc:       "The alertmanager_storage_config configures the Cortex alertmanager storage backend.",
 		},
 		{
 			name:       "blocks_storage_config",
-			structType: reflect.TypeOf(tsdb.BlocksStorageConfig{}),
+			structType: reflect.TypeFor[tsdb.BlocksStorageConfig](),
 			desc:       "The blocks_storage_config configures the blocks storage.",
 		},
 		{
 			name:       "compactor_config",
-			structType: reflect.TypeOf(compactor.Config{}),
+			structType: reflect.TypeFor[compactor.Config](),
 			desc:       "The compactor_config configures the compactor for the blocks storage.",
 		},
 		{
 			name:       "configs_config",
-			structType: reflect.TypeOf(configs.Config{}),
+			structType: reflect.TypeFor[configs.Config](),
 			desc:       "The configs_config configures the Cortex Configs DB and API.",
 		},
 		{
 			name:       "configstore_config",
-			structType: reflect.TypeOf(config_client.Config{}),
+			structType: reflect.TypeFor[config_client.Config](),
 			desc:       "The configstore_config configures the config database storing rules and alerts, and is used by the Cortex alertmanager.",
 		},
 		{
 			name:       "consul_config",
-			structType: reflect.TypeOf(consul.Config{}),
+			structType: reflect.TypeFor[consul.Config](),
 			desc:       "The consul_config configures the consul client.",
 		},
 		{
 			name:       "distributor_config",
-			structType: reflect.TypeOf(distributor.Config{}),
+			structType: reflect.TypeFor[distributor.Config](),
 			desc:       "The distributor_config configures the Cortex distributor.",
 		},
 		{
 			name:       "etcd_config",
-			structType: reflect.TypeOf(etcd.Config{}),
+			structType: reflect.TypeFor[etcd.Config](),
 			desc:       "The etcd_config configures the etcd client.",
 		},
 		{
 			name:       "fifo_cache_config",
-			structType: reflect.TypeOf(cache.FifoCacheConfig{}),
+			structType: reflect.TypeFor[cache.FifoCacheConfig](),
 			desc:       "The fifo_cache_config configures the local in-memory cache.",
 		},
 		{
 			name:       "flusher_config",
-			structType: reflect.TypeOf(flusher.Config{}),
+			structType: reflect.TypeFor[flusher.Config](),
 			desc:       "The flusher_config configures the WAL flusher target, used to manually run one-time flushes when scaling down ingesters.",
 		},
 		{
 			name:       "frontend_worker_config",
-			structType: reflect.TypeOf(querier_worker.Config{}),
+			structType: reflect.TypeFor[querier_worker.Config](),
 			desc:       "The frontend_worker_config configures the worker - running within the Cortex querier - picking up and executing queries enqueued by the query-frontend or query-scheduler.",
 		},
 		{
 			name:       "ingester_config",
-			structType: reflect.TypeOf(ingester.Config{}),
+			structType: reflect.TypeFor[ingester.Config](),
 			desc:       "The ingester_config configures the Cortex ingester.",
 		},
 		{
 			name:       "ingester_client_config",
-			structType: reflect.TypeOf(client.Config{}),
+			structType: reflect.TypeFor[client.Config](),
 			desc:       "The ingester_client_config configures how the Cortex distributors connect to the ingesters.",
 		},
 		{
 			name:       "limits_config",
-			structType: reflect.TypeOf(validation.Limits{}),
+			structType: reflect.TypeFor[validation.Limits](),
 			desc:       "The limits_config configures default and per-tenant limits imposed by Cortex services (ie. distributor, ingester, ...).",
 		},
 		{
 			name:       "memberlist_config",
-			structType: reflect.TypeOf(memberlist.KVConfig{}),
+			structType: reflect.TypeFor[memberlist.KVConfig](),
 			desc:       "The memberlist_config configures the Gossip memberlist.",
 		},
 		{
 			name:       "memcached_config",
-			structType: reflect.TypeOf(cache.MemcachedConfig{}),
+			structType: reflect.TypeFor[cache.MemcachedConfig](),
 			desc:       "The memcached_config block configures how data is stored in Memcached (ie. expiration).",
 		},
 		{
 			name:       "memcached_client_config",
-			structType: reflect.TypeOf(cache.MemcachedClientConfig{}),
+			structType: reflect.TypeFor[cache.MemcachedClientConfig](),
 			desc:       "The memcached_client_config configures the client used to connect to Memcached.",
 		},
 		{
 			name:       "querier_config",
-			structType: reflect.TypeOf(querier.Config{}),
+			structType: reflect.TypeFor[querier.Config](),
 			desc:       "The querier_config configures the Cortex querier.",
 		},
 		{
 			name:       "query_frontend_config",
-			structType: reflect.TypeOf(frontend.CombinedFrontendConfig{}),
+			structType: reflect.TypeFor[frontend.CombinedFrontendConfig](),
 			desc:       "The query_frontend_config configures the Cortex query-frontend.",
 		},
 		{
 			name:       "query_range_config",
-			structType: reflect.TypeOf(queryrange.Config{}),
+			structType: reflect.TypeFor[queryrange.Config](),
 			desc:       "The query_range_config configures the query splitting and caching in the Cortex query-frontend.",
 		},
 		{
 			name:       "redis_config",
-			structType: reflect.TypeOf(cache.RedisConfig{}),
+			structType: reflect.TypeFor[cache.RedisConfig](),
 			desc:       "The redis_config configures the Redis backend cache.",
 		},
 		{
 			name:       "ruler_config",
-			structType: reflect.TypeOf(ruler.Config{}),
+			structType: reflect.TypeFor[ruler.Config](),
 			desc:       "The ruler_config configures the Cortex ruler.",
 		},
 		{
 			name:       "ruler_storage_config",
-			structType: reflect.TypeOf(rulestore.Config{}),
+			structType: reflect.TypeFor[rulestore.Config](),
 			desc:       "The ruler_storage_config configures the Cortex ruler storage backend.",
 		},
 		{
 			name:       "runtime_configuration_storage_config",
-			structType: reflect.TypeOf(runtimeconfig.Config{}),
+			structType: reflect.TypeFor[runtimeconfig.Config](),
 			desc:       "The runtime_configuration_storage_config configures the storage backend for the runtime configuration file.",
 		},
 		{
 			name:       "s3_sse_config",
-			structType: reflect.TypeOf(s3.SSEConfig{}),
+			structType: reflect.TypeFor[s3.SSEConfig](),
 			desc:       "The s3_sse_config configures the S3 server-side encryption.",
 		},
 		{
 			name:       "server_config",
-			structType: reflect.TypeOf(server.Config{}),
+			structType: reflect.TypeFor[server.Config](),
 			desc:       "The server_config configures the HTTP and gRPC server of the launched service(s).",
 		},
 		{
 			name:       "storage_config",
-			structType: reflect.TypeOf(storage.Config{}),
+			structType: reflect.TypeFor[storage.Config](),
 			desc:       "The storage_config configures the storage type Cortex uses.",
 		},
 		{
 			name:       "store_gateway_config",
-			structType: reflect.TypeOf(storegateway.Config{}),
+			structType: reflect.TypeFor[storegateway.Config](),
 			desc:       "The store_gateway_config configures the store-gateway service used by the blocks storage.",
 		},
 		{
 			name:       "tracing_config",
-			structType: reflect.TypeOf(tracing.Config{}),
+			structType: reflect.TypeFor[tracing.Config](),
 			desc:       "The tracing_config configures backends cortex uses.",
 		},
 	}
diff --git a/tools/doc-generator/parser.go b/tools/doc-generator/parser.go
@@ -361,7 +361,7 @@ func getFieldFlag(parent reflect.Type, field reflect.StructField, fieldValue ref
 }
 
 func getCustomFieldEntry(parent reflect.Type, field reflect.StructField, fieldValue reflect.Value, flags map[uintptr]*flag.Flag) (*configEntry, error) {
-	if field.Type == reflect.TypeOf(logging.Level{}) || field.Type == reflect.TypeOf(logging.Format{}) {
+	if field.Type == reflect.TypeFor[logging.Level]() || field.Type == reflect.TypeFor[logging.Format]() {
 		fieldFlag, err := getFieldFlag(parent, field, fieldValue, flags)
 		if err != nil {
 			return nil, err
@@ -377,7 +377,7 @@ func getCustomFieldEntry(parent reflect.Type, field reflect.StructField, fieldVa
 			fieldDefault: fieldFlag.DefValue,
 		}, nil
 	}
-	if field.Type == reflect.TypeOf(flagext.URLValue{}) {
+	if field.Type == reflect.TypeFor[flagext.URLValue]() {
 		fieldFlag, err := getFieldFlag(parent, field, fieldValue, flags)
 		if err != nil {
 			return nil, err
@@ -393,7 +393,7 @@ func getCustomFieldEntry(parent reflect.Type, field reflect.StructField, fieldVa
 			fieldDefault: fieldFlag.DefValue,
 		}, nil
 	}
-	if field.Type == reflect.TypeOf(flagext.Secret{}) {
+	if field.Type == reflect.TypeFor[flagext.Secret]() {
 		fieldFlag, err := getFieldFlag(parent, field, fieldValue, flags)
 		if err != nil {
 			return nil, err
@@ -409,7 +409,7 @@ func getCustomFieldEntry(parent reflect.Type, field reflect.StructField, fieldVa
 			fieldDefault: fieldFlag.DefValue,
 		}, nil
 	}
-	if field.Type == reflect.TypeOf(model.Duration(0)) {
+	if field.Type == reflect.TypeFor[model.Duration]() {
 		fieldFlag, err := getFieldFlag(parent, field, fieldValue, flags)
 		if err != nil {
 			return nil, err
@@ -429,7 +429,7 @@ func getCustomFieldEntry(parent reflect.Type, field reflect.StructField, fieldVa
 			fieldDefault: fieldFlag.DefValue,
 		}, nil
 	}
-	if field.Type == reflect.TypeOf(flagext.Time{}) {
+	if field.Type == reflect.TypeFor[flagext.Time]() {
 		fieldFlag, err := getFieldFlag(parent, field, fieldValue, flags)
 		if err != nil {
 			return nil, err

Original file line number	Diff line number	Diff line change
`@@ -344,74 +344,74 @@ func validateAlertmanagerConfig(cfg any) error {`
`344`	`344`	`// Check if the input config is a data type for which we have a specific validation.`
`345`	`345`	`// At this point the value can't be a pointer anymore.`
`346`	`346`	`switch t {`
`347`		`- case reflect.TypeOf(config.GlobalConfig{}):`
	`347`	`+ case reflect.TypeFor[config.GlobalConfig]():`
`348`	`348`	`if err := validateGlobalConfig(v.Interface().(config.GlobalConfig)); err != nil {`
`349`	`349`	`return err`
`350`	`350`	`}`
`351`	`351`
`352`		`- case reflect.TypeOf(commoncfg.HTTPClientConfig{}):`
	`352`	`+ case reflect.TypeFor[commoncfg.HTTPClientConfig]():`
`353`	`353`	`if err := validateReceiverHTTPConfig(v.Interface().(commoncfg.HTTPClientConfig)); err != nil {`
`354`	`354`	`return err`
`355`	`355`	`}`
`356`	`356`
`357`		`- case reflect.TypeOf(config.OpsGenieConfig{}):`
	`357`	`+ case reflect.TypeFor[config.OpsGenieConfig]():`
`358`	`358`	`if err := validateOpsGenieConfig(v.Interface().(config.OpsGenieConfig)); err != nil {`
`359`	`359`	`return err`
`360`	`360`	`}`
`361`	`361`
`362`		`- case reflect.TypeOf(commoncfg.TLSConfig{}):`
	`362`	`+ case reflect.TypeFor[commoncfg.TLSConfig]():`
`363`	`363`	`if err := validateReceiverTLSConfig(v.Interface().(commoncfg.TLSConfig)); err != nil {`
`364`	`364`	`return err`
`365`	`365`	`}`
`366`	`366`
`367`		`- case reflect.TypeOf(config.SlackConfig{}):`
	`367`	`+ case reflect.TypeFor[config.SlackConfig]():`
`368`	`368`	`if err := validateSlackConfig(v.Interface().(config.SlackConfig)); err != nil {`
`369`	`369`	`return err`
`370`	`370`	`}`
`371`	`371`
`372`		`- case reflect.TypeOf(config.VictorOpsConfig{}):`
	`372`	`+ case reflect.TypeFor[config.VictorOpsConfig]():`
`373`	`373`	`if err := validateVictorOpsConfig(v.Interface().(config.VictorOpsConfig)); err != nil {`
`374`	`374`	`return err`
`375`	`375`	`}`
`376`	`376`
`377`		`- case reflect.TypeOf(config.PagerdutyConfig{}):`
	`377`	`+ case reflect.TypeFor[config.PagerdutyConfig]():`
`378`	`378`	`if err := validatePagerdutyConfig(v.Interface().(config.PagerdutyConfig)); err != nil {`
`379`	`379`	`return err`
`380`	`380`	`}`
`381`	`381`
`382`		`- case reflect.TypeOf(config.WebhookConfig{}):`
	`382`	`+ case reflect.TypeFor[config.WebhookConfig]():`
`383`	`383`	`if err := validateWebhookConfig(v.Interface().(config.WebhookConfig)); err != nil {`
`384`	`384`	`return err`
`385`	`385`	`}`
`386`		`- case reflect.TypeOf(config.PushoverConfig{}):`
	`386`	`+ case reflect.TypeFor[config.PushoverConfig]():`
`387`	`387`	`if err := validatePushOverConfig(v.Interface().(config.PushoverConfig)); err != nil {`
`388`	`388`	`return err`
`389`	`389`	`}`
`390`		`- case reflect.TypeOf(config.TelegramConfig{}):`
	`390`	`+ case reflect.TypeFor[config.TelegramConfig]():`
`391`	`391`	`if err := validateTelegramConfig(v.Interface().(config.TelegramConfig)); err != nil {`
`392`	`392`	`return err`
`393`	`393`	`}`
`394`		`- case reflect.TypeOf(config.MSTeamsConfig{}):`
	`394`	`+ case reflect.TypeFor[config.MSTeamsConfig]():`
`395`	`395`	`if err := validateMSTeamsConfig(v.Interface().(config.MSTeamsConfig)); err != nil {`
`396`	`396`	`return err`
`397`	`397`	`}`
`398`		`- case reflect.TypeOf(config.MSTeamsV2Config{}):`
	`398`	`+ case reflect.TypeFor[config.MSTeamsV2Config]():`
`399`	`399`	`if err := validateMSTeamsV2Config(v.Interface().(config.MSTeamsV2Config)); err != nil {`
`400`	`400`	`return err`
`401`	`401`	`}`
`402`		`- case reflect.TypeOf(config.RocketchatConfig{}):`
	`402`	`+ case reflect.TypeFor[config.RocketchatConfig]():`
`403`	`403`	`if err := validateRocketChatConfig(v.Interface().(config.RocketchatConfig)); err != nil {`
`404`	`404`	`return err`
`405`	`405`	`}`
`406`		`- case reflect.TypeOf(config.DiscordConfig{}):`
	`406`	`+ case reflect.TypeFor[config.DiscordConfig]():`
`407`	`407`	`if err := validateDiscordConfig(v.Interface().(config.DiscordConfig)); err != nil {`
`408`	`408`	`return err`
`409`	`409`	`}`
`410`		`- case reflect.TypeOf(config.EmailConfig{}):`
	`410`	`+ case reflect.TypeFor[config.EmailConfig]():`
`411`	`411`	`if err := validateEmailConfig(v.Interface().(config.EmailConfig)); err != nil {`
`412`	`412`	`return err`
`413`	`413`	`}`
`414`		`- case reflect.TypeOf(config.IncidentioConfig{}):`
	`414`	`+ case reflect.TypeFor[config.IncidentioConfig]():`
`415`	`415`	`if err := validateIncidentIOConfig(v.Interface().(config.IncidentioConfig)); err != nil {`
`416`	`416`	`return err`
`417`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -327,9 +327,9 @@ func (c *stateChannel) Broadcast(b []byte) {`
`327`	`327`
`328`	`328`	`// getStateTypeFromKey used for get the state type out of the state key.`
`329`	`329`	`func getStateTypeFromKey(key string) string {`
`330`		`- index := strings.IndexByte(key, ':')`
`331`		`- if index < 0 {`
	`330`	`+ before, _, ok := strings.Cut(key, ":")`
	`331`	`+ if !ok {`
`332`	`332`	`return key`
`333`	`333`	`}`
`334`		`- return key[:index]`
	`334`	`+ return before`
`335`	`335`	`}`