packages.go

package gogencli

import (
	"fmt"
	"go/ast"
	"go/types"
	"path/filepath"
	"slices"

	"golang.org/x/tools/go/packages"
)

func (g *Generator) FindPackageByPath(pkgPath string) *packages.Package {
	for _, p := range g.packages {
		if p.PkgPath == pkgPath {
			return p
		}
	}
	return nil
}

func (g *Generator) loadPackages() (err error) {
	if g.addRootPattern && !slices.Contains(g.patterns, g.rootDir) {
		g.patterns = append(g.patterns, g.rootDir)
	}

	patterns := slices.Concat(g.patterns, g.typePatterns)
	if len(patterns) == 0 {
		return fmt.Errorf("at least one pattern is required")
	}

	g.packages, err = packages.Load(g.packagesConfig, patterns...)
	if err != nil {
		return fmt.Errorf("error loading packages for inspection: %w", err)
	}
	if packages.PrintErrors(g.packages) > 0 {
		return fmt.Errorf("packages contain errors")
	}

	if len(g.packages) == 0 {
		return fmt.Errorf("no packages found")
	}

	err = g.loadRootPackage()
	if err != nil {
		return err
	}

	if g.rootRequired && (g.root == nil || g.root.ASTFile == nil || g.root.Object == nil) {
		return fmt.Errorf("could not find root package and file")
	}

	return nil
}

func (g *Generator) loadRootPackage() (err error) {
	for _, pkg := range g.packages {
		if pkg.Dir == g.rootDir {
			g.rootPackage = pkg
			break
		}
	}

	if g.rootPackage == nil {
		return nil
	}

	if g.goFile == "" {
		return nil
	}

	rootFile := filepath.Join(g.rootDir, g.goFile)

	afile := g.astHelper.FindFileByFilename(g.rootPackage, rootFile)

	if afile == nil {
		return nil
	}

	g.root = &Root{
		ASTFile: afile,
	}
	if g.rootPackage.Fset != nil {
		g.root.TokenFile = g.rootPackage.Fset.File(g.root.ASTFile.Pos())
	}

	g.root.Decl = g.loadRootASTDecl()
	g.root.Object = g.loadRootObject()

	return nil
}

func (g *Generator) loadRootASTDecl() *ASTType {
	for _, decl := range g.root.ASTFile.Decls {
		switch d := decl.(type) {
		case *ast.GenDecl:
			if g.IsGoGenerateLine(d.Doc) {
				ret := &ASTType{
					Package: g.rootPackage,
					File:    g.root.ASTFile,
					Decl:    d,
				}
				if len(d.Specs) > 0 {
					ret.Spec = d.Specs[0]
					ret.Name = getSpecName(ret.Spec)
				}
				return ret
			} else {
				for _, spec := range d.Specs {
					switch s := spec.(type) {
					case *ast.ImportSpec:
						if g.IsGoGenerateLine(s.Doc) {
							return &ASTType{
								Name:    s.Name.Name,
								Package: g.rootPackage,
								File:    g.root.ASTFile,
								Decl:    d,
								Spec:    s,
							}
						}
					case *ast.TypeSpec:
						if g.IsGoGenerateLine(s.Doc) {
							return &ASTType{
								Name:    s.Name.Name,
								Package: g.rootPackage,
								File:    g.root.ASTFile,
								Decl:    d,
								Spec:    s,
							}
						}
					case *ast.ValueSpec:
						if g.IsGoGenerateLine(s.Doc) {
							return &ASTType{
								Name:    s.Names[0].Name,
								Package: g.rootPackage,
								File:    g.root.ASTFile,
								Decl:    d,
								Spec:    s,
							}
						}
					}
				}
			}
		case *ast.FuncDecl:
			if g.IsGoGenerateLine(d.Doc) {
				return &ASTType{
					Name:    d.Name.Name,
					Package: g.rootPackage,
					File:    g.root.ASTFile,
					Decl:    d,
				}
			}
		}
	}

	return nil
}

func (g *Generator) loadRootObject() types.Object {
	if g.root.Decl == nil {
		return nil
	}
	return g.RootPackage().Types.Scope().Lookup(g.root.Decl.Name)
}