Don't require a function to init non-configurable analyzers

Author: JoelSpeed

docs/new-linter.md

@@ -39,15 +39,10 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name, // A constant containing the name of the linter. This should be lowercase.
-		initAnalyzer, // A function that returns the initialized Analyzer.
+		Analyzer, // An *analysis.Analyzer variable that is the linter.
 		true, // Whether the linter is enabled by default.
 	)
 }
-
-// initAnalyzer returns the intialized Analyzer.
-func initAnalyzer(_ any) (*analysis.Analyzer, error) {
-	return Analyzer, nil
-}
 ```
 
 This pattern allows the linter to be registered with the KAL registry, and allows the linter to be initialized.
@@ -60,7 +55,6 @@ Once imported, the analyzer will be included in the linter builds.
 
 Where the linter requires configuration, a slightly different pattern is used in `initializer.go`.
 This time, use `NewConfigurableInitializer` instead of `NewInitializer` and pass in a function to validate the linter configuration.
-You will also need to pass a function to initialize a new pointer to the configuration struct for the linter.
 
 ```go
 
@@ -75,23 +69,17 @@ func Initializer() initializer.AnalyzerInitializer {
 		name, // A constant containing the name of the linter. This should be lowercase.
 		initAnalyzer, // A function that returns the initialized Analyzer.
 		true, // Whether the linter is enabled by default.
-		func() any { return &Config{} }, // A function that returns a new pointer to the configuration struct for the linter.
 		validateLintersConfig, // A function that validates the linter configuration.
 	)
 }
 
 // initAnalyzer returns the intialized Analyzer.
-func initAnalyzer(cfg any) (*analysis.Analyzer, error) {
-    cc, ok := cfg.(*ConditionsConfig)
-	if !ok {
-		return nil, fmt.Errorf("failed to initialize conditions analyzer: %w", initializer.NewIncorrectTypeError(cfg))
-	}
-
-	return newAnalyzer(), nil
+func initAnalyzer(cfg *Config) (*analysis.Analyzer, error) {
+	return newAnalyzer(cfg), nil
 }
 
 // validateLintersConfig validates the linter configuration.
-func validateLintersConfig(cfg any, fldPath *field.Path) field.ErrorList {
+func validateLintersConfig(cfg *Config, fldPath *field.Path) field.ErrorList {
 	... // Validate the linter configuration.
 }
 ```

pkg/analysis/commentstart/initializer.go

@@ -16,7 +16,6 @@ limitations under the License.
 package commentstart
 
 import (
-	"golang.org/x/tools/go/analysis"
 	kalanalysis "sigs.k8s.io/kube-api-linter/pkg/analysis"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
 )
@@ -30,12 +29,7 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name,
-		initAnalyzer,
+		Analyzer,
 		true,
 	)
 }
-
-// Init returns the intialized Analyzer.
-func initAnalyzer(_ any) (*analysis.Analyzer, error) {
-	return Analyzer, nil
-}

pkg/analysis/conditions/analyzer.go

@@ -69,6 +69,10 @@ type analyzer struct {
 
 // newAnalyzer creates a new analyzer.
 func newAnalyzer(cfg *ConditionsConfig) *analysis.Analyzer {
+	if cfg == nil {
+		cfg = &ConditionsConfig{}
+	}
+
 	defaultConfig(cfg)
 
 	a := &analyzer{

pkg/analysis/conditions/initializer.go

@@ -35,25 +35,18 @@ func Initializer() initializer.AnalyzerInitializer {
 		name,
 		initAnalyzer,
 		true,
-		func() any { return &ConditionsConfig{} },
 		validateConfig,
 	)
 }
 
-func initAnalyzer(cfg any) (*analysis.Analyzer, error) {
-	cc, ok := cfg.(*ConditionsConfig)
-	if !ok {
-		return nil, fmt.Errorf("failed to initialize conditions analyzer: %w", initializer.NewIncorrectTypeError(cfg))
-	}
-
+func initAnalyzer(cc *ConditionsConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cc), nil
 }
 
 // validateConfig implements validation of the conditions linter config.
-func validateConfig(cfg any, fldPath *field.Path) field.ErrorList {
-	cc, ok := cfg.(*ConditionsConfig)
-	if !ok {
-		return field.ErrorList{field.InternalError(fldPath, initializer.NewIncorrectTypeError(cfg))}
+func validateConfig(cc *ConditionsConfig, fldPath *field.Path) field.ErrorList {
+	if cc == nil {
+		return field.ErrorList{}
 	}
 
 	fieldErrors := field.ErrorList{}

pkg/analysis/duplicatemarkers/initializer.go

@@ -16,7 +16,6 @@ limitations under the License.
 package duplicatemarkers
 
 import (
-	"golang.org/x/tools/go/analysis"
 	kalanalysis "sigs.k8s.io/kube-api-linter/pkg/analysis"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
 )
@@ -30,12 +29,7 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name,
-		initAnalyzer,
+		Analyzer,
 		true,
 	)
 }
-
-// initAnalyzer returns the intialized Analyzer.
-func initAnalyzer(_ any) (*analysis.Analyzer, error) {
-	return Analyzer, nil
-}

pkg/analysis/initializer/initializer.go

@@ -16,15 +16,18 @@ limitations under the License.
 package initializer
 
 import (
+	"fmt"
+	"reflect"
+
 	"golang.org/x/tools/go/analysis"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 )
 
 // InitializerFunc is a function that initializes an Analyzer.
-type InitializerFunc func(any) (*analysis.Analyzer, error)
+type InitializerFunc[T any] func(T) (*analysis.Analyzer, error)
 
 // ValidateFunc is a function that validates the configuration for an Analyzer.
-type ValidateFunc func(any, *field.Path) field.ErrorList
+type ValidateFunc[T any] func(T, *field.Path) field.ErrorList
 
 // AnalyzerInitializer is used to initialize analyzers.
 type AnalyzerInitializer interface {
@@ -54,67 +57,77 @@ type ConfigurableAnalyzerInitializer interface {
 }
 
 // NewInitializer construct a new initializer for initializing an Analyzer.
-func NewInitializer(name string, initFunc InitializerFunc, isDefault bool) AnalyzerInitializer {
-	return initializer{
+func NewInitializer(name string, analyzer *analysis.Analyzer, isDefault bool) AnalyzerInitializer {
+	return initializer[any]{
 		name:      name,
-		initFunc:  initFunc,
+		initFunc:  func(any) (*analysis.Analyzer, error) { return analyzer, nil },
 		isDefault: isDefault,
 	}
 }
 
 // NewConfigurableInitializer constructs a new initializer for intializing a
 // configurable Analyzer.
-func NewConfigurableInitializer(name string, initFunc InitializerFunc, isDefault bool, configType func() any, validateFunc ValidateFunc) ConfigurableAnalyzerInitializer {
-	return configurableInitializer{
-		initializer: initializer{
+func NewConfigurableInitializer[T any](name string, initFunc InitializerFunc[T], isDefault bool, validateFunc ValidateFunc[T]) ConfigurableAnalyzerInitializer {
+	return configurableInitializer[T]{
+		initializer: initializer[T]{
 			name:      name,
 			initFunc:  initFunc,
 			isDefault: isDefault,
 		},
-		configTypeFunc: configType,
-		validateFunc:   validateFunc,
+		validateFunc: validateFunc,
 	}
 }
 
-type initializer struct {
+type initializer[T any] struct {
 	name      string
-	initFunc  InitializerFunc
+	initFunc  InitializerFunc[T]
 	isDefault bool
 }
 
 // Name returns the name of the initializer.
-func (i initializer) Name() string {
+func (i initializer[T]) Name() string {
 	return i.name
 }
 
 // Init returns a newly initializr analyzer.
-func (i initializer) Init(_ any) (*analysis.Analyzer, error) {
-	return i.initFunc(nil)
+func (i initializer[T]) Init(_ any) (*analysis.Analyzer, error) {
+	var cfg T
+
+	return i.initFunc(cfg)
 }
 
 // Default determines whether this initializer should be enabled by default or not.
-func (i initializer) Default() bool {
+func (i initializer[T]) Default() bool {
 	return i.isDefault
 }
 
-type configurableInitializer struct {
-	initializer
+type configurableInitializer[T any] struct {
+	initializer[T]
 
-	configTypeFunc func() any
-	validateFunc   ValidateFunc
+	validateFunc ValidateFunc[T]
 }
 
 // Init returns a newly initialized analyzer.
-func (i configurableInitializer) Init(cfg any) (*analysis.Analyzer, error) {
-	return i.initFunc(cfg)
+func (i configurableInitializer[T]) Init(cfg any) (*analysis.Analyzer, error) {
+	cfgT, ok := cfg.(T)
+	if !ok {
+		return nil, fmt.Errorf("failed to initialize analyzer: %w", NewIncorrectTypeError(cfg))
+	}
+
+	return i.initFunc(cfgT)
 }
 
 // ConfigType returns the type of the config for the linter.
-func (i configurableInitializer) ConfigType() any {
-	return i.configTypeFunc()
+func (i configurableInitializer[T]) ConfigType() any {
+	return reflect.New(reflect.TypeOf(*new(T)).Elem()).Interface()
 }
 
 // ValidateConfig validates the configuration for the initializer.
-func (i configurableInitializer) ValidateConfig(cfg any, fld *field.Path) field.ErrorList {
-	return i.validateFunc(cfg, fld)
+func (i configurableInitializer[T]) ValidateConfig(cfg any, fld *field.Path) field.ErrorList {
+	cfgT, ok := cfg.(T)
+	if !ok {
+		return field.ErrorList{field.InternalError(fld, NewIncorrectTypeError(cfg))}
+	}
+
+	return i.validateFunc(cfgT, fld)
 }

pkg/analysis/integers/initializer.go

@@ -16,7 +16,6 @@ limitations under the License.
 package integers
 
 import (
-	"golang.org/x/tools/go/analysis"
 	kalanalysis "sigs.k8s.io/kube-api-linter/pkg/analysis"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
 )
@@ -30,11 +29,7 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name,
-		initAnalyzer,
+		Analyzer,
 		true,
 	)
 }
-
-func initAnalyzer(_ any) (*analysis.Analyzer, error) {
-	return Analyzer, nil
-}

pkg/analysis/jsontags/analyzer.go

@@ -42,6 +42,10 @@ type analyzer struct {
 
 // newAnalyzer creates a new analyzer with the given json tag regex.
 func newAnalyzer(cfg *JSONTagsConfig) (*analysis.Analyzer, error) {
+	if cfg == nil {
+		cfg = &JSONTagsConfig{}
+	}
+
 	defaultConfig(cfg)
 
 	jsonTagRegex, err := regexp.Compile(cfg.JSONTagRegex)

pkg/analysis/jsontags/initializer.go

@@ -36,25 +36,18 @@ func Initializer() initializer.AnalyzerInitializer {
 		name,
 		initAnalyzer,
 		true,
-		func() any { return &JSONTagsConfig{} },
 		validateConfig,
 	)
 }
 
-func initAnalyzer(cfg any) (*analysis.Analyzer, error) {
-	jtc, ok := cfg.(*JSONTagsConfig)
-	if !ok {
-		return nil, fmt.Errorf("failed to initialize JSON tags analyzer: %w", initializer.NewIncorrectTypeError(cfg))
-	}
-
+func initAnalyzer(jtc *JSONTagsConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(jtc)
 }
 
 // validateConfig is used to validate the configuration in the config.JSONTagsConfig struct.
-func validateConfig(cfg any, fldPath *field.Path) field.ErrorList {
-	jtc, ok := cfg.(*JSONTagsConfig)
-	if !ok {
-		return field.ErrorList{field.InternalError(fldPath, initializer.NewIncorrectTypeError(cfg))}
+func validateConfig(jtc *JSONTagsConfig, fldPath *field.Path) field.ErrorList {
+	if jtc == nil {
+		return field.ErrorList{}
 	}
 
 	fieldErrors := field.ErrorList{}

pkg/analysis/maxlength/initializer.go

@@ -16,7 +16,6 @@ limitations under the License.
 package maxlength
 
 import (
-	"golang.org/x/tools/go/analysis"
 	kalanalysis "sigs.k8s.io/kube-api-linter/pkg/analysis"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
 )
@@ -30,11 +29,7 @@ func init() {
 func Initializer() initializer.AnalyzerInitializer {
 	return initializer.NewInitializer(
 		name,
-		initAnalyzer,
+		Analyzer,
 		false, // For now, CRD only, and so not on by default.
 	)
 }
-
-func initAnalyzer(_ any) (*analysis.Analyzer, error) {
-	return Analyzer, nil
-}