Adds support for new type alias any in the rule redefines-built-in (#659)

* adds support for any type alias

* adds more representative tests

Author: chavacava

rule/redefines-builtin-id.go

@@ -8,72 +8,73 @@ import (
 	"github.com/mgechev/revive/lint"
 )
 
+var builtInConstAndVars = map[string]bool{
+	"true":  true,
+	"false": true,
+	"iota":  true,
+	"nil":   true,
+}
+
+var builtFunctions = map[string]bool{
+	"append":  true,
+	"cap":     true,
+	"close":   true,
+	"complex": true,
+	"copy":    true,
+	"delete":  true,
+	"imag":    true,
+	"len":     true,
+	"make":    true,
+	"new":     true,
+	"panic":   true,
+	"print":   true,
+	"println": true,
+	"real":    true,
+	"recover": true,
+}
+
+var builtInTypes = map[string]bool{
+	"ComplexType": true,
+	"FloatType":   true,
+	"IntegerType": true,
+	"Type":        true,
+	"Type1":       true,
+	"bool":        true,
+	"byte":        true,
+	"complex128":  true,
+	"complex64":   true,
+	"error":       true,
+	"float32":     true,
+	"float64":     true,
+	"int":         true,
+	"int16":       true,
+	"int32":       true,
+	"int64":       true,
+	"int8":        true,
+	"rune":        true,
+	"string":      true,
+	"uint":        true,
+	"uint16":      true,
+	"uint32":      true,
+	"uint64":      true,
+	"uint8":       true,
+	"uintptr":     true,
+	"any":         true,
+}
+
 // RedefinesBuiltinIDRule warns when a builtin identifier is shadowed.
 type RedefinesBuiltinIDRule struct{}
 
 // Apply applies the rule to given file.
 func (r *RedefinesBuiltinIDRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
 	var failures []lint.Failure
 
-	builtInConstAndVars := map[string]bool{
-		"true":  true,
-		"false": true,
-		"iota":  true,
-		"nil":   true,
-	}
-
-	builtFunctions := map[string]bool{
-		"append":  true,
-		"cap":     true,
-		"close":   true,
-		"complex": true,
-		"copy":    true,
-		"delete":  true,
-		"imag":    true,
-		"len":     true,
-		"make":    true,
-		"new":     true,
-		"panic":   true,
-		"print":   true,
-		"println": true,
-		"real":    true,
-		"recover": true,
-	}
-
-	builtInTypes := map[string]bool{
-		"ComplexType": true,
-		"FloatType":   true,
-		"IntegerType": true,
-		"Type":        true,
-		"Type1":       true,
-		"bool":        true,
-		"byte":        true,
-		"complex128":  true,
-		"complex64":   true,
-		"error":       true,
-		"float32":     true,
-		"float64":     true,
-		"int":         true,
-		"int16":       true,
-		"int32":       true,
-		"int64":       true,
-		"int8":        true,
-		"rune":        true,
-		"string":      true,
-		"uint":        true,
-		"uint16":      true,
-		"uint32":      true,
-		"uint64":      true,
-		"uint8":       true,
-		"uintptr":     true,
-	}
-
 	onFailure := func(failure lint.Failure) {
 		failures = append(failures, failure)
 	}
 
 	astFile := file.AST
-	w := &lintRedefinesBuiltinID{builtInConstAndVars, builtFunctions, builtInTypes, onFailure}
+	w := &lintRedefinesBuiltinID{onFailure}
 	ast.Walk(w, astFile)
 
 	return failures
@@ -85,34 +86,46 @@ func (r *RedefinesBuiltinIDRule) Name() string {
 }
 
 type lintRedefinesBuiltinID struct {
-	constsAndVars map[string]bool
-	funcs         map[string]bool
-	types         map[string]bool
-	onFailure     func(lint.Failure)
+	onFailure func(lint.Failure)
 }
 
 func (w *lintRedefinesBuiltinID) Visit(node ast.Node) ast.Visitor {
 	switch n := node.(type) {
 	case *ast.GenDecl:
-		if n.Tok != token.TYPE {
-			return nil // skip if not type declaration
-		}
-		typeSpec, ok := n.Specs[0].(*ast.TypeSpec)
-		if !ok {
-			return nil
-		}
-		id := typeSpec.Name.Name
-		if w.types[id] {
-			w.addFailure(n, fmt.Sprintf("redefinition of the built-in type %s", id))
+		switch n.Tok {
+		case token.TYPE:
+			typeSpec, ok := n.Specs[0].(*ast.TypeSpec)
+			if !ok {
+				return nil
+			}
+			id := typeSpec.Name.Name
+			if ok, bt := w.isBuiltIn(id); ok {
+				w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, id))
+			}
+		case token.VAR, token.CONST:
+			for _, vs := range n.Specs {
+				valSpec, ok := vs.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				for _, name := range valSpec.Names {
+					if ok, bt := w.isBuiltIn(name.Name); ok {
+						w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, name))
+					}
+				}
+			}
+		default:
+			return nil // skip if not type/var/const declaration
 		}
+
 	case *ast.FuncDecl:
 		if n.Recv != nil {
 			return w // skip methods
 		}
 
 		id := n.Name.Name
-		if w.funcs[id] {
-			w.addFailure(n, fmt.Sprintf("redefinition of the built-in function %s", id))
+		if ok, bt := w.isBuiltIn(id); ok {
+			w.addFailure(n, fmt.Sprintf("redefinition of the built-in %s %s", bt, id))
 		}
 	case *ast.AssignStmt:
 		for _, e := range n.Lhs {
@@ -121,13 +134,20 @@ func (w *lintRedefinesBuiltinID) Visit(node ast.Node) ast.Visitor {
 				continue
 			}
 
-			if w.constsAndVars[id.Name] {
+			if ok, bt := w.isBuiltIn(id.Name); ok {
 				var msg string
-				if n.Tok == token.DEFINE {
-					msg = fmt.Sprintf("assignment creates a shadow of built-in identifier %s", id.Name)
-				} else {
-					msg = fmt.Sprintf("assignment modifies built-in identifier %s", id.Name)
+				println(bt, id.Name)
+				switch bt {
+				case "constant or variable":
+					if n.Tok == token.DEFINE {
+						msg = fmt.Sprintf("assignment creates a shadow of built-in identifier %s", id.Name)
+					} else {
+						msg = fmt.Sprintf("assignment modifies built-in identifier %s", id.Name)
+					}
+				default:
+					msg = fmt.Sprintf("redefinition of the built-in %s %s", bt, id)
 				}
+
 				w.addFailure(n, msg)
 			}
 		}
@@ -144,3 +164,19 @@ func (w lintRedefinesBuiltinID) addFailure(node ast.Node, msg string) {
 		Failure:    msg,
 	})
 }
+
+func (w lintRedefinesBuiltinID) isBuiltIn(id string) (r bool, builtInKind string) {
+	if builtFunctions[id] {
+		return true, "function"
+	}
+
+	if builtInConstAndVars[id] {
+		return true, "constant or variable"
+	}
+
+	if builtInTypes[id] {
+		return true, "type"
+	}
+
+	return false, ""
+}

testdata/redefines-builtin-id.go

@@ -19,3 +19,13 @@ func delete(set []int64, i int) (y []int64) { // MATCH /redefinition of the buil
 	}
 	return
 }
+
+type any int // MATCH /redefinition of the built-in type any/
+
+func any() {} // MATCH /redefinition of the built-in type any/
+
+var any int // MATCH /redefinition of the built-in type any/
+
+const any = 1 // MATCH /redefinition of the built-in type any/
+
+var i, copy int // MATCH /redefinition of the built-in function copy/