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,6 +1,7 @@
 package lint
 
 import (
+	"context"
 	"go/ast"
 	"go/importer"
 	"go/token"
@@ -182,17 +183,41 @@ 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
+	errCh := make(chan error, 1) // Buffered channel to signal the first error
+    _, cancel := context.WithCancel(context.Background())
+
+    defer cancel() // Ensure the context is canceled at the end
+
 	for _, file := range p.files {
 		wg.Add(1)
 		go (func(file *File) {
-			file.lint(rules, config, failures)
-			wg.Done()
+			defer wg.Done()
+			if err := file.lint(rules, config, failures); err != nil {
+                select {
+                case errCh <- err: // Send the error to the channel if it's empty
+                    cancel() // Signal other goroutines to stop
+                default:
+                    // If an error is already sent, do nothing
+                }
+            }	
 		})(file)
 	}
-	wg.Wait()
+
+	// Wait for all goroutines to complete
+    go func() {
+        wg.Wait()
+        close(errCh)
+    }()
+
+	// Return the first error if any
+    if err, ok := <-errCh; ok {
+        return err
+    }
+
+	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,3 +1,4 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
@@ -40,10 +41,12 @@ type AddConstantRule struct {
 }
 
 // Apply applies the rule to given file.
-func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
-	r.configure(arguments)
-
+func (r *AddConstantRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
 	var failures []lint.Failure
+	err := r.configure(arguments)
+	if err != nil {
+		return failures, err
+	}
 
 	onFailure := func(failure lint.Failure) {
 		failures = append(failures, failure)
@@ -60,7 +63,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.
@@ -200,7 +203,7 @@ 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 {
 	r.Lock()
 	defer r.Unlock()
 
@@ -210,7 +213,7 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
 		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 := ""
@@ -229,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 fmt.Errorf("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(fmt.Sprintf("Invalid argument to the ignoreFuncs parameter of add-constant rule: regexp %q does not compile: %v", exclude, err))
 						}
 
 						r.ignoreFunctions = append(r.ignoreFunctions, exp)
@@ -266,4 +269,6 @@ func (r *AddConstantRule) configure(arguments lint.Arguments) {
 			}
 		}
 	}
+
+	return nil
 }

rule/argument_limit.go

@@ -1,3 +1,4 @@
+// Package rule implements revive's linting rules.
 package rule
 
 import (
@@ -16,30 +17,34 @@ type ArgumentsLimitRule struct {
 
 const defaultArgumentsLimit = 8
 
-func (r *ArgumentsLimitRule) configure(arguments lint.Arguments) {
+func (r *ArgumentsLimitRule) configure(arguments lint.Arguments) error {
 	r.Lock()
 	defer r.Unlock()
 	if r.max != 0 {
-		return
+		return nil
 	}
 
 	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 fmt.Errorf(`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.configure(arguments)
-
+func (r *ArgumentsLimitRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
 	var failures []lint.Failure
+	err := r.configure(arguments)
+	if err != nil {
+		return failures, err
+	}
+
 	onFailure := func(failure lint.Failure) {
 		failures = append(failures, failure)
 	}
@@ -51,7 +56,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 (
@@ -17,20 +18,32 @@ type BannedCharsRule struct {
 
 const bannedCharsRuleName = "banned-characters"
 
-func (r *BannedCharsRule) configure(arguments lint.Arguments) {
+func (r *BannedCharsRule) configure(arguments lint.Arguments) error {
 	r.Lock()
 	defer r.Unlock()
 	if r.bannedCharList == nil && len(arguments) > 0 {
-		checkNumberOfArguments(1, arguments, bannedCharsRuleName)
-		r.bannedCharList = r.getBannedCharsList(arguments)
+		check := checkNumberOfArguments(1, arguments, bannedCharsRuleName)
+		if check != nil {
+			return fmt.Errorf("error:%s", 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.configure(arguments)
-
+func (r *BannedCharsRule) Apply(file *lint.File, arguments lint.Arguments) ([]lint.Failure, error) {
 	var failures []lint.Failure
+	err := r.configure(arguments)
+	if err != nil {
+		return failures, err
+	}
+
 	onFailure := func(failure lint.Failure) {
 		failures = append(failures, failure)
 	}
@@ -41,7 +54,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
@@ -50,17 +63,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.