fix: improve internal Metalinter build

Author: ldez

pkg/lint/lintersdb/manager.go

@@ -204,18 +204,30 @@ func (m *Manager) build(enabledByDefaultLinters []*linter.Config) map[string]*li
 }
 
 func (m *Manager) combineGoAnalysisLinters(linters map[string]*linter.Config) {
+	mlConfig := &linter.Config{}
+
 	var goanalysisLinters []*goanalysis.Linter
 	goanalysisPresets := map[string]bool{}
+
 	for _, lc := range linters {
 		lnt, ok := lc.Linter.(*goanalysis.Linter)
 		if !ok {
 			continue
 		}
+
 		if lnt.LoadMode() == goanalysis.LoadModeWholeProgram {
 			// It's ineffective by CPU and memory to run whole-program and incremental analyzers at once.
 			continue
 		}
+
+		mlConfig.LoadMode |= lc.LoadMode
+
+		if lc.IsSlowLinter() {
+			mlConfig.ConsiderSlow()
+		}
+
 		goanalysisLinters = append(goanalysisLinters, lnt)
+
 		for _, p := range lc.InPresets {
 			goanalysisPresets[p] = true
 		}
@@ -245,22 +257,14 @@ func (m *Manager) combineGoAnalysisLinters(linters map[string]*linter.Config) {
 		return a.Name() <= b.Name()
 	})
 
-	ml := goanalysis.NewMetaLinter(goanalysisLinters)
+	mlConfig.Linter = goanalysis.NewMetaLinter(goanalysisLinters)
 
 	presets := maps.Keys(goanalysisPresets)
 	sort.Strings(presets)
+	mlConfig.InPresets = presets
 
-	mlConfig := &linter.Config{
-		Linter:           ml,
-		EnabledByDefault: false,
-		InPresets:        presets,
-		AlternativeNames: nil,
-		OriginalURL:      "",
-	}
-
-	mlConfig = mlConfig.WithLoadForGoAnalysis()
+	linters[mlConfig.Linter.Name()] = mlConfig
 
-	linters[ml.Name()] = mlConfig
 	m.debugf("Combined %d go/analysis linters into one metalinter", len(goanalysisLinters))
 }
 

pkg/lint/lintersdb/manager_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/tools/go/packages"
 
 	"github.com/golangci/golangci-lint/pkg/config"
 	"github.com/golangci/golangci-lint/pkg/goanalysis"
@@ -176,8 +177,11 @@ func TestManager_combineGoAnalysisLinters(t *testing.T) {
 	m, err := NewManager(nil, nil)
 	require.NoError(t, err)
 
-	foo := goanalysis.NewLinter("foo", "example foo", nil, nil).WithLoadMode(goanalysis.LoadModeTypesInfo)
-	bar := goanalysis.NewLinter("bar", "example bar", nil, nil).WithLoadMode(goanalysis.LoadModeTypesInfo)
+	fooTyped := goanalysis.NewLinter("foo", "example foo", nil, nil).WithLoadMode(goanalysis.LoadModeTypesInfo)
+	barTyped := goanalysis.NewLinter("bar", "example bar", nil, nil).WithLoadMode(goanalysis.LoadModeTypesInfo)
+
+	fooSyntax := goanalysis.NewLinter("foo", "example foo", nil, nil).WithLoadMode(goanalysis.LoadModeSyntax)
+	barSyntax := goanalysis.NewLinter("bar", "example bar", nil, nil).WithLoadMode(goanalysis.LoadModeSyntax)
 
 	testCases := []struct {
 		desc     string
@@ -188,37 +192,112 @@ func TestManager_combineGoAnalysisLinters(t *testing.T) {
 			desc: "no combined, one linter",
 			linters: map[string]*linter.Config{
 				"foo": {
-					Linter:    foo,
+					Linter:    fooTyped,
 					InPresets: []string{"A"},
 				},
 			},
 			expected: map[string]*linter.Config{
 				"foo": {
-					Linter:    foo,
+					Linter:    fooTyped,
+					InPresets: []string{"A"},
+				},
+			},
+		},
+		{
+			desc: "combined, several linters (typed)",
+			linters: map[string]*linter.Config{
+				"foo": {
+					Linter:    fooTyped,
 					InPresets: []string{"A"},
 				},
+				"bar": {
+					Linter:    barTyped,
+					InPresets: []string{"B"},
+				},
 			},
+			expected: func() map[string]*linter.Config {
+				mlConfig := &linter.Config{
+					Linter:    goanalysis.NewMetaLinter([]*goanalysis.Linter{barTyped, fooTyped}),
+					InPresets: []string{"A", "B"},
+				}
+
+				return map[string]*linter.Config{
+					"goanalysis_metalinter": mlConfig,
+				}
+			}(),
+		},
+		{
+			desc: "combined, several linters (different LoadMode)",
+			linters: map[string]*linter.Config{
+				"foo": {
+					Linter:    fooTyped,
+					InPresets: []string{"A"},
+					LoadMode:  packages.NeedName,
+				},
+				"bar": {
+					Linter:    barTyped,
+					InPresets: []string{"B"},
+					LoadMode:  packages.NeedTypesSizes,
+				},
+			},
+			expected: func() map[string]*linter.Config {
+				mlConfig := &linter.Config{
+					Linter:    goanalysis.NewMetaLinter([]*goanalysis.Linter{barTyped, fooTyped}),
+					InPresets: []string{"A", "B"},
+					LoadMode:  packages.NeedName | packages.NeedTypesSizes,
+				}
+
+				return map[string]*linter.Config{
+					"goanalysis_metalinter": mlConfig,
+				}
+			}(),
+		},
+		{
+			desc: "combined, several linters (same LoadMode)",
+			linters: map[string]*linter.Config{
+				"foo": {
+					Linter:    fooTyped,
+					InPresets: []string{"A"},
+					LoadMode:  packages.NeedName,
+				},
+				"bar": {
+					Linter:    barTyped,
+					InPresets: []string{"B"},
+					LoadMode:  packages.NeedName,
+				},
+			},
+			expected: func() map[string]*linter.Config {
+				mlConfig := &linter.Config{
+					Linter:    goanalysis.NewMetaLinter([]*goanalysis.Linter{barTyped, fooTyped}),
+					InPresets: []string{"A", "B"},
+					LoadMode:  packages.NeedName,
+				}
+
+				return map[string]*linter.Config{
+					"goanalysis_metalinter": mlConfig,
+				}
+			}(),
 		},
 		{
-			desc: "combined, several linters",
+			desc: "combined, several linters (syntax)",
 			linters: map[string]*linter.Config{
 				"foo": {
-					Linter:    foo,
+					Linter:    fooSyntax,
 					InPresets: []string{"A"},
 				},
 				"bar": {
-					Linter:    bar,
+					Linter:    barSyntax,
 					InPresets: []string{"B"},
 				},
 			},
 			expected: func() map[string]*linter.Config {
 				mlConfig := &linter.Config{
-					Linter:    goanalysis.NewMetaLinter([]*goanalysis.Linter{bar, foo}),
+					Linter:    goanalysis.NewMetaLinter([]*goanalysis.Linter{barSyntax, fooSyntax}),
 					InPresets: []string{"A", "B"},
 				}
 
 				return map[string]*linter.Config{
-					"goanalysis_metalinter": mlConfig.WithLoadForGoAnalysis(),
+					"goanalysis_metalinter": mlConfig,
 				}
 			}(),
 		},