gtigen

type Config struct {

	// the source directory to run gtigen on (can be set to multiple through paths like ./...)
	Dir string `def:"." posarg:"0" required:"-"`

	// the output file location relative to the package on which gtigen is being called
	Output string `def:"gtigen.go"`

	// whether to add types to gtigen by default
	AddTypes bool

	// whether to add methods to gtigen by default
	AddMethods bool

	// whether to add functions to gtigen by default
	AddFuncs bool

	// An ordered map of configs keyed by fully-qualified interface type names; if a type implements the interface, the config will be applied to it.
	// The configs are applied in sequential ascending order, which means that
	// the last config overrides the other ones, so the most specific
	// interfaces should typically be put last.
	// Note: the package gtigen is run on must explicitly reference this interface at some point for this to work; adding a simple
	// `var _ MyInterface = (*MyType)(nil)` statement to check for interface implementation is an easy way to accomplish that.
	// Note: gtigen will still succeed if it can not find one of the interfaces specified here in order to allow it to work generically across multiple directories; you can use the -v flag to get log warnings about this if you suspect that it is not finding interfaces when it should.
	InterfaceConfigs *ordmap.Map[string, *Config]

	// whether to generate an instance of the type(s)
	Instance bool

	// whether to generate a global type variable of the form 'TypeNameType'
	TypeVar bool

	// Whether to generate chaining `Set*` methods for each field of each type (eg: "SetText" for field "Text").
	// If this is set to true, then you can add `set:"-"` struct tags to individual fields
	// to prevent Set methods being generated for them.
	Setters bool

	// a slice of templates to execute on each type being added; the template data is of the type gtigen.Type
	Templates []*template.Template
}

type Generator struct {
	Config     *Config                               // The configuration information
	Buf        bytes.Buffer                          // The accumulated output.
	Pkgs       []*packages.Package                   // The packages we are scanning.
	Pkg        *packages.Package                     // The packages we are currently on.
	File       *ast.File                             // The file we are currently on.
	Cmap       ast.CommentMap                        // The comment map for the file we are currently on.
	Types      []*Type                               // The types
	Methods    *ordmap.Map[string, []*gti.Method]    // The methods, keyed by the the full package name of the type of the receiver
	Funcs      *ordmap.Map[string, *gti.Func]        // The functions
	Interfaces *ordmap.Map[string, *types.Interface] // The cached interfaces, created from [Config.InterfaceConfigs]
}

type Type struct {
	Name           string         // The name of the type in its package (eg: MyType)
	FullName       string         // The fully package-path-qualified name of the type (eg: goki.dev/gi/v2.Button)
	ShortName      string         // The short, package-qualified name of the type (eg: gi.Button)
	IDName         string         // The short, package-unqualified, kebab-case name of the type, suitable for use in an ID (eg: button)
	Type           *ast.TypeSpec  // The standard AST type value
	Doc            string         // The documentation for the type
	Pkg            string         // The name of the package the type is in
	Directives     gti.Directives // The directives for the type; guaranteed to be non-nil
	Fields         *gti.Fields    // The fields of the struct type; nil if not a struct
	Embeds         *gti.Fields    // The embeds of the struct type; nil if not a struct
	EmbeddedFields *gti.Fields    // The fields contained within the embeds of the struct type; nil if not a struct, and used for generating setters only
	Methods        *gti.Methods   // The methods of the type; guaranteed to be non-nil
	Config         *Config        // Configuration information set in the comment directive for the type; is initialized to generator config info first
}