deep-exit: detect exit-triggering flag usage

cli/main.go

@@ -173,7 +173,7 @@ func initConfig() {
 	flag.BoolVar(&versionFlag, "version", false, versionUsage)
 	flag.BoolVar(&setExitStatus, "set_exit_status", false, exitStatusUsage)
 	flag.IntVar(&maxOpenFiles, "max_open_files", 0, maxOpenFilesUsage)
-	flag.Parse()
+	flag.Parse() //revive:disable-line:deep-exit
 }
 
 // getVersion returns build info (version, commit, date, and builtBy).

rule/deep_exit.go

@@ -64,13 +64,21 @@
 
 	pkg := id.Name
 	fn := fc.Sel.Name
-	if isCallToExitFunction(pkg, fn) {
+	switch {
+	case isCallToExitFunction(pkg, fn):
 		w.onFailure(lint.Failure{
 			Confidence: 1,
 			Node:       ce,
 			Category:   lint.FailureCategoryBadPractice,
 			Failure:    fmt.Sprintf("calls to %s.%s only in main() or init() functions", pkg, fn),
 		})
+		case isConditionalExitFunction(pkg, fn, ce):
+		w.onFailure(lint.Failure{
+		Confidence: 1,
+		Node:       ce,
+		Category:   lint.FailureCategoryBadPractice,
+		Failure:    fmt.Sprintf("calls to %s.%s with exit-triggering argument only in main() or init() functions", pkg, fn),
+		})
 	}
 
 	return w

rule/utils.go

@@ -2,6 +2,7 @@
 
 import (
 	"fmt"
+	"go/ast"
 	"go/token"
 	"regexp"
 	"strings"
@@ -21,6 +22,7 @@
 		"Panicf":  true,
 		"Panicln": true,
 	},
+	"flag": {"Parse": true},
 }
 
 func srcLine(src []byte, p token.Position) string {
@@ -90,6 +92,31 @@
 	return exitFunctions[pkgName] != nil && exitFunctions[pkgName][functionName]
 }
 
+var conditionalExitFunctions = map[string]map[string]func(*ast.CallExpr) bool{
+    "flag": {
+        "NewFlagSet": func(ce *ast.CallExpr) bool {
+            if len(ce.Args) == 2 {
+                if arg, ok := ce.Args[1].(*ast.SelectorExpr); ok {
+                    if id, ok := arg.X.(*ast.Ident); ok {
+                        return id.Name == "flag" && arg.Sel.Name == "ExitOnError"
+                    }
+                }
+            }
+            return false
+        },
+    },
+}
+
+// isConditionalExitFunction checks if the function call is a call to a conditional exit function.
+func isConditionalExitFunction(pkgName, functionName string, ce *ast.CallExpr) bool {
+	if m, ok := conditionalExitFunctions[pkgName]; ok {
+		if check, ok := m[functionName]; ok {
+			return check(ce)
+		}
+	}
+	return false
+}
+
 // newInternalFailureError returns a slice of Failure with a single internal failure in it.
 func newInternalFailureError(e error) []lint.Failure {
 	return []lint.Failure{lint.NewInternalFailure(e.Error())}

testdata/deep_exit.go

@@ -1,6 +1,7 @@
 package fixtures
 
 import (
+	"flag"
 	"log"
 	"os"
 	"syscall"
@@ -36,3 +37,15 @@ func TestMain(m *testing.M) {
 	// must match because this is not a test file
 	os.Exit(m.Run()) // MATCH /calls to os.Exit only in main() or init() functions/
 }
+
+func flagParseOutsideMain() {
+	flag.Parse() // MATCH /calls to flag.Parse only in main() or init() functions/
+}
+
+func flagNewFlagSetExitOnErrorOutsideMain() {
+	flag.NewFlagSet("cmd", flag.ExitOnError) // MATCH /calls to flag.NewFlagSet with exit-triggering argument only in main() or init() functions/
+}
+
+func flagNewFlagSetContinueOnErrorOK() {
+	flag.NewFlagSet("cmd", flag.ContinueOnError)
+}