Struct RegistryGenerator 

pub struct RegistryGenerator {
    pub single_file: bool,
    pub use_mod_rs: bool,
    /* private fields */
}

Generator that creates source files from ASTRegistry + SymbolRegistry.

Derives file structure purely from SymbolPath hierarchy - no existing files or span information required. This enables:

• Fresh file generation from scratch
• Module addition/removal without span manipulation
• Consistent output regardless of original file layout

Output Format

The generator outputs GeneratedWorkspace containing crate-relative paths (e.g., "src/lib.rs"). It does NOT handle workspace layout concerns like where each crate lives within the workspace (e.g., "crates/core/src/lib.rs").

Generation Modes

• Single-file mode (single_file()): All symbols in one file with nested mod { } blocks
• Multi-file mode (multi_file()): Each module gets its own .rs file
• Multi-file mod.rs (multi_file_mod_rs()): Legacy mod.rs style instead of module.rs

Example

let generator = RegistryGenerator::multi_file();
let workspace = generator.generate(&ast_registry, &symbol_registry);

// For symbols: core::Config, core::models::User
// Output: {"src/lib.rs": "...", "src/models.rs": "..."}

Fields

single_file: bool

Generate single file with nested mods (true) or multi-file (false)

use_mod_rs: bool

Use mod.rs style (legacy) vs module.rs style (modern) for multi-file

Implementations

impl RegistryGenerator

pub fn single_file() -> Self

Create a new generator with single-file output.

pub fn multi_file() -> Self

Create a new generator with multi-file output (modern style).

pub fn multi_file_mod_rs() -> Self

Create a new generator with multi-file output (mod.rs style).

pub fn with_existing_files<I>(self, paths: I) -> Self

where I: IntoIterator, I::Item: Into<String>,

Provide existing crate-relative file paths as a workspace-wide fallback.

All crates see this same set when no per-crate entry is present. Preserved as the original API for backward compatibility and for callers (unit tests / single-crate workspaces) that do not need per-crate isolation. Multi-crate production code should prefer [with_existing_files_per_crate].

pub fn with_lib_crates(self, crates: HashSet<CrateName>) -> Self

Declare which crates own a src/lib.rs on disk.

When this set is non-empty, [generate_internal] will silently drop any is_main = false crate that is NOT a member — preventing the generator from synthesising a phantom src/lib.rs for binary-only crates. The defensive guard previously living in BlueprintExecutor::sync_files_and_rebuild (f42eb504) becomes redundant once this whitelist is supplied: the generator simply never produces the offending file.

Leave the set empty (the default) to retain the legacy behaviour — every crate the symbol registry knows about is emitted with a lib-style root unless its symbols carry the main:: prefix.

pub fn with_existing_files_per_crate( self, map: HashMap<CrateName, HashSet<String>>, ) -> Self

Provide per-crate existing file path sets.

Preferred API for multi-crate workspaces. Each crate sees only its own key set, preventing <crate_A>/mod.rs entries from leaking into the layout decision for <crate_B> (RL061 fix).

Crates absent from map fall back to the workspace-wide set populated by [with_existing_files].

pub fn generate( &self, ast_registry: &ASTRegistry, symbol_registry: &SymbolRegistry, ) -> Result<GeneratedWorkspace, ToSynError>

Generate source files from registries.

Handles both library symbols (crate::Foo) and binary symbols (main::crate::Foo). Binary symbols are output to src/main.rs while library symbols go to src/lib.rs.

pub fn generate_affected( &self, ast_registry: &ASTRegistry, symbol_registry: &SymbolRegistry, modified_symbols: &[SymbolId], _metadata: &CargoMetadataProvider, ) -> Result<GeneratedWorkspace, ToSynError>

Generate only files affected by modified symbols.

This method determines which files need regeneration based on the modified symbols and the generator’s file layout strategy (CrateLayout-aware).

Strategy

1. Collect affected modules from modified symbols
2. Determine file paths based on CrateLayout (bin-only/lib/mixed)
3. Generate only the affected files

Arguments

• ast_registry - The AST registry containing all symbols
• symbol_registry - The symbol registry with path information
• modified_symbols - SymbolIds that were modified during mutation
• metadata - Cargo metadata for CrateInfo lookup

Returns

A GeneratedWorkspace containing only the affected files with crate-relative paths.

Example

let modified = vec![status_id, todo_item_id];
let workspace = generator.generate_affected(
    &ast_registry,
    &symbol_registry,
    &modified,
    &metadata,
);
// workspace.crates["my_crate"].files contains only affected files

Generate only files affected by modified symbols.

Maps each modified SymbolId to its crate-relative file path, then runs the full organization phase (fast: HashMap grouping) but only serializes affected files via to_source() (expensive: prettyplease).

DESIGN INVARIANT

Full-workspace serialization is PROHIBITED. Only files containing modified symbols may be serialized. This is critical because:

1. to_source() (prettyplease) is O(file_size) per file
2. Regenerating unmodified files causes format drift (vec![] → vec!(), shorthand expansion, etc.)
3. Writing unmodified files wastes I/O and triggers re-indexing

If modified_symbols is empty, returns an empty workspace immediately.

pub fn generate_with_graph( &self, code_graph: &CodeGraphV2, ast_registry: &ASTRegistry, symbol_registry: &SymbolRegistry, ) -> Result<GeneratedWorkspace, ToSynError>

Generate source files using CodeGraphV2 for module traversal.

This version uses the Contains edges in CodeGraphV2 to traverse the module hierarchy instead of re-grouping symbols with HashMaps. This provides O(1) child lookup per symbol instead of O(N) HashMap grouping.

Arguments

• code_graph - The code graph with Contains edges representing module hierarchy
• ast_registry - The AST registry containing symbol ASTs
• symbol_registry - The symbol registry with path information

Trait Implementations

impl Clone for RegistryGenerator

fn clone(&self) -> RegistryGenerator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RegistryGenerator

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

Formats the value using the given formatter.

impl Default for RegistryGenerator

fn default() -> RegistryGenerator

Returns the “default value” for a type.

impl SourceGenerator for RegistryGenerator

fn generate( &self, ast_registry: &ASTRegistry, symbol_registry: &SymbolRegistry, ) -> Result<GeneratedWorkspace, ToSynError>

Generate source files from registries.