usage_analyzer.go

package unusedsqlc

import (
	"go/ast"
	"go/token"
	"strings"
)

// UsageAnalyzer analyzes Go AST to find sqlc query usage.
type UsageAnalyzer struct {
	config *Config
}

// NewUsageAnalyzer creates a new UsageAnalyzer with the given configuration.
func NewUsageAnalyzer(config *Config) *UsageAnalyzer {
	if config == nil {
		config = DefaultConfig()
	}
	return &UsageAnalyzer{
		config: config,
	}
}

// FindUsedQueries analyzes AST files to find which sqlc queries are actually used.
func (a *UsageAnalyzer) FindUsedQueries(files []*ast.File, fset *token.FileSet, queries []*SQLQuery) map[string]bool {
	usedQueries := make(map[string]bool)

	queryMap := make(map[string]*SQLQuery)
	for _, query := range queries {
		queryMap[query.Name] = query
	}

	for _, file := range files {
		if a.config.IgnoreGenerated {
			pos := fset.Position(file.Pos())
			if strings.Contains(pos.Filename, ".sql.go") ||
				strings.Contains(pos.Filename, "_gen.go") ||
				strings.Contains(pos.Filename, "generated") {
				continue
			}
		}

		ast.Inspect(file, func(n ast.Node) bool {
			switch node := n.(type) {
			case *ast.CallExpr:
				a.checkCallExpr(node, queryMap, usedQueries)
			case *ast.SelectorExpr:
				if _, exists := queryMap[node.Sel.Name]; exists {
					usedQueries[node.Sel.Name] = true
				}
			}
			return true
		})
	}

	return usedQueries
}

func (a *UsageAnalyzer) checkCallExpr(call *ast.CallExpr, queryMap map[string]*SQLQuery, usedQueries map[string]bool) {
	if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
		methodName := sel.Sel.Name
		if _, exists := queryMap[methodName]; exists {
			usedQueries[methodName] = true
		}
	}

	for _, arg := range call.Args {
		switch argExpr := arg.(type) {
		case *ast.SelectorExpr:
			if _, exists := queryMap[argExpr.Sel.Name]; exists {
				usedQueries[argExpr.Sel.Name] = true
			}
		case *ast.Ident:
			if _, exists := queryMap[argExpr.Name]; exists {
				usedQueries[argExpr.Name] = true
			}
		}
	}
}