group of fixes after running on golang source code

Author: golangcidev

Gopkg.lock

@@ -1,2 +1,2 @@
 test:
-	go test -v ./...
+	go test -v -race ./...

Makefile

@@ -3,6 +3,7 @@ package commands
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/fatih/color"
 	"github.com/golangci/golangci-lint/pkg"
@@ -20,7 +21,7 @@ func (e *Executor) initLinters() {
 
 func printLinterConfigs(lcs []pkg.LinterConfig) {
 	for _, lc := range lcs {
-		fmt.Printf("%s: %s\n", color.YellowString(lc.Linter.Name()), lc.Desc)
+		fmt.Printf("%s: %s\n", color.YellowString(lc.Linter.Name()), lc.Linter.Desc())
 	}
 }
 
@@ -39,5 +40,15 @@ func (e Executor) executeLinters(cmd *cobra.Command, args []string) {
 	color.Red("\nDisabled by default linters:\n")
 	printLinterConfigs(disabledLCs)
 
+	color.Green("\nLinters presets:")
+	for _, p := range pkg.AllPresets() {
+		linters := pkg.GetAllLintersForPreset(p)
+		linterNames := []string{}
+		for _, linter := range linters {
+			linterNames = append(linterNames, linter.Name())
+		}
+		fmt.Printf("%s: %s\n", color.YellowString(p), strings.Join(linterNames, ", "))
+	}
+
 	os.Exit(0)
 }

internal/commands/linters.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"go/build"
+	"go/token"
 	"log"
 	"strings"
 	"time"
@@ -38,16 +39,16 @@ func (e *Executor) initRun() {
 		fmt.Sprintf("Format of output: %s", strings.Join(config.OutFormats, "|")))
 	runCmd.Flags().BoolVar(&rc.PrintIssuedLine, "print-issued-lines", true, "Print lines of code with issue")
 	runCmd.Flags().BoolVar(&rc.PrintLinterName, "print-linter-name", true, "Print linter name in issue line")
+	runCmd.Flags().BoolVar(&rc.PrintWelcomeMessage, "print-welcome", true, "Print welcome message")
 
 	runCmd.Flags().IntVar(&rc.ExitCodeIfIssuesFound, "issues-exit-code",
 		1, "Exit code when issues were found")
 	runCmd.Flags().StringSliceVar(&rc.BuildTags, "build-tags", []string{}, "Build tags (not all linters support them)")
 
-	runCmd.Flags().BoolVar(&rc.Errcheck.CheckClose, "errcheck.check-close", false, "Errcheck: check missed error checks on .Close() calls")
 	runCmd.Flags().BoolVar(&rc.Errcheck.CheckTypeAssertions, "errcheck.check-type-assertions", false, "Errcheck: check for ignored type assertion results")
 	runCmd.Flags().BoolVar(&rc.Errcheck.CheckAssignToBlank, "errcheck.check-blank", false, "Errcheck: check for errors assigned to blank identifier: _ = errFunc()")
 
-	runCmd.Flags().BoolVar(&rc.Govet.CheckShadowing, "govet.check-shadowing", true, "Govet: check for shadowed variables")
+	runCmd.Flags().BoolVar(&rc.Govet.CheckShadowing, "govet.check-shadowing", false, "Govet: check for shadowed variables")
 
 	runCmd.Flags().Float64Var(&rc.Golint.MinConfidence, "golint.min-confidence", 0.8, "Golint: minimum confidence of a problem to print it")
 
@@ -90,6 +91,9 @@ func (e *Executor) initRun() {
 	runCmd.Flags().StringVar(&rc.DiffFromRevision, "new-from-rev", "", "Show only new issues created after git revision `REV`")
 	runCmd.Flags().StringVar(&rc.DiffPatchFilePath, "new-from-patch", "", "Show only new issues created in git patch with file path `PATH`")
 	runCmd.Flags().BoolVar(&rc.AnalyzeTests, "tests", false, "Analyze tests (*_test.go)")
+
+	runCmd.Flags().StringSliceVarP(&rc.Presets, "presets", "p", []string{},
+		fmt.Sprintf("Enable presets (%s) of linters. Run 'golangci-lint linters' to see them. This option implies option --disable-all", strings.Join(pkg.AllPresets(), "|")))
 }
 
 func isFullImportNeeded(linters []pkg.Linter) bool {
@@ -208,10 +212,15 @@ func (e *Executor) runAnalysis(ctx context.Context, args []string) (chan result.
 	if len(excludePatterns) != 0 {
 		excludeTotalPattern = fmt.Sprintf("(%s)", strings.Join(excludePatterns, "|"))
 	}
+	fset := token.NewFileSet()
+	if lintCtx.Program != nil {
+		fset = lintCtx.Program.Fset
+	}
 	runner := pkg.SimpleRunner{
 		Processors: []processors.Processor{
 			processors.NewExclude(excludeTotalPattern),
-			processors.NewNolint(lintCtx.Program.Fset),
+			processors.NewCgo(),
+			processors.NewNolint(fset),
 			processors.NewUniqByLine(),
 			processors.NewDiff(e.cfg.Run.Diff, e.cfg.Run.DiffFromRevision, e.cfg.Run.DiffPatchFilePath),
 			processors.NewMaxPerFileFromLinter(),
@@ -231,6 +240,10 @@ func (e *Executor) executeRun(cmd *cobra.Command, args []string) {
 		logrus.Infof("Run took %s", time.Since(startedAt))
 	}(time.Now())
 
+	if e.cfg.Run.PrintWelcomeMessage {
+		fmt.Println("Run this tool in cloud on every github pull request in https://golangci.com for free (public repos)")
+	}
+
 	f := func() error {
 		issues, err := e.runAnalysis(ctx, args)
 		if err != nil {

internal/commands/run.go

@@ -15,6 +15,7 @@ const (
 var OutFormats = []string{OutFormatColoredLineNumber, OutFormatLineNumber, OutFormatJSON}
 
 var DefaultExcludePatterns = []string{
+	"Error return value of `(os\\.Std(out|err)\\.Write|.*\\.Close)` is not checked",
 	"should have comment",
 	"comment on exported method",
 	"G104", // disable what errcheck does: it reports on Close etc
@@ -33,14 +34,14 @@ type Run struct { // nolint:maligned
 
 	BuildTags []string
 
-	OutFormat       string
-	PrintIssuedLine bool
-	PrintLinterName bool
+	OutFormat           string
+	PrintIssuedLine     bool
+	PrintLinterName     bool
+	PrintWelcomeMessage bool
 
 	ExitCodeIfIssuesFound int
 
 	Errcheck struct {
-		CheckClose          bool
 		CheckTypeAssertions bool
 		CheckAssignToBlank  bool
 	}
@@ -83,6 +84,8 @@ type Run struct { // nolint:maligned
 	EnableAllLinters  bool
 	DisableAllLinters bool
 
+	Presets []string
+
 	ExcludePatterns    []string
 	UseDefaultExcludes bool
 

pkg/config/config.go

@@ -3,19 +3,69 @@ package pkg
 import (
 	"context"
 	"fmt"
+	"strings"
 	"sync"
 
 	"github.com/golangci/golangci-lint/pkg/config"
 	"github.com/golangci/golangci-lint/pkg/golinters"
 	"github.com/sirupsen/logrus"
 )
 
+const (
+	PresetFormatting  = "format"
+	PresetComplexity  = "complexity"
+	PresetStyle       = "style"
+	PresetBugs        = "bugs"
+	PresetUnused      = "unused"
+	PresetPerformance = "performance"
+)
+
+func AllPresets() []string {
+	return []string{PresetBugs, PresetUnused, PresetFormatting, PresetStyle, PresetComplexity, PresetPerformance}
+}
+
+func allPresetsSet() map[string]bool {
+	ret := map[string]bool{}
+	for _, p := range AllPresets() {
+		ret[p] = true
+	}
+	return ret
+}
+
 type LinterConfig struct {
-	Desc             string
 	Linter           Linter
 	EnabledByDefault bool
 	DoesFullImport   bool
 	NeedsSSARepr     bool
+	InPresets        []string
+}
+
+func (lc LinterConfig) WithFullImport() LinterConfig {
+	lc.DoesFullImport = true
+	return lc
+}
+
+func (lc LinterConfig) WithSSA() LinterConfig {
+	lc.DoesFullImport = true
+	lc.NeedsSSARepr = true
+	return lc
+}
+
+func (lc LinterConfig) WithPresets(presets ...string) LinterConfig {
+	lc.InPresets = presets
+	return lc
+}
+
+func (lc LinterConfig) WithDisabledByDefault() LinterConfig {
+	lc.EnabledByDefault = false
+	return lc
+}
+
+func newLinterConfig(linter Linter) LinterConfig {
+	return LinterConfig{
+		Linter:           linter,
+		EnabledByDefault: true,
+	}
 }
 
 var nameToLC map[string]LinterConfig
@@ -37,46 +87,26 @@ func GetLinterConfig(name string) *LinterConfig {
 	return &lc
 }
 
-func enabledByDefault(linter Linter, desc string, doesFullImport, needsSSARepr bool) LinterConfig {
-	return LinterConfig{
-		EnabledByDefault: true,
-		Linter:           linter,
-		Desc:             desc,
-		DoesFullImport:   doesFullImport,
-		NeedsSSARepr:     needsSSARepr,
-	}
-}
-
-func disabledByDefault(linter Linter, desc string, doesFullImport, needsSSARepr bool) LinterConfig {
-	return LinterConfig{
-		EnabledByDefault: false,
-		Linter:           linter,
-		Desc:             desc,
-		DoesFullImport:   doesFullImport,
-		NeedsSSARepr:     needsSSARepr,
-	}
-}
-
 func GetAllSupportedLinterConfigs() []LinterConfig {
 	return []LinterConfig{
-		enabledByDefault(golinters.Govet{}, "Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string", false, false),
-		enabledByDefault(golinters.Errcheck{}, "Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases", true, false),
-		enabledByDefault(golinters.Golint{}, "Golint differs from gofmt. Gofmt reformats Go source code, whereas golint prints out style mistakes", false, false),
-		enabledByDefault(golinters.Megacheck{}, "Megacheck: 3 sub-linters in one: staticcheck, gosimple and unused", true, true),
-		enabledByDefault(golinters.Gas{}, "Inspects source code for security problems", true, false),
-		enabledByDefault(golinters.Structcheck{}, "Finds unused struct fields", true, false),
-		enabledByDefault(golinters.Varcheck{}, "Finds unused global variables and constants", true, false),
-		enabledByDefault(golinters.Interfacer{}, "Linter that suggests narrower interface types", true, true),
-		enabledByDefault(golinters.Unconvert{}, "Remove unnecessary type conversions", true, false),
-		enabledByDefault(golinters.Ineffassign{}, "Detects when assignments to existing variables are not used", false, false),
-		enabledByDefault(golinters.Dupl{}, "Tool for code clone detection", false, false),
-		enabledByDefault(golinters.Goconst{}, "Finds repeated strings that could be replaced by a constant", false, false),
-		enabledByDefault(golinters.Deadcode{}, "Finds unused code", true, false),
-		enabledByDefault(golinters.Gocyclo{}, "Computes and checks the cyclomatic complexity of functions", false, false),
-
-		disabledByDefault(golinters.Gofmt{}, "Gofmt checks whether code was gofmt-ed. By default this tool runs with -s option to check for code simplification", false, false),
-		disabledByDefault(golinters.Gofmt{UseGoimports: true}, "Goimports does everything that gofmt does. Additionally it checks unused imports", false, false),
-		disabledByDefault(golinters.Maligned{}, "Tool to detect Go structs that would take less memory if their fields were sorted", true, false),
+		newLinterConfig(golinters.Govet{}).WithPresets(PresetBugs),
+		newLinterConfig(golinters.Errcheck{}).WithFullImport().WithPresets(PresetBugs),
+		newLinterConfig(golinters.Golint{}).WithDisabledByDefault().WithPresets(PresetStyle),
+		newLinterConfig(golinters.Megacheck{}).WithSSA().WithPresets(PresetBugs, PresetUnused, PresetStyle),
+		newLinterConfig(golinters.Gas{}).WithFullImport().WithPresets(PresetBugs),
+		newLinterConfig(golinters.Structcheck{}).WithFullImport().WithPresets(PresetUnused),
+		newLinterConfig(golinters.Varcheck{}).WithFullImport().WithPresets(PresetUnused),
+		newLinterConfig(golinters.Interfacer{}).WithDisabledByDefault().WithSSA().WithPresets(PresetStyle),
+		newLinterConfig(golinters.Unconvert{}).WithDisabledByDefault().WithFullImport().WithPresets(PresetStyle),
+		newLinterConfig(golinters.Ineffassign{}).WithPresets(PresetUnused),
+		newLinterConfig(golinters.Dupl{}).WithDisabledByDefault().WithPresets(PresetStyle),
+		newLinterConfig(golinters.Goconst{}).WithDisabledByDefault().WithPresets(PresetStyle),
+		newLinterConfig(golinters.Deadcode{}).WithFullImport().WithPresets(PresetUnused),
+		newLinterConfig(golinters.Gocyclo{}).WithDisabledByDefault().WithPresets(PresetComplexity),
+
+		newLinterConfig(golinters.Gofmt{}).WithDisabledByDefault().WithPresets(PresetFormatting),
+		newLinterConfig(golinters.Gofmt{UseGoimports: true}).WithDisabledByDefault().WithPresets(PresetFormatting),
+		newLinterConfig(golinters.Maligned{}).WithFullImport().WithDisabledByDefault().WithPresets(PresetPerformance),
 	}
 }
 
@@ -132,6 +162,17 @@ func validateEnabledDisabledLintersConfig(cfg *config.Run) error {
 		}
 	}
 
+	allPresets := allPresetsSet()
+	for _, p := range cfg.Presets {
+		if !allPresets[p] {
+			return fmt.Errorf("no such preset %q: only next presets exist: (%s)", p, strings.Join(AllPresets(), "|"))
+		}
+	}
+
+	if len(cfg.Presets) != 0 && cfg.EnableAllLinters {
+		return fmt.Errorf("--presets is incompatible with --enable-all")
+	}
+
 	if cfg.EnableAllLinters && cfg.DisableAllLinters {
 		return fmt.Errorf("--enable-all and --disable-all options must not be combined")
 	}
@@ -164,12 +205,29 @@ func validateEnabledDisabledLintersConfig(cfg *config.Run) error {
 	return nil
 }
 
+func GetAllLintersForPreset(p string) []Linter {
+	ret := []Linter{}
+	for _, lc := range GetAllSupportedLinterConfigs() {
+		for _, ip := range lc.InPresets {
+			if p == ip {
+				ret = append(ret, lc.Linter)
+				break
+			}
+		}
+	}
+
+	return ret
+}
+
 func GetEnabledLinters(ctx context.Context, cfg *config.Run) ([]Linter, error) {
 	if err := validateEnabledDisabledLintersConfig(cfg); err != nil {
 		return nil, err
 	}
+
 	resultLintersSet := map[string]Linter{}
 	switch {
+	case len(cfg.Presets) != 0:
+		break // imply --disable-all
 	case cfg.EnableAllLinters:
 		resultLintersSet = lintersToMap(getAllSupportedLinters())
 	case cfg.DisableAllLinters:
@@ -182,6 +240,32 @@ func GetEnabledLinters(ctx context.Context, cfg *config.Run) ([]Linter, error) {
 		resultLintersSet[name] = getLinterByName(name)
 	}
 
+	// XXX: hacks because of sub-linters in megacheck
+	megacheckWasEnabledByUser := resultLintersSet["megacheck"] != nil
+	if !megacheckWasEnabledByUser {
+		cfg.Megacheck.EnableGosimple = false
+		cfg.Megacheck.EnableStaticcheck = false
+		cfg.Megacheck.EnableUnused = false
+	}
+
+	for _, p := range cfg.Presets {
+		for _, linter := range GetAllLintersForPreset(p) {
+			resultLintersSet[linter.Name()] = linter
+		}
+
+		if !megacheckWasEnabledByUser {
+			if p == PresetBugs {
+				cfg.Megacheck.EnableStaticcheck = true
+			}
+			if p == PresetStyle {
+				cfg.Megacheck.EnableGosimple = true
+			}
+			if p == PresetUnused {
+				cfg.Megacheck.EnableUnused = true
+			}
+		}
+	}
+
 	for _, name := range cfg.DisabledLinters {
 		delete(resultLintersSet, name)
 	}
@@ -192,7 +276,10 @@ func GetEnabledLinters(ctx context.Context, cfg *config.Run) ([]Linter, error) {
 		resultLinters = append(resultLinters, linter)
 		resultLinterNames = append(resultLinterNames, name)
 	}
-	logrus.Infof("Enabled linters: %s", resultLinterNames)
+	logrus.Infof("Active linters: %s", resultLinterNames)
+	if len(cfg.Presets) != 0 {
+		logrus.Infof("Active presets: %s", cfg.Presets)
+	}
 
 	return resultLinters, nil
 }

pkg/enabled_linters.go

@@ -56,6 +56,8 @@ func testOneSource(t *testing.T, sourcePath string) {
 		"--print-issued-lines=false",
 		"--print-linter-name=false",
 		"--out-format=line-number",
+		"--print-welcome=false",
+		"--govet.check-shadowing=true",
 		sourcePath)
 	runGoErrchk(cmd, t)
 }