dev: replace FileCache by LineCache (golangci#5518)

Author: ldez

pkg/fsutils/files.go

@@ -37,11 +37,6 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env,
 	lineCache *fsutils.LineCache, fileCache *fsutils.FileCache,
 	dbManager *lintersdb.Manager, lintCtx *linter.Context,
 ) (*Runner, error) {
-	// Beware that some processors need to add the path prefix when working with paths
-	// because they get invoked before the path prefixer (exclude and severity rules)
-	// or process other paths (skip files).
-	files := fsutils.NewFiles(lineCache, cfg.Output.PathPrefix)
-
 	pathRelativity, err := processors.NewPathRelativity(log, cfg.GetBasePath())
 	if err != nil {
 		return nil, fmt.Errorf("error creating path relativity processor: %w", err)
@@ -98,7 +93,7 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env,
 			// Must be before exclude because users see already marked output and configure excluding by it.
 			processors.NewIdentifierMarker(),
 
-			processors.NewExclusionRules(log.Child(logutils.DebugKeyExclusionRules), files,
+			processors.NewExclusionRules(log.Child(logutils.DebugKeyExclusionRules), lineCache,
 				&cfg.Linters.Exclusions),
 
 			processors.NewNolintFilter(log.Child(logutils.DebugKeyNolintFilter), dbManager, enabledLinters),
@@ -117,7 +112,7 @@ func NewRunner(log logutils.Log, cfg *config.Config, goenv *goutil.Env,
 			// Now we can modify the issues for output.
 			processors.NewSourceCode(lineCache, log.Child(logutils.DebugKeySourceCode)),
 			processors.NewPathShortener(),
-			processors.NewSeverity(log.Child(logutils.DebugKeySeverityRules), files, &cfg.Severity),
+			processors.NewSeverity(log.Child(logutils.DebugKeySeverityRules), lineCache, &cfg.Severity),
 			processors.NewPathPrettifier(log, cfg.Output.PathPrefix),
 			processors.NewSortResults(&cfg.Output),
 		},

pkg/lint/runner.go

@@ -47,14 +47,14 @@ func (r *baseRule) isEmpty() bool {
 	return r.text == nil && r.source == nil && r.path == nil && r.pathExcept == nil && len(r.linters) == 0
 }
 
-func (r *baseRule) match(issue *result.Issue, files *fsutils.Files, log logutils.Log) bool {
+func (r *baseRule) match(issue *result.Issue, lines *fsutils.LineCache, log logutils.Log) bool {
 	if r.isEmpty() {
 		return false
 	}
 	if r.text != nil && !r.text.MatchString(issue.Text) {
 		return false
 	}
-	if r.path != nil && !r.path.MatchString(files.WithPathPrefix(issue.RelativePath)) {
+	if r.path != nil && !r.path.MatchString(issue.RelativePath) {
 		return false
 	}
 	if r.pathExcept != nil && r.pathExcept.MatchString(issue.RelativePath) {
@@ -65,7 +65,7 @@ func (r *baseRule) match(issue *result.Issue, files *fsutils.Files, log logutils
 	}
 
 	// the most heavyweight checking last
-	if r.source != nil && !r.matchSource(issue, files.LineCache, log) {
+	if r.source != nil && !r.matchSource(issue, lines, log) {
 		return false
 	}
 

pkg/result/processors/base_rule.go

@@ -14,20 +14,20 @@ import (
 var _ Processor = (*ExclusionRules)(nil)
 
 type ExclusionRules struct {
-	log   logutils.Log
-	files *fsutils.Files
+	log logutils.Log
+
+	lines *fsutils.LineCache
 
 	warnUnused     bool
 	skippedCounter map[string]int
 
 	rules []excludeRule
 }
 
-func NewExclusionRules(log logutils.Log, files *fsutils.Files,
-	cfg *config.LinterExclusions) *ExclusionRules {
+func NewExclusionRules(log logutils.Log, lines *fsutils.LineCache, cfg *config.LinterExclusions) *ExclusionRules {
 	p := &ExclusionRules{
 		log:            log,
-		files:          files,
+		lines:          lines,
 		warnUnused:     cfg.WarnUnused,
 		skippedCounter: map[string]int{},
 	}
@@ -56,7 +56,7 @@ func (p *ExclusionRules) Process(issues []result.Issue) ([]result.Issue, error)
 
 	return filterIssues(issues, func(issue *result.Issue) bool {
 		for _, rule := range p.rules {
-			if !rule.match(issue, p.files, p.log) {
+			if !rule.match(issue, p.lines, p.log) {
 				continue
 			}
 

pkg/result/processors/exclusion_rules.go

@@ -1,7 +1,6 @@
 package processors
 
 import (
-	"path"
 	"path/filepath"
 	"testing"
 
@@ -13,7 +12,7 @@ import (
 )
 
 func TestExclusionRules_Process_multiple(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
 	cfg := &config.LinterExclusions{
 		Rules: []config.ExcludeRule{
@@ -50,7 +49,7 @@ func TestExclusionRules_Process_multiple(t *testing.T) {
 		},
 	}
 
-	p := NewExclusionRules(nil, files, cfg)
+	p := NewExclusionRules(nil, lines, cfg)
 
 	cases := []issueTestCase{
 		{Path: "e.go", Text: "exclude", Linter: "linter"},
@@ -91,52 +90,8 @@ func TestExclusionRules_Process_multiple(t *testing.T) {
 	assert.Equal(t, expectedCases, resultingCases)
 }
 
-func TestExclusionRules_Process_pathPrefix(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), path.Join("some", "dir"))
-
-	cfg := &config.LinterExclusions{
-		Rules: []config.ExcludeRule{
-			{
-				BaseRule: config.BaseRule{
-					Path: `some/dir/e\.go`,
-				},
-			},
-		},
-	}
-
-	p := NewExclusionRules(nil, files, cfg)
-
-	cases := []issueTestCase{
-		{Path: "e.go"},
-		{Path: "other.go"},
-	}
-
-	var issues []result.Issue
-	for _, c := range cases {
-		issues = append(issues, newIssueFromIssueTestCase(c))
-	}
-
-	processedIssues := process(t, p, issues...)
-
-	var resultingCases []issueTestCase
-	for _, i := range processedIssues {
-		resultingCases = append(resultingCases, issueTestCase{
-			Path:   i.FilePath(),
-			Linter: i.FromLinter,
-			Text:   i.Text,
-			Line:   i.Line(),
-		})
-	}
-
-	expectedCases := []issueTestCase{
-		{Path: "other.go"},
-	}
-
-	assert.Equal(t, expectedCases, resultingCases)
-}
-
 func TestExclusionRules_Process_text(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
 	cfg := &config.LinterExclusions{
 		Rules: []config.ExcludeRule{{
@@ -147,7 +102,7 @@ func TestExclusionRules_Process_text(t *testing.T) {
 		}},
 	}
 
-	p := NewExclusionRules(nil, files, cfg)
+	p := NewExclusionRules(nil, lines, cfg)
 
 	texts := []string{"exclude", "1", "", "exclud", "notexclude"}
 	var issues []result.Issue
@@ -170,15 +125,15 @@ func TestExclusionRules_Process_text(t *testing.T) {
 }
 
 func TestExclusionRules_Process_empty(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
-	p := NewExclusionRules(nil, files, &config.LinterExclusions{})
+	p := NewExclusionRules(nil, lines, &config.LinterExclusions{})
 
 	processAssertSame(t, p, newIssueFromTextTestCase("test"))
 }
 
 func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
 	cfg := &config.LinterExclusions{
 		Rules: []config.ExcludeRule{
@@ -209,7 +164,7 @@ func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) {
 		},
 	}
 
-	p := NewExclusionRules(nil, files, cfg)
+	p := NewExclusionRules(nil, lines, cfg)
 
 	cases := []issueTestCase{
 		{Path: "e.go", Text: "exclude", Linter: "linter"},
@@ -253,7 +208,7 @@ func TestExclusionRules_Process_caseSensitive_multiple(t *testing.T) {
 }
 
 func TestExclusionRules_Process_caseSensitive_text(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
 	cfg := &config.LinterExclusions{
 		Rules: []config.ExcludeRule{
@@ -266,7 +221,7 @@ func TestExclusionRules_Process_caseSensitive_text(t *testing.T) {
 		},
 	}
 
-	p := NewExclusionRules(nil, files, cfg)
+	p := NewExclusionRules(nil, lines, cfg)
 
 	texts := []string{"exclude", "excLude", "1", "", "exclud", "notexclude"}
 
@@ -290,9 +245,9 @@ func TestExclusionRules_Process_caseSensitive_text(t *testing.T) {
 }
 
 func TestExclusionRules_Process_caseSensitive_empty(t *testing.T) {
-	files := fsutils.NewFiles(fsutils.NewLineCache(fsutils.NewFileCache()), "")
+	lines := fsutils.NewLineCache(fsutils.NewFileCache())
 
-	p := NewExclusionRules(nil, files, &config.LinterExclusions{})
+	p := NewExclusionRules(nil, lines, &config.LinterExclusions{})
 
 	processAssertSame(t, p, newIssueFromTextTestCase("test"))
 }

pkg/result/processors/exclusion_rules_test.go

@@ -1,7 +1,8 @@
 package processors
 
 import (
-	"github.com/golangci/golangci-lint/pkg/fsutils"
+	"path/filepath"
+
 	"github.com/golangci/golangci-lint/pkg/logutils"
 	"github.com/golangci/golangci-lint/pkg/result"
 )
@@ -30,7 +31,11 @@ func (p *PathPrettifier) Process(issues []result.Issue) ([]result.Issue, error)
 	return transformIssues(issues, func(issue *result.Issue) *result.Issue {
 		newIssue := issue
 
-		newIssue.Pos.Filename = fsutils.WithPathPrefix(p.prefix, issue.RelativePath)
+		if p.prefix == "" {
+			newIssue.Pos.Filename = issue.RelativePath
+		} else {
+			newIssue.Pos.Filename = filepath.Join(p.prefix, issue.RelativePath)
+		}
 
 		return newIssue
 	}), nil

pkg/result/processors/path_prettifier.go

@@ -22,16 +22,16 @@ type Severity struct {
 
 	log logutils.Log
 
-	files *fsutils.Files
+	lines *fsutils.LineCache
 
 	defaultSeverity string
 	rules           []severityRule
 }
 
-func NewSeverity(log logutils.Log, files *fsutils.Files, cfg *config.Severity) *Severity {
+func NewSeverity(log logutils.Log, lines *fsutils.LineCache, cfg *config.Severity) *Severity {
 	p := &Severity{
 		name:            "severity-rules",
-		files:           files,
+		lines:           lines,
 		log:             log,
 		defaultSeverity: cfg.Default,
 	}
@@ -55,7 +55,7 @@ func (*Severity) Finish() {}
 
 func (p *Severity) transform(issue *result.Issue) *result.Issue {
 	for _, rule := range p.rules {
-		if rule.match(issue, p.files, p.log) {
+		if rule.match(issue, p.lines, p.log) {
 			if rule.severity == severityFromLinter || (rule.severity == "" && p.defaultSeverity == severityFromLinter) {
 				return issue
 			}