Updated lint failures

Author: krishagarwal278

go.mod

@@ -5,6 +5,7 @@ go 1.24.0
 require (
 	github.com/golangci/golangci-lint/v2 v2.5.0
 	github.com/golangci/plugin-module-register v0.1.2
+	github.com/google/go-cmp v0.7.0
 	github.com/onsi/ginkgo/v2 v2.23.4
 	github.com/onsi/gomega v1.38.0
 	golang.org/x/tools v0.37.0
@@ -100,7 +101,6 @@ require (
 	github.com/golangci/revgrep v0.8.0 // indirect
 	github.com/golangci/swaggoswag v0.0.0-20250504205917-77f2aca3143e // indirect
 	github.com/golangci/unconvert v0.0.0-20250410112200-a129a6e6413e // indirect
-	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/google/pprof v0.0.0-20250607225305-033d6d78b36a // indirect
 	github.com/gordonklaus/ineffassign v0.2.0 // indirect
 	github.com/gostaticanalysis/analysisutil v0.7.1 // indirect

pkg/analysis/enums/analyzer.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	"slices"
 	"strings"
 	"unicode"
 
@@ -41,6 +42,7 @@ type analyzer struct {
 
 func newAnalyzer(cfg *Config) *analysis.Analyzer {
 	a := &analyzer{config: cfg}
+
 	return &analysis.Analyzer{
 		Name:     name,
 		Doc:      "Enforces that enumerated fields use type aliases with +enum marker and have PascalCase values",
@@ -56,15 +58,16 @@ func (a *analyzer) run(pass *analysis.Pass) (any, error) {
 	}
 
 	// Check struct fields for proper enum usage
-	inspect.InspectFields(func(field *ast.Field, _ extractjsontags.FieldTagInfo, markersAccess markershelper.Markers) {
+	inspect.InspectFields(func(field *ast.Field, _ extractjsontags.FieldTagInfo, markersAccess markershelper.Markers, _ string) {
 		a.checkField(pass, field, markersAccess)
 	})
 
 	// Check type declarations for +enum markers
 	inspect.InspectTypeSpec(func(typeSpec *ast.TypeSpec, markersAccess markershelper.Markers) {
 		a.checkTypeSpec(pass, typeSpec, markersAccess)
 	})
-	a.checkConstValues(pass, inspect)
+	a.checkConstValues(pass)
+
 	return nil, nil //nolint:nilnil
 }
 
@@ -75,22 +78,29 @@ func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, markersAcce
 	}
 	// Get the underlying type, unwrapping pointers and arrays
 	fieldType, isArray := unwrapTypeWithArrayTracking(field.Type)
+
 	ident, ok := fieldType.(*ast.Ident)
+
 	if !ok {
 		return
 	}
+
 	prefix := buildFieldPrefix(fieldName, isArray)
+
 	if ident.Name == "string" && utils.IsBasicType(pass, ident) {
 		a.checkPlainStringField(pass, field, markersAccess, prefix)
+
 		return
 	}
+
 	a.checkTypeAliasField(pass, field, ident, markersAccess, prefix)
 }
 
 func buildFieldPrefix(fieldName string, isArray bool) string {
 	if isArray {
 		return fmt.Sprintf("field %s array element", fieldName)
 	}
+
 	return fmt.Sprintf("field %s", fieldName)
 }
 
@@ -106,10 +116,13 @@ func (a *analyzer) checkTypeAliasField(pass *analysis.Pass, field *ast.Field, id
 	if utils.IsBasicType(pass, ident) {
 		return
 	}
+
 	typeSpec, ok := utils.LookupTypeSpec(pass, ident)
+
 	if !ok || !isStringTypeAlias(pass, typeSpec) {
 		return
 	}
+
 	if !hasEnumMarker(markersAccess.TypeMarkers(typeSpec)) {
 		pass.Reportf(field.Pos(),
 			"%s uses type %s which appears to be an enum but is missing +enum marker (kubebuilder:validation:Enum)",
@@ -121,24 +134,28 @@ func (a *analyzer) checkTypeSpec(pass *analysis.Pass, typeSpec *ast.TypeSpec, ma
 	if typeSpec.Name == nil {
 		return
 	}
+
 	typeMarkers := markersAccess.TypeMarkers(typeSpec)
+
 	if !hasEnumMarker(typeMarkers) {
 		return
 	}
+
 	if !isStringTypeAlias(pass, typeSpec) {
 		pass.Reportf(typeSpec.Pos(),
 			"type %s has +enum marker but underlying type is not string",
 			typeSpec.Name.Name)
 	}
 }
 
-func (a *analyzer) checkConstValues(pass *analysis.Pass, inspect inspector.Inspector) {
+func (a *analyzer) checkConstValues(pass *analysis.Pass) {
 	for _, file := range pass.Files {
 		for _, decl := range file.Decls {
 			genDecl, ok := decl.(*ast.GenDecl)
 			if !ok || genDecl.Tok.String() != "const" {
 				continue
 			}
+
 			for _, spec := range genDecl.Specs {
 				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
 					a.checkConstSpec(pass, valueSpec)
@@ -158,16 +175,20 @@ func (a *analyzer) validateEnumConstant(pass *analysis.Pass, name *ast.Ident, va
 	if name == nil || index >= len(valueSpec.Values) {
 		return
 	}
+
 	typeSpec := a.getEnumTypeSpec(pass, name)
 	if typeSpec == nil {
 		return
 	}
+
 	// Extract and validate the enum value
 	basicLit, ok := valueSpec.Values[index].(*ast.BasicLit)
 	if !ok {
 		return
 	}
+
 	strValue := strings.Trim(basicLit.Value, `"`)
+
 	if !a.isInAllowlist(strValue) && !isPascalCase(strValue) {
 		pass.Reportf(basicLit.Pos(),
 			"enum value %q should be PascalCase (e.g., \"PhasePending\", \"StateRunning\")",
@@ -180,18 +201,22 @@ func (a *analyzer) getEnumTypeSpec(pass *analysis.Pass, name *ast.Ident) *ast.Ty
 	if !ok {
 		return nil
 	}
+
 	namedType, ok := constObj.Type().(*types.Named)
 	if !ok || namedType.Obj().Pkg() == nil || namedType.Obj().Pkg() != pass.Pkg {
 		return nil
 	}
+
 	typeSpec := findTypeSpecByName(pass, namedType.Obj().Name())
+
 	if typeSpec == nil || !hasEnumMarkerOnTypeSpec(pass, typeSpec) {
 		return nil
 	}
+
 	return typeSpec
 }
 
-// unwrapType removes pointer and array wrappers to get the underlying type
+// unwrapType removes pointer and array wrappers to get the underlying type.
 func unwrapType(expr ast.Expr) ast.Expr {
 	switch t := expr.(type) {
 	case *ast.StarExpr:
@@ -207,6 +232,7 @@ func unwrapType(expr ast.Expr) ast.Expr {
 // and tracks whether an array was encountered during unwrapping.
 func unwrapTypeWithArrayTracking(expr ast.Expr) (ast.Expr, bool) {
 	isArray := false
+
 	for {
 		switch t := expr.(type) {
 		case *ast.StarExpr:
@@ -222,10 +248,13 @@ func unwrapTypeWithArrayTracking(expr ast.Expr) (ast.Expr, bool) {
 
 func isStringTypeAlias(pass *analysis.Pass, typeSpec *ast.TypeSpec) bool {
 	underlyingType := unwrapType(typeSpec.Type)
+
 	ident, ok := underlyingType.(*ast.Ident)
+
 	if !ok {
 		return false
 	}
+
 	return ident.Name == "string" && utils.IsBasicType(pass, ident)
 }
 
@@ -239,6 +268,7 @@ func hasEnumMarkerOnTypeSpec(pass *analysis.Pass, typeSpec *ast.TypeSpec) bool {
 			return hasEnumMarkerInDoc(genDecl.Doc)
 		}
 	}
+
 	return false
 }
 
@@ -248,39 +278,39 @@ func findGenDeclForSpec(file *ast.File, typeSpec *ast.TypeSpec) *ast.GenDecl {
 		if !ok {
 			continue
 		}
+
 		for _, spec := range genDecl.Specs {
 			if spec == typeSpec {
 				return genDecl
 			}
 		}
 	}
+
 	return nil
 }
 
 func hasEnumMarkerInDoc(doc *ast.CommentGroup) bool {
 	if doc == nil {
 		return false
 	}
+
 	for _, comment := range doc.List {
 		text := comment.Text
 		if strings.Contains(text, markers.KubebuilderEnumMarker) || strings.Contains(text, markers.K8sEnumMarker) {
 			return true
 		}
 	}
+
 	return false
 }
 
-// isInAllowlist checks if a value is in the configured allowlist
+// isInAllowlist checks if a value is in the configured allowlist.
 func (a *analyzer) isInAllowlist(value string) bool {
 	if a.config == nil {
 		return false
 	}
-	for _, allowed := range a.config.Allowlist {
-		if value == allowed {
-			return true
-		}
-	}
-	return false
+
+	return slices.Contains(a.config.Allowlist, value)
 }
 
 func findTypeSpecByName(pass *analysis.Pass, typeName string) *ast.TypeSpec {
@@ -290,38 +320,47 @@ func findTypeSpecByName(pass *analysis.Pass, typeName string) *ast.TypeSpec {
 			if !ok {
 				continue
 			}
+
 			for _, spec := range genDecl.Specs {
 				typeSpec, ok := spec.(*ast.TypeSpec)
 				if !ok {
 					continue
 				}
+
 				if typeSpec.Name != nil && typeSpec.Name.Name == typeName {
 					return typeSpec
 				}
 			}
 		}
 	}
+
 	return nil
 }
 
 func isPascalCase(s string) bool {
 	if len(s) == 0 {
 		return false
 	}
+
 	if !unicode.IsUpper(rune(s[0])) {
 		return false
 	}
+
 	hasLower := false
+
 	for _, r := range s {
 		if r == '_' || r == '-' {
 			return false
 		}
+
 		if !unicode.IsLetter(r) && !unicode.IsDigit(r) {
 			return false
 		}
+
 		if unicode.IsLower(r) {
 			hasLower = true
 		}
 	}
+
 	return len(s) == 1 || hasLower
 }

pkg/analysis/enums/analyzer_test.go

@@ -28,6 +28,7 @@ func TestAnalyzer(t *testing.T) {
 	// Test without allowlist
 	config := &enums.Config{}
 	analyzer, err := enums.Initializer().Init(config)
+
 	if err != nil {
 		t.Fatalf("initializing enums linter: %v", err)
 	}

pkg/analysis/enums/initializer.go

@@ -43,6 +43,7 @@ func initAnalyzer(cfg *Config) (*analysis.Analyzer, error) {
 	if cfg == nil {
 		cfg = &Config{}
 	}
+
 	return newAnalyzer(cfg), nil
 }