dev: rewrite linters Manager

docs/src/docs/contributing/architecture.mdx

@@ -22,6 +22,14 @@ graph LR
 
 </ResponsiveContainer>
 
+## Init
+
+The configuration is loaded from file and flags by `config.Loader` inside `PersistentPreRun` (or `PreRun`) of the commands that require configuration.
+
+The linter database (`linterdb.Manager`) is fill based on the configuration:
+- The linters ("internals" and plugins) are built by `linterdb.LinterBuilder` and `linterdb.PluginBuilder` builders.
+- The configuration is validated by `linterdb.Validator`.
+
 ## Load Packages
 
 Loading packages is listing all packages and their recursive dependencies for analysis.

pkg/commands/help.go

@@ -41,7 +41,7 @@ func newHelpCommand(logger logutils.Log) *helpCommand {
 			Args:              cobra.NoArgs,
 			ValidArgsFunction: cobra.NoFileCompletions,
 			Run:               c.execute,
-			PreRun:            c.preRun,
+			PreRunE:           c.preRunE,
 		},
 	)
 
@@ -50,10 +50,18 @@ func newHelpCommand(logger logutils.Log) *helpCommand {
 	return c
 }
 
-func (c *helpCommand) preRun(_ *cobra.Command, _ []string) {
+func (c *helpCommand) preRunE(_ *cobra.Command, _ []string) error {
 	// The command doesn't depend on the real configuration.
 	// It just needs the list of all plugins and all presets.
-	c.dbManager = lintersdb.NewManager(config.NewDefault(), c.log)
+	dbManager, err := lintersdb.NewManager(c.log.Child(logutils.DebugKeyLintersDB), config.NewDefault(),
+		lintersdb.NewPluginBuilder(c.log), lintersdb.NewLinterBuilder())
+	if err != nil {
+		return err
+	}
+
+	c.dbManager = dbManager
+
+	return nil
 }
 
 func (c *helpCommand) execute(_ *cobra.Command, _ []string) {

pkg/commands/linters.go

@@ -27,8 +27,7 @@ type lintersCommand struct {
 
 	log logutils.Log
 
-	dbManager         *lintersdb.Manager
-	enabledLintersSet *lintersdb.EnabledSet
+	dbManager *lintersdb.Manager
 }
 
 func newLintersCommand(logger logutils.Log, cfg *config.Config) *lintersCommand {
@@ -65,15 +64,19 @@ func (c *lintersCommand) preRunE(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("can't load config: %w", err)
 	}
 
-	c.dbManager = lintersdb.NewManager(c.cfg, c.log)
-	c.enabledLintersSet = lintersdb.NewEnabledSet(c.dbManager,
-		lintersdb.NewValidator(c.dbManager), c.log.Child(logutils.DebugKeyLintersDB), c.cfg)
+	dbManager, err := lintersdb.NewManager(c.log.Child(logutils.DebugKeyLintersDB), c.cfg,
+		lintersdb.NewPluginBuilder(c.log), lintersdb.NewLinterBuilder())
+	if err != nil {
+		return err
+	}
+
+	c.dbManager = dbManager
 
 	return nil
 }
 
 func (c *lintersCommand) execute(_ *cobra.Command, _ []string) error {
-	enabledLintersMap, err := c.enabledLintersSet.GetEnabledLintersMap()
+	enabledLintersMap, err := c.dbManager.GetEnabledLintersMap()
 	if err != nil {
 		return fmt.Errorf("can't get enabled linters: %w", err)
 	}

pkg/commands/run.go

@@ -80,8 +80,7 @@ type runCommand struct {
 
 	buildInfo BuildInfo
 
-	dbManager         *lintersdb.Manager
-	enabledLintersSet *lintersdb.EnabledSet
+	dbManager *lintersdb.Manager
 
 	log        logutils.Log
 	debugf     logutils.DebugFunc
@@ -171,9 +170,13 @@ func (c *runCommand) persistentPostRunE(_ *cobra.Command, _ []string) error {
 }
 
 func (c *runCommand) preRunE(_ *cobra.Command, _ []string) error {
-	c.dbManager = lintersdb.NewManager(c.cfg, c.log)
-	c.enabledLintersSet = lintersdb.NewEnabledSet(c.dbManager,
-		lintersdb.NewValidator(c.dbManager), c.log.Child(logutils.DebugKeyLintersDB), c.cfg)
+	dbManager, err := lintersdb.NewManager(c.log.Child(logutils.DebugKeyLintersDB), c.cfg,
+		lintersdb.NewPluginBuilder(c.log), lintersdb.NewLinterBuilder())
+	if err != nil {
+		return err
+	}
+
+	c.dbManager = dbManager
 
 	c.goenv = goutil.NewEnv(c.log.Child(logutils.DebugKeyGoEnv))
 
@@ -340,12 +343,12 @@ func (c *runCommand) runAndPrint(ctx context.Context, args []string) error {
 func (c *runCommand) runAnalysis(ctx context.Context, args []string) ([]result.Issue, error) {
 	c.cfg.Run.Args = args
 
-	lintersToRun, err := c.enabledLintersSet.GetOptimizedLinters()
+	lintersToRun, err := c.dbManager.GetOptimizedLinters()
 	if err != nil {
 		return nil, err
 	}
 
-	enabledLintersMap, err := c.enabledLintersSet.GetEnabledLintersMap()
+	enabledLintersMap, err := c.dbManager.GetEnabledLintersMap()
 	if err != nil {
 		return nil, err
 	}
@@ -361,8 +364,8 @@ func (c *runCommand) runAnalysis(ctx context.Context, args []string) ([]result.I
 	}
 	lintCtx.Log = c.log.Child(logutils.DebugKeyLintersContext)
 
-	runner, err := lint.NewRunner(c.cfg, c.log.Child(logutils.DebugKeyRunner),
-		c.goenv, c.enabledLintersSet, c.lineCache, c.fileCache, c.dbManager, lintCtx.Packages)
+	runner, err := lint.NewRunner(c.log.Child(logutils.DebugKeyRunner),
+		c.cfg, c.goenv, c.lineCache, c.fileCache, c.dbManager, lintCtx.Packages)
 	if err != nil {
 		return nil, err
 	}

pkg/commands/version.go

@@ -25,8 +25,8 @@ type versionInfo struct {
 }
 
 type versionOptions struct {
-	Format string `mapstructure:"format"`
-	Debug  bool   `mapstructure:"debug"`
+	Format string
+	Debug  bool
 }
 
 type versionCommand struct {

pkg/config/config.go

@@ -1,9 +1,8 @@
 package config
 
 import (
-	"errors"
-	"fmt"
 	"os"
+	"regexp"
 	"strings"
 
 	hcversion "github.com/hashicorp/go-version"
@@ -33,18 +32,16 @@ func (c *Config) GetConfigDir() string {
 }
 
 func (c *Config) Validate() error {
-	for i, rule := range c.Issues.ExcludeRules {
-		if err := rule.Validate(); err != nil {
-			return fmt.Errorf("error in exclude rule #%d: %w", i, err)
-		}
+	validators := []func() error{
+		c.Issues.Validate,
+		c.Severity.Validate,
+		c.LintersSettings.Validate,
+		c.Linters.Validate,
 	}
 
-	if len(c.Severity.Rules) > 0 && c.Severity.Default == "" {
-		return errors.New("can't set severity rule option: no default severity defined")
-	}
-	for i, rule := range c.Severity.Rules {
-		if err := rule.Validate(); err != nil {
-			return fmt.Errorf("error in severity rule #%d: %w", i, err)
+	for _, v := range validators {
+		if err := v(); err != nil {
+			return err
 		}
 	}
 
@@ -90,3 +87,22 @@ func detectGoVersion() string {
 
 	return "1.17"
 }
+
+// Trims the Go version to keep only M.m.
+// Since Go 1.21 the version inside the go.mod can be a patched version (ex: 1.21.0).
+// The version can also include information which we want to remove (ex: 1.21alpha1)
+// https://go.dev/doc/toolchain#versions
+// This a problem with staticcheck and gocritic.
+func trimGoVersion(v string) string {
+	if v == "" {
+		return ""
+	}
+
+	exp := regexp.MustCompile(`(\d\.\d+)(?:\.\d+|[a-z]+\d)`)
+
+	if exp.MatchString(v) {
+		return exp.FindStringSubmatch(v)[1]
+	}
+
+	return v
+}

pkg/config/config_test.go

@@ -84,3 +84,52 @@ func TestIsGoGreaterThanOrEqual(t *testing.T) {
 		})
 	}
 }
+
+func Test_trimGoVersion(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		version  string
+		expected string
+	}{
+		{
+			desc:     "patched version",
+			version:  "1.22.0",
+			expected: "1.22",
+		},
+		{
+			desc:     "minor version",
+			version:  "1.22",
+			expected: "1.22",
+		},
+		{
+			desc:     "RC version",
+			version:  "1.22rc1",
+			expected: "1.22",
+		},
+		{
+			desc:     "alpha version",
+			version:  "1.22alpha1",
+			expected: "1.22",
+		},
+		{
+			desc:     "beta version",
+			version:  "1.22beta1",
+			expected: "1.22",
+		},
+		{
+			desc:     "semver RC version",
+			version:  "1.22.0-rc1",
+			expected: "1.22",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			version := trimGoVersion(test.version)
+			assert.Equal(t, test.expected, version)
+		})
+	}
+}

pkg/config/issues.go

@@ -122,6 +122,16 @@ type Issues struct {
 	NeedFix bool `mapstructure:"fix"`
 }
 
+func (i *Issues) Validate() error {
+	for i, rule := range i.ExcludeRules {
+		if err := rule.Validate(); err != nil {
+			return fmt.Errorf("error in exclude rule #%d: %w", i, err)
+		}
+	}
+
+	return nil
+}
+
 type ExcludeRule struct {
 	BaseRule `mapstructure:",squash"`
 }

pkg/config/linters.go

@@ -1,5 +1,10 @@
 package config
 
+import (
+	"errors"
+	"fmt"
+)
+
 type Linters struct {
 	Enable     []string
 	Disable    []string
@@ -9,3 +14,52 @@ type Linters struct {
 
 	Presets []string
 }
+
+func (l *Linters) Validate() error {
+	if err := l.validateAllDisableEnableOptions(); err != nil {
+		return err
+	}
+
+	if err := l.validateDisabledAndEnabledAtOneMoment(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (l *Linters) validateAllDisableEnableOptions() error {
+	if l.EnableAll && l.DisableAll {
+		return errors.New("--enable-all and --disable-all options must not be combined")
+	}
+
+	if l.DisableAll {
+		if len(l.Enable) == 0 && len(l.Presets) == 0 {
+			return errors.New("all linters were disabled, but no one linter was enabled: must enable at least one")
+		}
+
+		if len(l.Disable) != 0 {
+			return fmt.Errorf("can't combine options --disable-all and --disable %s", l.Disable[0])
+		}
+	}
+
+	if l.EnableAll && len(l.Enable) != 0 && !l.Fast {
+		return fmt.Errorf("can't combine options --enable-all and --enable %s", l.Enable[0])
+	}
+
+	return nil
+}
+
+func (l *Linters) validateDisabledAndEnabledAtOneMoment() error {
+	enabledLintersSet := map[string]bool{}
+	for _, name := range l.Enable {
+		enabledLintersSet[name] = true
+	}
+
+	for _, name := range l.Disable {
+		if enabledLintersSet[name] {
+			return fmt.Errorf("linter %q can't be disabled and enabled at one moment", name)
+		}
+	}
+
+	return nil
+}

pkg/config/linters_settings.go

@@ -291,6 +291,10 @@ type LintersSettings struct {
 	Custom map[string]CustomLinterSettings
 }
 
+func (s *LintersSettings) Validate() error {
+	return s.Govet.Validate()
+}
+
 type AsasalintSettings struct {
 	Exclude              []string `mapstructure:"exclude"`
 	UseBuiltinExclusions bool     `mapstructure:"use-builtin-exclusions"`
@@ -606,15 +610,14 @@ type GovetSettings struct {
 }
 
 func (cfg *GovetSettings) Validate() error {
-	// TODO(ldez) need to be move into the linter file.
 	if cfg.EnableAll && cfg.DisableAll {
-		return errors.New("enable-all and disable-all can't be combined")
+		return errors.New("govet: enable-all and disable-all can't be combined")
 	}
 	if cfg.EnableAll && len(cfg.Enable) != 0 {
-		return errors.New("enable-all and enable can't be combined")
+		return errors.New("govet: enable-all and enable can't be combined")
 	}
 	if cfg.DisableAll && len(cfg.Disable) != 0 {
-		return errors.New("disable-all and disable can't be combined")
+		return errors.New("govet: disable-all and disable can't be combined")
 	}
 	return nil
 }