unused-param,unused-receiver: refactor configure func (#1157)

rule/unused_param.go

@@ -9,6 +9,8 @@ import (
 	"github.com/mgechev/revive/lint"
 )
 
+var allowBlankIdentifierRegex = regexp.MustCompile("^_$")
+
 // UnusedParamRule lints unused params in functions.
 type UnusedParamRule struct {
 	// regex to check if some name is valid for unused parameter, "^_$" by default
@@ -21,31 +23,30 @@ type UnusedParamRule struct {
 func (r *UnusedParamRule) configure(args lint.Arguments) {
 	// while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives
 	// it's more compatible to JSON nature of configurations
-	var allowRegexStr string
+	r.allowRegex = allowBlankIdentifierRegex
-	if len(args) == 0 {
-		allowRegexStr = "^_$"
 	r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it as _"
-	} else {
+	if len(args) == 0 {
+		return
+	}
 	// Arguments = [{}]
 	options := args[0].(map[string]any)
-		// Arguments = [{allowRegex="^_"}]
 
-		if allowRegexParam, ok := options["allowRegex"]; ok {
+	allowRegexParam, ok := options["allowRegex"]
-			allowRegexStr, ok = allowRegexParam.(string)
+	if !ok {
+		return
+	}
+	// Arguments = [{allowRegex="^_"}]
+	allowRegexStr, ok := allowRegexParam.(string)
 	if !ok {
 		panic(fmt.Errorf("error configuring %s rule: allowRegex is not string but [%T]", r.Name(), allowRegexParam))
 	}
-		}
-	}
 	var err error
 	r.allowRegex, err = regexp.Compile(allowRegexStr)
 	if err != nil {
 		panic(fmt.Errorf("error configuring %s rule: allowRegex is not valid regex [%s]: %v", r.Name(), allowRegexStr, err))
 	}
-	if r.failureMsg == "" {
 	r.failureMsg = "parameter '%s' seems to be unused, consider removing or renaming it to match " + r.allowRegex.String()
 }
-}
 
 // Apply applies the rule to given file.
 func (r *UnusedParamRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure {

rule/unused_receiver.go

@@ -21,31 +21,30 @@ type UnusedReceiverRule struct {
 func (r *UnusedReceiverRule) configure(args lint.Arguments) {
 	// while by default args is an array, i think it's good to provide structures inside it by default, not arrays or primitives
 	// it's more compatible to JSON nature of configurations
-	var allowRegexStr string
+	r.allowRegex = allowBlankIdentifierRegex
-	if len(args) == 0 {
-		allowRegexStr = "^_$"
 	r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it as _"
-	} else {
+	if len(args) == 0 {
+		return
+	}
 	// Arguments = [{}]
 	options := args[0].(map[string]any)
-		// Arguments = [{allowRegex="^_"}]
 
-		if allowRegexParam, ok := options["allowRegex"]; ok {
+	allowRegexParam, ok := options["allowRegex"]
-			allowRegexStr, ok = allowRegexParam.(string)
+	if !ok {
+		return
+	}
+	// Arguments = [{allowRegex="^_"}]
+	allowRegexStr, ok := allowRegexParam.(string)
 	if !ok {
 		panic(fmt.Errorf("error configuring [unused-receiver] rule: allowRegex is not string but [%T]", allowRegexParam))
 	}
-		}
-	}
 	var err error
 	r.allowRegex, err = regexp.Compile(allowRegexStr)
 	if err != nil {
 		panic(fmt.Errorf("error configuring [unused-receiver] rule: allowRegex is not valid regex [%s]: %v", allowRegexStr, err))
 	}
-	if r.failureMsg == "" {
 	r.failureMsg = "method receiver '%s' is not referenced in method's body, consider removing or renaming it to match " + r.allowRegex.String()
 }
-}
 
 // Apply applies the rule to given file.
 func (r *UnusedReceiverRule) Apply(file *lint.File, args lint.Arguments) []lint.Failure {

test/unused_param_test.go

@@ -9,6 +9,10 @@ import (
 
 func TestUnusedParam(t *testing.T) {
 	testRule(t, "unused_param", &rule.UnusedParamRule{})
+	testRule(t, "unused_param", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{}})
+	testRule(t, "unused_param", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
+		map[string]any{"a": "^xxx"},
+	}})
 	testRule(t, "unused_param_custom_regex", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
 		map[string]any{"allowRegex": "^xxx"},
 	}})

test/unused_receiver_test.go

@@ -9,7 +9,18 @@ import (
 
 func TestUnusedReceiver(t *testing.T) {
 	testRule(t, "unused_receiver", &rule.UnusedReceiverRule{})
+	testRule(t, "unused_receiver", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{}})
+	testRule(t, "unused_receiver", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
+		map[string]any{"a": "^xxx"},
+	}})
 	testRule(t, "unused_receiver_custom_regex", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
 		map[string]any{"allowRegex": "^xxx"},
 	}})
 }
+
+func BenchmarkUnusedReceiver(b *testing.B) {
+	var t *testing.T
+	for i := 0; i <= b.N; i++ {
+		testRule(t, "unused_receiver", &rule.UnusedReceiverRule{})
+	}
+}