Provide type checker with function for type to search for

Author: JoelSpeed

pkg/analysis/integers/analyzer.go

@@ -49,7 +49,7 @@ func run(pass *analysis.Pass) (any, error) {
 		(*ast.TypeSpec)(nil),
 	}
 
-	typeChecker := utils.NewTypeChecker(checkIntegers)
+	typeChecker := utils.NewTypeChecker(utils.IsBasicType, checkIntegers)
 
 	// Preorder visits all the nodes of the AST in depth-first order. It calls
 	// f(n) for each node n before it visits n's children.
@@ -63,7 +63,12 @@ func run(pass *analysis.Pass) (any, error) {
 }
 
 // checkIntegers looks for known type of integers that do not match the allowed `int32` or `int64` requirements.
-func checkIntegers(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string) {
+func checkIntegers(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string) {
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return
+	}
+
 	switch ident.Name {
 	case "int32", "int64":
 		// Valid cases

pkg/analysis/nobools/analyzer.go

@@ -49,7 +49,7 @@ func run(pass *analysis.Pass) (any, error) {
 		(*ast.TypeSpec)(nil),
 	}
 
-	typeChecker := utils.NewTypeChecker(checkBool)
+	typeChecker := utils.NewTypeChecker(utils.IsBasicType, checkBool)
 
 	// Preorder visits all the nodes of the AST in depth-first order. It calls
 	// f(n) for each node n before it visits n's children.
@@ -62,7 +62,12 @@ func run(pass *analysis.Pass) (any, error) {
 	return nil, nil //nolint:nilnil
 }
 
-func checkBool(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string) {
+func checkBool(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string) {
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return
+	}
+
 	if ident.Name == "bool" {
 		pass.Reportf(node.Pos(), "%s should not use a bool. Use a string type with meaningful constant values as an enum.", prefix)
 	}

pkg/analysis/nofloats/analyzer.go

@@ -49,7 +49,7 @@ func run(pass *analysis.Pass) (any, error) {
 		(*ast.TypeSpec)(nil),
 	}
 
-	typeChecker := utils.NewTypeChecker(checkFloat)
+	typeChecker := utils.NewTypeChecker(utils.IsBasicType, checkFloat)
 
 	// Preorder visits all the nodes of the AST in depth-first order. It calls
 	// f(n) for each node n before it visits n's children.
@@ -62,7 +62,12 @@ func run(pass *analysis.Pass) (any, error) {
 	return nil, nil //nolint:nilnil
 }
 
-func checkFloat(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string) {
+func checkFloat(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string) {
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return
+	}
+
 	if ident.Name == "float32" || ident.Name == "float64" {
 		pass.Reportf(node.Pos(), "%s should not use a float value because they cannot be reliably round-tripped.", prefix)
 	}

pkg/analysis/utils/type_check.go

@@ -31,14 +31,16 @@ type TypeChecker interface {
 }
 
 // NewTypeChecker returns a new TypeChecker with the provided checkFunc.
-func NewTypeChecker(checkFunc func(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string)) TypeChecker {
+func NewTypeChecker(isTypeFunc func(pass *analysis.Pass, ident ast.Expr) bool, checkFunc func(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string)) TypeChecker {
 	return &typeChecker{
-		checkFunc: checkFunc,
+		isTypeFunc: isTypeFunc,
+		checkFunc:  checkFunc,
 	}
 }
 
 type typeChecker struct {
-	checkFunc func(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string)
+	isTypeFunc func(pass *analysis.Pass, expr ast.Expr) bool
+	checkFunc  func(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string)
 }
 
 // CheckNode checks the provided node for built-in types.
@@ -84,6 +86,11 @@ func (t *typeChecker) checkTypeSpec(pass *analysis.Pass, tSpec *ast.TypeSpec, no
 }
 
 func (t *typeChecker) checkTypeExpr(pass *analysis.Pass, typeExpr ast.Expr, node ast.Node, prefix string) {
+	if t.isTypeFunc(pass, typeExpr) {
+		t.checkFunc(pass, typeExpr, node, prefix)
+		return
+	}
+
 	switch typ := typeExpr.(type) {
 	case *ast.Ident:
 		t.checkIdent(pass, typ, node, prefix)
@@ -100,12 +107,6 @@ func (t *typeChecker) checkTypeExpr(pass *analysis.Pass, typeExpr ast.Expr, node
 // checkIdent calls the checkFunc with the ident, when we have hit a built-in type.
 // If the ident is not a built in, we look at the underlying type until we hit a built-in type.
 func (t *typeChecker) checkIdent(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string) {
-	if IsBasicType(pass, ident) {
-		// We've hit a built-in type, no need to check further.
-		t.checkFunc(pass, ident, node, prefix)
-		return
-	}
-
 	tSpec, ok := LookupTypeSpec(pass, ident)
 	if !ok {
 		return

pkg/analysis/utils/type_check_test.go

@@ -53,7 +53,12 @@ func testAnalyzer() *analysis.Analyzer {
 				(*ast.TypeSpec)(nil),
 			}
 
-			typeChecker := utils.NewTypeChecker(func(pass *analysis.Pass, ident *ast.Ident, node ast.Node, prefix string) {
+			typeChecker := utils.NewTypeChecker(utils.IsBasicType, func(pass *analysis.Pass, expr ast.Expr, node ast.Node, prefix string) {
+				ident, ok := expr.(*ast.Ident)
+				if !ok {
+					return
+				}
+
 				if ident.Name == "string" {
 					pass.Reportf(node.Pos(), "%s is a string", prefix)
 				}

pkg/analysis/utils/utils.go

@@ -31,8 +31,8 @@ import (
 
 // IsBasicType checks if the type of the given identifier is a basic type.
 // Basic types are types like int, string, bool, etc.
-func IsBasicType(pass *analysis.Pass, ident *ast.Ident) bool {
-	_, ok := pass.TypesInfo.TypeOf(ident).(*types.Basic)
+func IsBasicType(pass *analysis.Pass, expr ast.Expr) bool {
+	_, ok := pass.TypesInfo.TypeOf(expr).(*types.Basic)
 	return ok
 }