Struct RsGenerator 

pub struct RsGenerator { /* private fields */ }

Rust code generator implementing the CodeGenerator trait.

Implementations

impl RsGenerator

pub fn new() -> Self

Creates a new Rust code generator.

Trait Implementations

impl CodeGenerator for RsGenerator

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

Emit a per-module native Rust module tree (spec §20.6.1; DQ19 resolved): each module the entry program reaches through a real use is emitted to its own .rs file under src/, wired with Rust’s native module system (mod <m>; declarations + use crate::<m>::<x>; for cross-module references). This is the sole bock build output path.

Layout (cargo-idiomatic src/-rooted crate)

Codegen emits the src/-rooted source tree (in all modes); in project mode the scaffolder adds the Cargo.toml run affordance (S6a / DV18), so build/rust/ becomes a runnable Cargo crate:

• Cargo.toml — minimal manifest ([package] + a [[bin]] at src/main.rs), emitted by the scaffolder in project mode only — just enough to cargo run.
• src/main.rs — the entry module’s body, preceded by mod <seg>; declarations for every top-level namespace the tree contains.
• src/<path>.rs — one file per reached non-entry module, mirrored from its declared module-path (module core.option ⇒ src/core/option.rs).
• src/<namespace>.rs — a wiring file per intermediate namespace (src/core.rs declaring pub mod option; pub mod iter; …), since Rust requires every file be reached through a mod declaration.

§20.6.1 allows “the target ecosystem’s conventions,” so the src/-rooted mirror is the correct idiomatic layout. The crate is run via cargo run from build/rust/ (debug build — see the rust run plan in bock-build’s toolchain.rs).

Cross-module references

Each emitted file lists its cross-module dependencies as use crate::<declared::path>::<symbol>; at the top — both the explicit used symbols and the implicit §18.2-prelude names a module references but does not use (e.g. a base trait in an impl). The symbols are then referenced unqualified in the body exactly as the bundling path emitted them, so the per-item lowering is unchanged.

The concurrency runtime (used by Channel/spawn programs) is emitted once into a shared src/bock_runtime.rs; modules referencing it use crate::bock_runtime::*;. Rust uses a native fn main, so no entry invocation is appended.

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

Transpile @test functions into an inline #[cfg(test)] mod (S7).

cargo test runs the bin crate’s inline test module. Each Bock @test becomes a #[test] fn, with expect(actual).<assertion>(expected) chains lowered to assert! / assert_eq!. The module is emitted to src/bock_tests.rs and wired into src/main.rs via the returned entry_append (#[cfg(test)] mod bock_tests;). framework is ignored: cargo test is the universal Rust 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 RsGenerator

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

Formats the value using the given formatter.

impl Default for RsGenerator

fn default() -> Self

Returns the “default value” for a type.