Struct GoGenerator 

pub struct GoGenerator { /* private fields */ }

Go code generator implementing the CodeGenerator trait.

Implementations

impl GoGenerator

pub fn new() -> Self

Creates a new Go code generator.

Trait Implementations

impl CodeGenerator for GoGenerator

fn generate_project( &self, modules: &[(&AIRModule, &Path)], ) -> Result<GeneratedCode, CodegenError>

Emit a per-module native Go package tree (spec §20.6.1; DQ19 resolved): each module the entry program reaches through a real use is emitted to its own .go file under build/go/, all in one package main.

Package model (flat, single package main)

Go requires exactly one package per directory, and same-package symbols are visible across files without any import. So the cleanest model that is genuinely per-file and runs via go run . keeps every emitted file in build/go/ as package main: a function/record/enum declared in core.option’s file is referenced directly from main’s file, no inter-file import. The flat layout (filenames flatten the dotted module path — module core.option ⇒ core.option.go) avoids the subdirectory that would make Go treat a module as a separate package. §20.6.1 allows “the target ecosystem’s conventions,” and one package across files is Go’s. (Project mode — S6 — may refine this toward real subpackages with capitalized exports.)

ImportDecls therefore emit nothing (same package). The runtime preludes (Optional / Result / numeric / Ordering / concurrency / range) are emitted once into a shared bock_runtime.go; consuming files use the runtime symbols directly (same package). The minimal go.mod (module name + go version) run affordance is emitted by the scaffolder in project mode (S6a / DV18), not by codegen, so go run . resolves the package. Go uses a native func main, so no entry invocation is appended.

fn generate_tests( &self, modules: &[(&AIRModule, &Path)], _framework: &str, ) -> Result<TestArtifacts, CodegenError>

Transpile @test functions into a bock_test.go file (S7).

go test runs func TestXxx(t *testing.T) in package main (same package → the test can call the program’s unexported functions). Each Bock @test becomes one such function, with expect(...) assertion chains lowered to if <neg> { t.Errorf(...) }. framework is ignored: go test (stdlib testing) is the universal Go framework (§20.6.2).

fn target(&self) -> &TargetProfile

Returns the target profile for this generator.

fn generate_module( &self, module: &AIRModule, ) -> Result<GeneratedCode, CodegenError>

Generates target code from a fully-lowered AIR module.

fn needs_ai_synthesis(&self, node: &AIRNode) -> bool

Returns true when the given AIR node should go through Tier 1 AI synthesis (§17.2, Q3 amended).

fn entry_invocation(&self, main_is_async: bool) -> Option<String>

Returns the source-code snippet that invokes the user’s main function as the entry point for this target, or None if the target has a native entry-point convention (Rust fn main, Go func main) that runs without a synthetic call.

impl Debug for GoGenerator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GoGenerator

fn default() -> Self

Returns the “default value” for a type.