codegen

func ContentRevision ¶

func ContentRevision(dir string) (string, error)

ContentRevision returns a short content-addressable revision for the generated library in dir. It hashes every Go source file plus go.mod and go.sum in sorted path order, so the result is a stable fingerprint of the factory source, the inlined UB libraries, and the full pinned Go dependency set that go.sum records. The compiled binary itself is excluded; only build inputs contribute. Run it after `go mod tidy` so go.sum is present.

func EncodeNode ¶

func EncodeNode(n lang.Node) (string, error)

EncodeNode renders a parsed `lang` AST node as a Go expression that constructs an equivalent value. The expression evaluates to the matching `lang` pointer type (`*lang.File` for a File, `*lang.Field` for a Field, the matching `*lang.X` for any expression node).

Source positions are not encoded; the produced node has zero Span values. The encoder handles every plain expression node and every `TypeExpr` node; callers must not pass a node kind the parser does not produce as part of a body.

func EncodeSyntaxFactoryBody ¶ added in v0.8.0

func EncodeSyntaxFactoryBody(n syntax.FactoryBody) (string, error)

EncodeSyntaxFactoryBody renders a typed factory or composite body as a Go expression. Source positions are omitted; runtime graph extraction only needs declaration names, selectors, and expression bodies.

func EncodeSyntaxFactoryBodyWithSpans ¶ added in v0.8.0

func EncodeSyntaxFactoryBodyWithSpans(
	n syntax.FactoryBody,
	spanName SyntaxSpanNamer,
) (string, error)

EncodeSyntaxFactoryBodyWithSpans renders a body while preserving source spans.

func Generate ¶

func Generate(in Input) ([]byte, error)

Generate produces the formatted Go source for the factory binary's main.go. The result is the bytes a caller writes to disk and feeds through `go build`.

func GenerateUBLibrary ¶

func GenerateUBLibrary(
	alias string,
	syntaxBodies map[string]map[string]syntax.FactoryBody,
	imports map[string]map[string]map[string]string,
	goSpecs map[string]GoLibrarySpecs,
) ([]byte, error)

GenerateUBLibrary produces the Go source for a UB library's generated package. The package's name is alias; it exports a `Library()` function returning a `*runtime.Library` whose composites are split into one map per kind (ResourceComposites, DataComposites, ActionComposites). syntaxBodies are keyed by kind and then composite name; each generated registration uses SyntaxBody.

imports maps each composite's kind and name to its resolved import table: the composite's body's own imports block, with each declared alias mapped to the Go import path of the package that supplies it. The generated source emits one Go-level import per unique path and renders a per-composite `Libraries` map binding each composite-local alias to the corresponding package's `Library()`. Pass nil or an empty map when a composite has no imports.

goSpecs maps a Go import path to the specs its types declare. A bound library with specs is constructed once in `Library()`, has its Constraints and Defaults attached, and every binding of that path shares the instance, so a composite-internal node resolves the same spec data a root import of the library would.

func GenerateUBLibraryPackage ¶ added in v0.8.0

func GenerateUBLibraryPackage(
	packageID string,
	libraryName string,
	syntaxBodies map[string]map[string]syntax.FactoryBody,
	imports map[string]map[string]map[string]string,
	goSpecs map[string]GoLibrarySpecs,
	sourceFiles map[string]syntax.SourceFileSpec,
) ([]byte, error)

GenerateUBLibraryPackage produces a UB library package whose Go package identifier can differ from the runtime library name.

func WriteSource ¶

func WriteSource(
	dir string,
	in Input,
	goVersion, unobinVersion string,
	importVersions map[string]string,
	replaces Replaces,
) error

WriteSource lays out a generated binary's source tree in dir, ready for `go build` to consume. It writes:

<dir>/main.go    // From Generate.
<dir>/go.mod     // With the right require statements.

goVersion is the Go toolchain version to declare. unobinVersion is the version of `github.com/cloudboss/unobin` the generated binary depends on. importVersions maps each library's Go import path to the version constraint to require for callers that have not set Input.GoModules. replaces maps a module path to a local path to substitute via `replace`.