redundant-import-alias: add param ignoreUsed to ignore redundant alia…

…ses but used in code (useful for sdk packages)

RULES_DESCRIPTIONS.md

@@ -672,9 +672,18 @@ _Configuration_: N/A
 
 ## redundant-import-alias
 
-_Description_: This rule warns on redundant import aliases. This happens when the alias used on the import statement matches the imported package name.
+_Description_: This rule warns on redundant import aliases. This happens when the alias used on the import statement matches the imported package name. 
 
-_Configuration_: N/A
+_Configuration_:
+
+* `ignoreUsed` : (bool) ignore aliases used in code (useful when using popular sdk packages).
+
+Example:
+
+```toml
+[rule.redundant-import-alias]
+  arguments = [{ ignoreUsed = true}]
+```
 
 ## string-format
 

rule/redundant-import-alias.go

@@ -3,30 +3,38 @@ package rule
 import (
 	"fmt"
 	"go/ast"
-	"strings"
+	"sync"
 
 	"github.com/mgechev/revive/lint"
 )
 
+const (
+	defaultIgnoreUsed = false
+)
+
 // RedundantImportAlias lints given else constructs.
-type RedundantImportAlias struct{}
+type RedundantImportAlias struct {
+	ignoreUsed bool
+	sync.Mutex
+}
 
 // Apply applies the rule to given file.
-func (*RedundantImportAlias) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
+func (r *RedundantImportAlias) Apply(file *lint.File, arguments lint.Arguments) []lint.Failure {
+	r.configure(arguments)
+
 	var failures []lint.Failure
 
-	redundants := checkRedundantAliases(file.AST)
+	redundants := r.checkRedundantAliases(file.AST)
 
 	for _, imp := range file.AST.Imports {
 		if imp.Name == nil {
 			continue
 		}
 
 		if _, exists := redundants[imp.Name.Name]; exists {
-			var aliastype = redundants[imp.Name.Name]
 			failures = append(failures, lint.Failure{
 				Confidence: 1,
-				Failure:    fmt.Sprintf("Import alias \"%s\" is %s", imp.Name.Name, aliastype),
+				Failure:    fmt.Sprintf("Import alias \"%s\" is redundant", imp.Name.Name),
 				Node:       imp,
 				Category:   "imports",
 			})
@@ -40,22 +48,9 @@ func (*RedundantImportAlias) Name() string {
 	return "redundant-import-alias"
 }
 
-func getImportPackageName(imp *ast.ImportSpec) string {
-	const pathSep = "/"
-	const strDelim = `"`
-
-	path := imp.Path.Value
-	i := strings.LastIndex(path, pathSep)
-	if i == -1 {
-		return strings.Trim(path, strDelim)
-	}
-
-	return strings.Trim(path[i+1:], strDelim)
-}
+func (r *RedundantImportAlias) checkRedundantAliases(node ast.Node) map[string]string {
 
-func checkRedundantAliases(node ast.Node) map[string]string {
-	var redundants = make(map[string]string)
-    var aliasedPackages = make(map[string]string)
+	var aliasedPackages = make(map[string]string)
 
 	// First pass: Identify all aliases and their usage - by default alias is redundant
 	ast.Inspect(node, func(n ast.Node) bool {
@@ -70,29 +65,52 @@ func checkRedundantAliases(node ast.Node) map[string]string {
 		return true
 	})
 
-	// Second pass: Check if any of the aliases are redundant
-	ast.Inspect(node, func(n ast.Node) bool {
-		sel, ok := n.(*ast.SelectorExpr)
-		if !ok {
+	if r.ignoreUsed {
+		// Second pass: remove one time used aliases
+		ast.Inspect(node, func(n ast.Node) bool {
+			sel, ok := n.(*ast.SelectorExpr)
+			if !ok {
+				return true
+			}
+
+			x, ok := sel.X.(*ast.Ident)
+			if !ok {
+				return true
+			}
+
+			// This alias is being used; it's not redundant
+			if _, exists := aliasedPackages[x.Name]; exists {
+				delete(aliasedPackages, x.Name)
+			}
+
 			return true
-		}
+		})
+	}
+
+	return aliasedPackages
+}
+
+func (r *RedundantImportAlias) configure(arguments lint.Arguments) {
+	r.Lock()
+	defer r.Unlock()
 
-		x, ok := sel.X.(*ast.Ident)
+	r.ignoreUsed = defaultIgnoreUsed
+	if len(arguments) > 0 {
+
+		args, ok := arguments[0].(map[string]any)
 		if !ok {
-			return true
+			panic(fmt.Sprintf("Invalid argument to the redundant-import-alias rule. Expecting a k,v map, got %T", arguments[0]))
 		}
 
-		// This alias is being used; it's not redundant
-        if _, exists := aliasedPackages[x.Name]; exists {
-			delete(aliasedPackages, x.Name)
-		} 
-
-        return true
-	})
-
-	for name, value := range aliasedPackages {
-		redundants[name] = value
+		for k, v := range args {
+			switch k {
+			case "ignoreUsed":
+				value, ok := v.(bool)
+				if !ok {
+					panic(fmt.Sprintf("Invalid argument to the redundant-import-alias rule, expecting string representation of an bool. Got '%v' (%T)", v, v))
+				}
+				r.ignoreUsed = value
+			}
+		}
 	}
-
-	return redundants
 }

test/redundant-import-alias_test.go

@@ -1,11 +1,33 @@
 package test
 
 import (
-	"github.com/mgechev/revive/rule"
 	"testing"
+
+	"github.com/mgechev/revive/lint"
+	"github.com/mgechev/revive/rule"
 )
 
 // TestRedundantImportAlias rule.
+func TestRedundantImportIgnoredAliases(t *testing.T) {
+
+	args := []any{map[string]any{
+		"ignoreUsed": true,
+	}}
+
+	testRule(t, "redundant-import-alias-ignored", &rule.RedundantImportAlias{}, &lint.RuleConfig{
+		Arguments: args,
+	})
+
+}
+
 func TestRedundantImportAlias(t *testing.T) {
-	testRule(t, "redundant-import-alias", &rule.RedundantImportAlias{})
+
+	args := []any{map[string]any{
+		"ignoreUsed": false,
+	}}
+
+	testRule(t, "redundant-import-alias", &rule.RedundantImportAlias{}, &lint.RuleConfig{
+		Arguments: args,
+	})
+
 }

testdata/redundant-import-alias-ignored.go

@@ -0,0 +1,22 @@
+package fixtures
+
+import (
+	runpb "cloud.google.com/go/run/apiv2/runpb"
+	md5 "crypto/md5"
+	strings "strings" // MATCH /Import alias "strings" is redundant/
+
+	"crypto/md5"
+	_ "crypto/md5" // MATCH /Import alias "_" is redundant/
+
+	"strings"
+	str "strings" // MATCH /Import alias "str" is redundant/
+
+)
+
+func UseRunpb() {
+	runpb.RegisterTasksServer()
+}
+
+func UseMd5() {
+	fmt.PrintLn(md5.Size)
+}

testdata/redundant-import-alias.go

@@ -1,8 +1,10 @@
 package fixtures
 
 import (
-	runpb "cloud.google.com/go/run/apiv2/runpb"
-	md5 "crypto/md5"
+	runpb "cloud.google.com/go/run/apiv2/runpb" // MATCH /Import alias "runpb" is redundant/
+
+	md5 "crypto/md5" // MATCH /Import alias "md5" is redundant/
+
 	strings "strings" // MATCH /Import alias "strings" is redundant/
 
 	"crypto/md5"