async issues processing

Author: golangcidev

Gopkg.lock

@@ -29,10 +29,6 @@
   name = "github.com/bradleyfalzon/revgrep"
   version = "0.3.0"
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/golangci/golangci-shared"
-
 [[constraint]]
   name = "github.com/stretchr/testify"
   version = "1.2.1"

Gopkg.toml

@@ -4,13 +4,12 @@ import (
 	"log"
 
 	"github.com/golangci/golangci-lint/internal/commands"
-	"github.com/golangci/golangci-shared/pkg/analytics"
 	"github.com/sirupsen/logrus"
 )
 
 func main() {
 	log.SetFlags(0) // don't print time
-	analytics.SetLogLevel(logrus.WarnLevel)
+	logrus.SetLevel(logrus.WarnLevel)
 
 	e := commands.NewExecutor()
 	if err := e.Execute(); err != nil {

cmd/golangci-lint/main.go

@@ -6,7 +6,6 @@ import (
 	"runtime"
 	"runtime/pprof"
 
-	"github.com/golangci/golangci-shared/pkg/analytics"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
@@ -23,7 +22,7 @@ func (e *Executor) initRoot() {
 			runtime.GOMAXPROCS(e.cfg.Common.Concurrency)
 
 			if e.cfg.Common.IsVerbose {
-				analytics.SetLogLevel(logrus.InfoLevel)
+				logrus.SetLevel(logrus.InfoLevel)
 			}
 
 			if e.cfg.Common.CPUProfilePath != "" {

internal/commands/root.go

@@ -6,7 +6,9 @@ import (
 	"fmt"
 	"go/build"
 	"log"
+	"os"
 	"strings"
+	"syscall"
 	"time"
 
 	"github.com/fatih/color"
@@ -18,7 +20,7 @@ import (
 	"github.com/golangci/golangci-lint/pkg/golinters"
 	"github.com/golangci/golangci-lint/pkg/result"
 	"github.com/golangci/golangci-lint/pkg/result/processors"
-	"github.com/golangci/golangci-shared/pkg/analytics"
+	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"golang.org/x/tools/go/loader"
 )
@@ -110,7 +112,7 @@ func loadWholeAppIfNeeded(ctx context.Context, linters []pkg.Linter, cfg *config
 
 	startedAt := time.Now()
 	defer func() {
-		analytics.Log(ctx).Infof("Program loading took %s", time.Since(startedAt))
+		logrus.Infof("Program loading took %s", time.Since(startedAt))
 	}()
 
 	bctx := build.Default
@@ -139,7 +141,7 @@ func loadWholeAppIfNeeded(ctx context.Context, linters []pkg.Linter, cfg *config
 func buildSSAProgram(ctx context.Context, lprog *loader.Program) *ssa.Program {
 	startedAt := time.Now()
 	defer func() {
-		analytics.Log(ctx).Infof("SSA repr building took %s", time.Since(startedAt))
+		logrus.Infof("SSA repr building took %s", time.Since(startedAt))
 	}()
 
 	ssaProg := ssautil.CreateProgram(lprog, ssa.GlobalDebug)
@@ -177,8 +179,7 @@ func buildLintCtx(ctx context.Context, linters []pkg.Linter, cfg *config.Config)
 	}, nil
 }
 
-func (e *Executor) runAnalysis(ctx context.Context, args []string) ([]result.Issue, error) {
-	startedAt := time.Now()
+func (e *Executor) runAnalysis(ctx context.Context, args []string) (chan result.Issue, error) {
 	e.cfg.Run.Args = args
 
 	linters, err := pkg.GetEnabledLinters(ctx, &e.cfg.Run)
@@ -193,38 +194,37 @@ func (e *Executor) runAnalysis(ctx context.Context, args []string) ([]result.Iss
 
 	runner := pkg.SimpleRunner{
 		Processors: []processors.Processor{
-			processors.MaxLinterIssuesPerFile{},
-			processors.NewExcludeProcessor(fmt.Sprintf("(%s)", strings.Join(e.cfg.Run.ExcludePatterns, "|"))),
-			processors.NewNolintProcessor(lintCtx.Program),
-			processors.UniqByLineProcessor{},
+			processors.NewMaxPerFileFromLinter(),
+			processors.NewExclude(fmt.Sprintf("(%s)", strings.Join(e.cfg.Run.ExcludePatterns, "|"))),
+			processors.NewNolint(lintCtx.Program.Fset),
+			processors.NewUniqByLine(),
 			processors.NewPathPrettifier(),
 		},
 	}
 
-	issues, err := runner.Run(ctx, linters, lintCtx)
-	if err != nil {
-		return nil, err
-	}
-
-	analytics.Log(ctx).Infof("Analysis took %s", time.Since(startedAt))
-	return issues, nil
+	return runner.Run(ctx, linters, lintCtx), nil
 }
 
 func (e *Executor) executeRun(cmd *cobra.Command, args []string) {
-	f := func() error {
-		ctx, cancel := context.WithTimeout(context.Background(), e.cfg.Run.Deadline)
-		defer cancel()
+	ctx, cancel := context.WithTimeout(context.Background(), e.cfg.Run.Deadline)
+	defer cancel()
 
+	defer func(startedAt time.Time) {
+		logrus.Infof("Run took %s", time.Since(startedAt))
+	}(time.Now())
+
+	f := func() error {
 		issues, err := e.runAnalysis(ctx, args)
 		if err != nil {
 			return err
 		}
 
-		if err := outputIssues(e.cfg.Run.OutFormat, issues); err != nil {
+		gotAnyIssues, err := outputIssues(e.cfg.Run.OutFormat, issues)
+		if err != nil {
 			return fmt.Errorf("can't output %d issues: %s", len(issues), err)
 		}
 
-		if len(issues) != 0 {
+		if gotAnyIssues {
 			e.exitCode = e.cfg.Run.ExitCodeIfIssuesFound
 			return nil
 		}
@@ -240,34 +240,42 @@ func (e *Executor) executeRun(cmd *cobra.Command, args []string) {
 	}
 }
 
-func outputIssues(format string, issues []result.Issue) error {
+func outputIssues(format string, issues chan result.Issue) (bool, error) {
+	stdout := os.NewFile(uintptr(syscall.Stdout), "/dev/stdout") // was set to /dev/null
 	if format == config.OutFormatLineNumber || format == config.OutFormatColoredLineNumber {
-		if len(issues) == 0 {
-			outStr := "Congrats! No issues were found."
+		gotAnyIssue := false
+		for i := range issues {
+			gotAnyIssue = true
+			text := i.Text
 			if format == config.OutFormatColoredLineNumber {
-				outStr = color.GreenString(outStr)
+				text = color.RedString(text)
 			}
-			fmt.Println(outStr)
+			fmt.Fprintf(stdout, "%s:%d: %s\n", i.File, i.LineNumber, text)
 		}
 
-		for _, i := range issues {
-			text := i.Text
+		if !gotAnyIssue {
+			outStr := "Congrats! No issues were found."
 			if format == config.OutFormatColoredLineNumber {
-				text = color.RedString(text)
+				outStr = color.GreenString(outStr)
 			}
-			fmt.Printf("%s:%d: %s\n", i.File, i.LineNumber, text)
+			fmt.Fprintln(stdout, outStr)
 		}
-		return nil
+
+		return gotAnyIssue, nil
 	}
 
 	if format == config.OutFormatJSON {
-		outputJSON, err := json.Marshal(issues)
+		var allIssues []result.Issue
+		for i := range issues {
+			allIssues = append(allIssues, i)
+		}
+		outputJSON, err := json.Marshal(allIssues)
 		if err != nil {
-			return err
+			return false, err
 		}
-		fmt.Print(string(outputJSON))
-		return nil
+		fmt.Fprint(stdout, string(outputJSON))
+		return len(allIssues) != 0, nil
 	}
 
-	return fmt.Errorf("unknown output format %q", format)
+	return false, fmt.Errorf("unknown output format %q", format)
 }

internal/commands/run.go

@@ -7,7 +7,7 @@ import (
 
 	"github.com/golangci/golangci-lint/pkg/config"
 	"github.com/golangci/golangci-lint/pkg/golinters"
-	"github.com/golangci/golangci-shared/pkg/analytics"
+	"github.com/sirupsen/logrus"
 )
 
 type LinterConfig struct {
@@ -192,7 +192,7 @@ func GetEnabledLinters(ctx context.Context, cfg *config.Run) ([]Linter, error) {
 		resultLinters = append(resultLinters, linter)
 		resultLinterNames = append(resultLinterNames, name)
 	}
-	analytics.Log(ctx).Infof("Enabled linters: %s", resultLinterNames)
+	logrus.Infof("Enabled linters: %s", resultLinterNames)
 
 	return resultLinters, nil
 }

pkg/enabled_linters.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/golangci/golangci-shared/pkg/analytics"
+	"github.com/sirupsen/logrus"
 )
 
 func GetProjectRoot() string {
@@ -33,21 +33,21 @@ func (p ProjectPaths) MixedPaths() []string {
 
 func processPaths(root string, paths []string, maxPaths int) ([]string, error) {
 	if len(paths) > maxPaths {
-		analytics.Log(context.TODO()).Warnf("Gofmt: got too much paths (%d), analyze first %d", len(paths), maxPaths)
+		logrus.Warnf("Gofmt: got too much paths (%d), analyze first %d", len(paths), maxPaths)
 		paths = paths[:maxPaths]
 	}
 
 	ret := []string{}
-	for i := range paths {
-		if !filepath.IsAbs(paths[i]) {
-			ret = append(ret, paths[i])
+	for _, p := range paths {
+		if !filepath.IsAbs(p) {
+			ret = append(ret, p)
 			continue
 		}
 
-		relPath, err := filepath.Rel(root, paths[i])
+		relPath, err := filepath.Rel(root, p)
 		if err != nil {
 			return nil, fmt.Errorf("can't get relative path for path %s and root %s: %s",
-				paths[i], root, err)
+				p, root, err)
 		}
 		ret = append(ret, relPath)
 	}
@@ -58,7 +58,7 @@ func processPaths(root string, paths []string, maxPaths int) ([]string, error) {
 func GetPathsForAnalysis(ctx context.Context, inputPaths []string) (ret *ProjectPaths, err error) {
 	defer func(startedAt time.Time) {
 		if ret != nil {
-			analytics.Log(ctx).Infof("Found paths for analysis for %s: %s", time.Since(startedAt), ret.MixedPaths())
+			logrus.Infof("Found paths for analysis for %s: %s", time.Since(startedAt), ret.MixedPaths())
 		}
 	}(time.Now())
 
@@ -92,7 +92,7 @@ func GetPathsForAnalysis(ctx context.Context, inputPaths []string) (ret *Project
 
 	for i := range dirs {
 		dir := dirs[i]
-		if dir != "." {
+		if dir != "." && !filepath.IsAbs(dir) {
 			dirs[i] = "./" + dir
 		}
 	}

pkg/fsutils/fsutils.go

@@ -14,15 +14,15 @@ func (Deadcode) Name() string {
 	return "deadcode"
 }
 
-func (d Deadcode) Run(ctx context.Context, lintCtx *Context) (*result.Result, error) {
+func (d Deadcode) Run(ctx context.Context, lintCtx *Context) ([]result.Issue, error) {
 	issues, err := deadcodeAPI.Run(lintCtx.Program)
 	if err != nil {
 		return nil, err
 	}
 
-	res := &result.Result{}
+	var res []result.Issue
 	for _, i := range issues {
-		res.Issues = append(res.Issues, result.Issue{
+		res = append(res, result.Issue{
 			File:       i.Pos.Filename,
 			LineNumber: i.Pos.Line,
 			Text:       fmt.Sprintf("%s is unused", formatCode(i.UnusedIdentName, lintCtx.RunCfg())),

pkg/golinters/deadcode.go

@@ -14,19 +14,19 @@ func (Dupl) Name() string {
 	return "dupl"
 }
 
-func (d Dupl) Run(ctx context.Context, lintCtx *Context) (*result.Result, error) {
+func (d Dupl) Run(ctx context.Context, lintCtx *Context) ([]result.Issue, error) {
 	issues, err := duplAPI.Run(lintCtx.Paths.Files, lintCtx.RunCfg().Dupl.Threshold)
 	if err != nil {
 		return nil, err
 	}
 
-	res := &result.Result{}
+	var res []result.Issue
 	for _, i := range issues {
 		dupl := fmt.Sprintf("%s:%d-%d", i.To.Filename(), i.To.LineStart(), i.To.LineEnd())
 		text := fmt.Sprintf("%d-%d lines are duplicate of %s",
 			i.From.LineStart(), i.From.LineEnd(),
 			formatCode(dupl, lintCtx.RunCfg()))
-		res.Issues = append(res.Issues, result.Issue{
+		res = append(res, result.Issue{
 			File:       i.From.Filename(),
 			LineNumber: i.From.LineStart(),
 			Text:       text,