go-enum-linter.go

package analyzer

import (
	"fmt"
	"go/ast"
	"go/types"
	"golang.org/x/tools/go/analysis"
	"strings"
)

var GoEnumLintAnalyzer = &analysis.Analyzer{
	Name: "GoEnumLinter",
	Doc:  "Analyze enums and their usage",
	Run:  analyzeEnum,
}

const enumFileSuffix = "enum.go"

type EnumData struct {
	PackageName string
	Types       []string            // Type of enum
	Values      map[string][]string // Values of the enum type
}

func analyzeEnum(pass *analysis.Pass) (interface{}, error) {
	enumData := extractEnumDef(pass)
	for typeName, values := range enumData {
		fmt.Printf("%s: %v\n", typeName, values)
	}
	detectInvalidEnumUsage(pass, enumData)
	return nil, nil
}

func detectInvalidEnumUsage(pass *analysis.Pass, enumData map[string][]string) {
	for _, file := range pass.Files {
		fileName := pass.Fset.Position(file.Package).Filename
		// ignore .enum.go
		if strings.HasSuffix(fileName, enumFileSuffix) {
			continue
		}

		// Inspect AST recursively
		ast.Inspect(file, analyze(pass, enumData))
	}
}

func analyze(pass *analysis.Pass, enumData map[string][]string) func(node ast.Node) bool {
	return func(node ast.Node) bool {
		// Find Assign Statement
		if assign, ok := node.(*ast.AssignStmt); ok {
			fmt.Println(assign)
		}

		// Struct Literals
		if compLit, ok := node.(*ast.CompositeLit); ok {
			fmt.Println(compLit)
			if typ, ok := pass.TypesInfo.TypeOf(compLit).(*types.Named); ok {
				fmt.Println(typ)
			}
		}

		// Value Declarations
		if valueSpec, ok := node.(*ast.ValueSpec); ok {
			for i, name := range valueSpec.Names {
				if i < len(valueSpec.Values) {
					checkInvalidAssignment(pass, name, valueSpec.Values[i], enumData)
				} else {
					checkUninitializedDeclaration(pass, name, enumData)
				}
			}
		}

		// assignStatement
		if assignStmt, ok := node.(*ast.AssignStmt); ok {
			for i, lhs := range assignStmt.Lhs {
				if i < len(assignStmt.Rhs) {
					if ident, ok := lhs.(*ast.Ident); ok {
						checkInvalidAssignment(pass, ident, assignStmt.Rhs[i], enumData)
					}
				}
			}
		}

		// search recursively
		return true
	}
}

func checkUninitializedDeclaration(pass *analysis.Pass, ident *ast.Ident, enumData map[string][]string) {
	// 型情報を取得
	obj := pass.TypesInfo.Defs[ident]
	if obj == nil {
		return
	}
	typeName := obj.Type().String()

	// enumData に登録されている型で、初期値が設定されていない場合
	if _, exists := enumData[typeName]; exists {
		pass.Reportf(ident.Pos(), "Invalid declaration: %s must be initialized with a valid enum value", typeName)
	}
}
func checkInvalidAssignment(pass *analysis.Pass, lhs *ast.Ident, rhs ast.Expr, enumData map[string][]string) {
	// 左辺（代入先）の型を確認
	lhsObj := pass.TypesInfo.Defs[lhs]
	if lhsObj == nil {
		lhsObj = pass.TypesInfo.Uses[lhs] // Usesも考慮
	}
	if lhsObj == nil {
		return
	}
	lhsType := lhsObj.Type().String()

	// enumData に登録されている型でなければ無視
	values, exists := enumData[lhsType]
	if !exists {
		return
	}

	// 右辺（代入値）の検証
	switch rhsExpr := rhs.(type) {
	case *ast.Ident:
		// 列挙値として正しいかチェック
		rhsObj := pass.TypesInfo.Uses[rhsExpr]
		if rhsObj != nil && contains(values, rhsExpr.Name) {
			return // 正常な代入
		}
		pass.Reportf(rhs.Pos(), "Invalid assignment to %s: %s is not a valid enum value", lhsType, rhsExpr.Name)
	case *ast.BasicLit:
		// 基本リテラル（例: 数値）での代入は禁止
		pass.Reportf(rhs.Pos(), "Invalid literal assignment to %s: %s", lhsType, rhsExpr.Value)
	case *ast.CompositeLit:
		// 構造体リテラルの場合
		pass.Reportf(rhs.Pos(), "Invalid composite literal assignment to %s", lhsType)
	default:
		// その他のケースも禁止
		pass.Reportf(rhs.Pos(), "Invalid assignment to %s: unsupported value type", lhsType)
	}
}

func contains(list []string, item string) bool {
	for _, v := range list {
		if v == item {
			return true
		}
	}
	return false
}
func extractEnumDef(pass *analysis.Pass) map[string][]string {
	enumData := make(map[string][]string) // Name of type -> List of values

	for _, file := range pass.Files {
		fileName := pass.Fset.Position(file.Package).Filename
		if !strings.HasSuffix(fileName, enumFileSuffix) {
			continue
		}
		extractEnumValueFromFile(pass, file, enumData)
	}
	return enumData
}

func extractEnumValueFromFile(pass *analysis.Pass, file *ast.File, enumData map[string][]string) {
	for _, decl := range file.Decls {
		genDecl, ok := decl.(*ast.GenDecl)
		if !ok {
			continue
		}
		extractEnumValueFromDeclaration(pass, genDecl, enumData)
	}
}

func extractEnumValueFromDeclaration(pass *analysis.Pass, genDecl *ast.GenDecl, enumData map[string][]string) {
	for _, spec := range genDecl.Specs {
		valueSpec, ok := spec.(*ast.ValueSpec)
		if !ok {
			continue
		}
		extractEnumValueFromValueSpec(pass, valueSpec, enumData)
	}
}

func extractEnumValueFromValueSpec(pass *analysis.Pass, valueSpec *ast.ValueSpec, enumData map[string][]string) {
	for _, name := range valueSpec.Names {
		extractValueDef(pass, name, enumData)
	}
}

func extractValueDef(pass *analysis.Pass, name *ast.Ident, enumData map[string][]string) {
	obj := pass.TypesInfo.Defs[name]
	if obj != nil {
		typeName := obj.Type().String()
		enumData[typeName] = append(enumData[typeName], name.Name)
	}
}