refactor: replace panic with error in rules

lint/file.go

@@ -96,7 +96,7 @@ func (f *File) isMain() bool {
 
 const directiveSpecifyDisableReason = "specify-disable-reason"
 
-func (f *File) lint(rules []Rule, config Config, failures chan Failure) {
+func (f *File) lint(rules []Rule, config Config, failures chan Failure) error {
 	rulesConfig := config.Rules
 	_, mustSpecifyDisableReason := config.Directives[directiveSpecifyDisableReason]
 	disabledIntervals := f.disabledIntervals(rules, mustSpecifyDisableReason, failures)
@@ -105,7 +105,10 @@ func (f *File) lint(rules []Rule, config Config, failures chan Failure) {
 		if ruleConfig.MustExclude(f.Name) {
 			continue
 		}
-		currentFailures := currentRule.Apply(f, ruleConfig.Arguments)
+		currentFailures, err := currentRule.Apply(f, ruleConfig.Arguments)
+		if err != nil {
+			return err
+		}
 		for idx, failure := range currentFailures {
 			if failure.RuleName == "" {
 				failure.RuleName = currentRule.Name()
@@ -122,6 +125,7 @@ func (f *File) lint(rules []Rule, config Config, failures chan Failure) {
 			}
 		}
 	}
+	return nil
 }
 
 type enableDisableConfig struct {

lint/linter.go

@@ -152,7 +152,11 @@ func (l *Linter) lintPackage(filenames []string, gover *goversion.Version, ruleS
 		return nil
 	}
 
-	pkg.lint(ruleSet, config, failures)
+	err := pkg.lint(ruleSet, config, failures)
+
+	if err != nil {
+		return err
+	}
 
 	return nil
 }

lint/package.go

@@ -1,10 +1,12 @@
 package lint
 
 import (
+	"fmt"
 	"go/ast"
 	"go/importer"
 	"go/token"
 	"go/types"
+	"os"
 	"sync"
 
 	goversion "github.com/hashicorp/go-version"
@@ -182,17 +184,22 @@ func (p *Package) scanSortable() {
 	}
 }
 
-func (p *Package) lint(rules []Rule, config Config, failures chan Failure) {
+func (p *Package) lint(rules []Rule, config Config, failures chan Failure) error {
 	p.scanSortable()
 	var wg sync.WaitGroup
 	for _, file := range p.files {
 		wg.Add(1)
 		go (func(file *File) {
-			file.lint(rules, config, failures)
+			err := file.lint(rules, config, failures)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			} 
 			wg.Done()
 		})(file)
 	}
 	wg.Wait()
+	return nil
 }
 
 // IsAtLeastGo121 returns true if the Go version for this package is 1.21 or higher, false otherwise

lint/rule.go

@@ -14,7 +14,7 @@ type DisabledInterval struct {
 // Rule defines an abstract rule interface
 type Rule interface {
 	Name() string
-	Apply(*File, Arguments) []Failure
+	Apply(*File, Arguments) ([]Failure, error)
 }
 
 // AbstractRule defines an abstract rule.

revivelib/core_internal_test.go

@@ -43,8 +43,8 @@ func (*mockRule) Name() string {
 	return "mock-rule"
 }
 
-func (*mockRule) Apply(_ *lint.File, _ lint.Arguments) []lint.Failure {
-	return nil
+func (*mockRule) Apply(_ *lint.File, _ lint.Arguments) ([]lint.Failure, error) {
+	return nil, nil
 }
 
 func getMockRevive(t *testing.T) *Revive {

revivelib/core_test.go

@@ -78,8 +78,8 @@ func (r *mockRule) Name() string {
 	return "mock-rule"
 }
 
-func (r *mockRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
-	return nil
+func (r *mockRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
+	return nil, nil
 }
 
 func getMockRevive(t *testing.T) *revivelib.Revive {

rule/add_constant.go

@@ -1,6 +1,8 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
+	"errors"
 	"fmt"
 	"go/ast"
 	"regexp"
@@ -36,13 +38,16 @@ type AddConstantRule struct {
 	allowList       allowList
 	ignoreFunctions []*regexp.Regexp
 	strLitLimit     int
-
-	configureOnce sync.Once
+	configureOnce   sync.Once
 }
 
 // Apply applies the rule to given file.
-func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
-	r.configureOnce.Do(func() { r.configure(arguments) })
+func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
+	var configureErr error
+	r.configureOnce.Do(func() { configureErr = r.configure(arguments) })
+	if configureErr != nil {
+		return nil, configureErr
+	}
 
 	var failures []lint.Failure
 
@@ -61,7 +66,7 @@ func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) []lin
 
 	ast.Walk(w, file.AST)
 
-	return failures
+	return failures, nil
 }
 
 // Name returns the rule name.
@@ -201,14 +206,14 @@ func (w *lintAddConstantRule) isStructTag(n *ast.BasicLit) bool {
 	return ok
 }
 
-func (r *AddConstantRule) configure(arguments lint.Arguments) {
+func (r *AddConstantRule) configure(arguments lint.Arguments) error {
 	if r.allowList == nil {
 		r.strLitLimit = defaultStrLitLimit
 		r.allowList = newAllowList()
 		if len(arguments) > 0 {
 			args, ok := arguments[0].(map[string]any)
 			if !ok {
-				panic(fmt.Sprintf("Invalid argument to the add-constant rule. Expecting a k,v map, got %T", arguments[0]))
+				return fmt.Errorf("Invalid argument to the add-constant rule. Expecting a k,v map, got %T", arguments[0])
 			}
 			for k, v := range args {
 				kind := ""
@@ -227,35 +232,35 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
 					}
 					list, ok := v.(string)
 					if !ok {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v))
+						return fmt.Errorf("Invalid argument to the add-constant rule, string expected. Got '%v' (%T)", v, v)
 					}
 					r.allowList.add(kind, list)
 				case "maxLitCount":
 					sl, ok := v.(string)
 					if !ok {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v' (%T)", v, v))
+						return fmt.Errorf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v' (%T)", v, v)
 					}
 
 					limit, err := strconv.Atoi(sl)
 					if err != nil {
-						panic(fmt.Sprintf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v'", v))
+						return fmt.Errorf("Invalid argument to the add-constant rule, expecting string representation of an integer. Got '%v'", v)
 					}
 					r.strLitLimit = limit
 				case "ignoreFuncs":
 					excludes, ok := v.(string)
 					if !ok {
-						panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule, string expected. Got '%v' (%T)", v, v))
+						return fmt.Errorf("Invalid argument to the ignoreFuncs parameter of add-constant rule, string expected. Got '%v' (%T)", v, v)
 					}
 
 					for _, exclude := range strings.Split(excludes, ",") {
 						exclude = strings.Trim(exclude, " ")
 						if exclude == "" {
-							panic("Invalid argument to the ignoreFuncs parameter of add-constant rule, expected regular expression must not be empty.")
+							return errors.New("Invalid argument to the ignoreFuncs parameter of add-constant rule, expected regular expression must not be empty")
 						}
 
 						exp, err := regexp.Compile(exclude)
 						if err != nil {
-							panic(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %v", exclude, err))
+							return fmt.Errorf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %w", exclude, err)
 						}
 
 						r.ignoreFunctions = append(r.ignoreFunctions, exp)
@@ -264,4 +269,6 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
 			}
 		}
 	}
+
+	return nil
 }

rule/argument_limit.go

@@ -1,6 +1,8 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
+	"errors"
 	"fmt"
 	"go/ast"
 	"sync"
@@ -10,29 +12,33 @@ import (
 
 // ArgumentsLimitRule lints given else constructs.
 type ArgumentsLimitRule struct {
-	max int
-
+	max           int
 	configureOnce sync.Once
 }
 
 const defaultArgumentsLimit = 8
 
-func (r *ArgumentsLimitRule) configure(arguments lint.Arguments) {
+func (r *ArgumentsLimitRule) configure(arguments lint.Arguments) error {
 	if len(arguments) < 1 {
 		r.max = defaultArgumentsLimit
-		return
+		return nil
 	}
 
 	maxArguments, ok := arguments[0].(int64) // Alt. non panicking version
 	if !ok {
-		panic(`invalid value passed as argument number to the "argument-limit" rule`)
+		return errors.New(`invalid value passed as argument number to the "argument-limit" rule`)
 	}
 	r.max = int(maxArguments)
+	return nil
 }
 
 // Apply applies the rule to given file.
-func (r *ArgumentsLimitRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
-	r.configureOnce.Do(func() { r.configure(arguments) })
+func (r *ArgumentsLimitRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
+	var configureErr error
+	r.configureOnce.Do(func() { configureErr = r.configure(arguments) })
+	if configureErr != nil {
+		return nil, configureErr
+	}
 
 	var failures []lint.Failure
 	onFailure := func(failure lint.Failure) {
@@ -46,7 +52,7 @@ func (r *ArgumentsLimitRule) Apply(file *lint.File, arguments lint.Arguments) []
 
 	ast.Walk(walker, file.AST)
 
-	return failures
+	return failures, nil
 }
 
 // Name returns the rule name.

rule/atomic.go

@@ -1,3 +1,4 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
@@ -12,7 +13,7 @@ import (
 type AtomicRule struct{}
 
 // Apply applies the rule to given file.
-func (*AtomicRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
+func (*AtomicRule) Apply(file *lint.File, _ lint.Arguments) ([]lint.Failure, error) {
 	var failures []lint.Failure
 	walker := atomic{
 		pkgTypesInfo: file.Pkg.TypesInfo(),
@@ -23,7 +24,7 @@ func (*AtomicRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
 
 	ast.Walk(walker, file.AST)
 
-	return failures
+	return failures, nil
 }
 
 // Name returns the rule name.

rule/banned_characters.go

@@ -1,3 +1,4 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
@@ -12,22 +13,34 @@ import (
 // BannedCharsRule checks if a file contains banned characters.
 type BannedCharsRule struct {
 	bannedCharList []string
-
-	configureOnce sync.Once
+	configureOnce  sync.Once
 }
 
 const bannedCharsRuleName = "banned-characters"
 
-func (r *BannedCharsRule) configure(arguments lint.Arguments) {
+func (r *BannedCharsRule) configure(arguments lint.Arguments) error {
 	if len(arguments) > 0 {
-		checkNumberOfArguments(1, arguments, bannedCharsRuleName)
-		r.bannedCharList = r.getBannedCharsList(arguments)
+		check := checkNumberOfArguments(1, arguments, bannedCharsRuleName)
+		if check != nil {
+			return check
+		}
+		list, err := r.getBannedCharsList(arguments)
+		if err != nil {
+			return err
+		}
+
+		r.bannedCharList = list
 	}
+	return nil
 }
 
 // Apply applied the rule to the given file.
-func (r *BannedCharsRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
-	r.configureOnce.Do(func() { r.configure(arguments) })
+func (r *BannedCharsRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
+	var configureErr error
+	r.configureOnce.Do(func() { configureErr = r.configure(arguments) })
+	if configureErr != nil {
+		return nil, configureErr
+	}
 
 	var failures []lint.Failure
 	onFailure := func(failure lint.Failure) {
@@ -40,7 +53,7 @@ func (r *BannedCharsRule) Apply(file *lint.File, arguments lint.Arguments) []lin
 	}
 
 	ast.Walk(w, file.AST)
-	return failures
+	return failures, nil
 }
 
 // Name returns the rule name
@@ -49,17 +62,17 @@ func (*BannedCharsRule) Name() string {
 }
 
 // getBannedCharsList converts arguments into the banned characters list
-func (r *BannedCharsRule) getBannedCharsList(args lint.Arguments) []string {
+func (r *BannedCharsRule) getBannedCharsList(args lint.Arguments) ([]string, error) {
 	var bannedChars []string
 	for _, char := range args {
 		charStr, ok := char.(string)
 		if !ok {
-			panic(fmt.Sprintf("Invalid argument for the %s rule: expecting a string, got %T", r.Name(), char))
+			return nil, fmt.Errorf("Invalid argument for the %s rule: expecting a string, got %T", r.Name(), char)
 		}
 		bannedChars = append(bannedChars, charStr)
 	}
 
-	return bannedChars
+	return bannedChars, nil
 }
 
 type lintBannedCharsRule struct {

rule/bare_return.go

@@ -1,3 +1,4 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
@@ -10,7 +11,7 @@ import (
 type BareReturnRule struct{}
 
 // Apply applies the rule to given file.
-func (*BareReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
+func (*BareReturnRule) Apply(file *lint.File, _ lint.Arguments) ([]lint.Failure, error) {
 	var failures []lint.Failure
 
 	onFailure := func(failure lint.Failure) {
@@ -19,7 +20,7 @@ func (*BareReturnRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
 
 	w := lintBareReturnRule{onFailure: onFailure}
 	ast.Walk(w, file.AST)
-	return failures
+	return failures, nil
 }
 
 // Name returns the rule name.