(Resolves golangci#1981) Allow exit failure only on specified severities

Author: ImprintNav

.golangci.reference.yml

@@ -2443,6 +2443,12 @@ severity:
   # Default: false
   case-sensitive: true
 
+  # Issue severities required to cause an exit with a non-successful code. An empty list means
+  # that any issue severity will cause a non-successful exit code. Severities should match the
+  # supported severity names of the selected out format.
+  # Default: []
+  fail-on-severities: ["warning", "error"]
+
   # When a list of severity rules are provided, severity information will be added to lint issues.
   # Severity rules have the same filtering capability as exclude rules
   # except you are allowed to specify one matcher per severity rule.

pkg/commands/run.go

@@ -233,6 +233,11 @@ func initFlagSet(fs *pflag.FlagSet, cfg *config.Config, m *lintersdb.Manager, is
 	fs.BoolVar(&ic.WholeFiles, "whole-files", false,
 		wh("Show issues in any part of update files (requires new-from-rev or new-from-patch)"))
 	fs.BoolVar(&ic.NeedFix, "fix", false, "Fix found issues (if it's supported by the linter)")
+
+	// Severities config
+	sc := &cfg.Severity
+	fs.StringSliceVar(&sc.FailOnSeverities, "fail-on-severities", nil,
+		wh("Fail only if issues matching these severities are found"))
 }
 
 func (e *Executor) initRunConfiguration(cmd *cobra.Command) {
@@ -371,8 +376,26 @@ func (e *Executor) setOutputToDevNull() (savedStdout, savedStderr *os.File) {
 }
 
 func (e *Executor) setExitCodeIfIssuesFound(issues []result.Issue) {
-	if len(issues) != 0 {
-		e.exitCode = e.cfg.Run.ExitCodeIfIssuesFound
+	if len(issues) == 0 {
+		return
+	}
+	// treat empty set of failure severities as "fail on all issues"
+	if len(e.cfg.Severity.FailOnSeverities) == 0 {
+		if len(issues) > 0 {
+			e.exitCode = e.cfg.Run.ExitCodeIfIssuesFound
+		}
+		return
+	}
+
+	failSeveritySet := map[string]struct{}{}
+	for _, s := range e.cfg.Severity.FailOnSeverities {
+		failSeveritySet[s] = struct{}{}
+	}
+	for i := range issues {
+		if _, isFailure := failSeveritySet[issues[i].Severity]; isFailure {
+			e.exitCode = e.cfg.Run.ExitCodeIfIssuesFound
+			return
+		}
 	}
 }
 

pkg/config/reader.go

@@ -144,6 +144,9 @@ func (r *FileReader) validateConfig() error {
 	if len(c.Severity.Rules) > 0 && c.Severity.Default == "" {
 		return errors.New("can't set severity rule option: no default severity defined")
 	}
+	if len(c.Severity.FailOnSeverities) > 0 && c.Severity.Default == "" {
+		return errors.New("can't set severity failure set 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: %v", i, err)

pkg/config/severity.go

@@ -3,9 +3,10 @@ package config
 const severityRuleMinConditionsCount = 1
 
 type Severity struct {
-	Default       string         `mapstructure:"default-severity"`
-	CaseSensitive bool           `mapstructure:"case-sensitive"`
-	Rules         []SeverityRule `mapstructure:"rules"`
+	Default          string         `mapstructure:"default-severity"`
+	CaseSensitive    bool           `mapstructure:"case-sensitive"`
+	FailOnSeverities []string       `mapstructure:"fail-on-severities"`
+	Rules            []SeverityRule `mapstructure:"rules"`
 }
 
 type SeverityRule struct {

test/run_test.go

@@ -452,6 +452,37 @@ func TestUnusedCheckExported(t *testing.T) {
 		ExpectNoIssues()
 }
 
+func TestSuccessfulExitOnInsufficientlySevereIssues(t *testing.T) {
+	testshared.NewRunnerBuilder(t).
+		WithConfigFile("testdata_etc/fail_on_severities/staticcheck_ignore_warning_level.yml").
+		WithTargetPath("testdata_etc/fail_on_severities/...").
+		Runner().
+		Install().
+		Run().
+		ExpectExitCode(exitcodes.Success)
+}
+
+func TestFailedExitOnSufficientlySevereIssues(t *testing.T) {
+	testshared.NewRunnerBuilder(t).
+		WithConfigFile("testdata_etc/fail_on_severities/staticcheck_ignore_info_level.yml").
+		WithTargetPath("testdata_etc/fail_on_severities/...").
+		Runner().
+		Install().
+		Run().
+		ExpectExitCode(exitcodes.IssuesFound)
+}
+
+func TestFailedExitOnSufficientlySevereIssuesCmdFlag(t *testing.T) {
+	testshared.NewRunnerBuilder(t).
+		WithConfigFile("testdata_etc/fail_on_severities/staticcheck_ignore_warning_level.yml").
+		WithTargetPath("testdata_etc/fail_on_severities/...").
+		WithArgs("--fail-on-severities", "warning,error").
+		Runner().
+		Install().
+		Run().
+		ExpectExitCode(exitcodes.IssuesFound)
+}
+
 func TestConfigFileIsDetected(t *testing.T) {
 	testshared.InstallGolangciLint(t)
 

test/testdata_etc/fail_on_severities/staticcheck_deprecated.go

@@ -0,0 +1,29 @@
+package testdata
+
+import (
+	"fmt"
+)
+
+const half = 0.5
+
+// Deprecated: use floatRounder instead
+func deprecatedFloatRounder(f float64) int64 {
+	return int64(f)
+}
+
+func floatRounder(f float64) int64 {
+	sgn := int64(1)
+	if f < 0 {
+		sgn = -1
+	}
+	out := int64(f)
+	if f-float64(out) > half {
+		out++
+	}
+	return sgn * out
+}
+
+func StaticCheckExitSuccessOnInfo() {
+	fmt.Println(deprecatedFloatRounder(1.0)) // want "SA1019: deprecatedFloatRounder is deprecated"
+	fmt.Println(floatRounder(1.0))
+}

test/testdata_etc/fail_on_severities/staticcheck_ignore_info_level.yml

@@ -0,0 +1,18 @@
+linter-settings:
+  disable-all: true
+  enable:
+    - staticcheck 
+severity:
+  default-severity: error
+  fail-on-severities:
+    - warning
+    - error
+  rules:
+    - linters:
+        - staticcheck
+      severity: info
+      text: 'SA1019:'
+    - linters:
+        - staticcheck
+      severity: warning 
+      text: 'SA4016:'

test/testdata_etc/fail_on_severities/staticcheck_ignore_warning_level.yml

@@ -0,0 +1,17 @@
+linter-settings:
+  disable-all: true
+  enable:
+    - staticcheck 
+severity:
+  default-severity: error
+  fail-on-severities:
+    - error
+  rules:
+    - linters:
+        - staticcheck
+      severity: info
+      text: 'SA1019:'
+    - linters:
+        - staticcheck
+      severity: warning 
+      text: 'SA4016:'

test/testdata_etc/fail_on_severities/staticcheck_self_assign.go

@@ -0,0 +1,14 @@
+package testdata
+
+import (
+	"fmt"
+)
+
+func uselessFunction(val int) int {
+	return val ^ 0
+}
+
+func StaticCheckExitFailOnInfo() {
+	x := uselessFunction(1)
+	fmt.Println(x)
+}