@typra/emitter 0.2.0

package/dist/src/languages/rust/driver.js

@@ -0,0 +1,624 @@
+import { resolvePath } from "@typespec/compiler";
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { enumerateTypes, } from "../../ir/ast.js";
+import { filterNodes } from "../../emitter.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { RustExprVisitor } from "./visitor.js";
+import { buildBaseTestContext, rustTestOptions } from "../../testing/test-context.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+import { lowerFile, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitRustFile as emitRustFileDecl } from "./emitter.js";
+import { emitGeneratedFile } from "../../cleanup/generated-file.js";
+/**
+ * Type mapping from TypeSpec scalar types to Rust types.
+ * Retained for use by the test template context.
+ */
+export const rustTypeMapper = {
+    "string": "String",
+    "number": "f64",
+    "array": "Vec<serde_json::Value>",
+    "object": "serde_json::Value",
+    "boolean": "bool",
+    "int64": "i64",
+    "int32": "i32",
+    "float64": "f64",
+    "float32": "f32",
+    "integer": "i64",
+    "float": "f64",
+    "numeric": "f64",
+    "any": "serde_json::Value",
+    "dictionary": "serde_json::Value",
+};
+const RUST_KEYWORDS = new Set([
+    "as", "break", "const", "continue", "crate", "else", "enum", "extern",
+    "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod",
+    "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct",
+    "super", "trait", "true", "type", "unsafe", "use", "where", "while",
+    "async", "await", "dyn",
+]);
+function rustFieldName(name) {
+    const snake = toSnakeCase(name);
+    return RUST_KEYWORDS.has(snake) ? `r#${snake}` : snake;
+}
+/**
+ * Stale-file deletion is intentionally disabled until manifest cleanup is enabled.
+ */
+function cleanupFlatTypeFiles(relDir, isTypeFile) {
+    void relDir;
+    void isTypeFile;
+    return;
+}
+/**
+ * Main entry point for Rust code generation.
+ */
+export const generateRust = async (context, node, emitTarget, options) => {
+    const allTypes = Array.from(enumerateTypes(node));
+    const nodes = filterNodes(allTypes, options);
+    // Stale flat-file cleanup is disabled in this slice.
+    cleanupFlatTypeFiles(emitTarget["output-dir"], name => name.endsWith(".rs") && name !== "context.rs" && name !== "mod.rs" && name !== "lib.rs");
+    cleanupFlatTypeFiles(emitTarget["test-dir"], name => name.endsWith(".rs") && name !== "mod.rs" && name !== "main.rs");
+    // Build the expression IR infrastructure for this compilation
+    const registry = TypeRegistry.fromTypeGraph(allTypes);
+    const visitor = new RustExprVisitor(registry);
+    // Collect all polymorphic type names across all nodes
+    const polymorphicTypeNames = new Set();
+    for (const n of nodes) {
+        for (const name of collectPolymorphicTypeNames(n, registry)) {
+            polymorphicTypeNames.add(name);
+        }
+    }
+    // Build a map from polymorphic child type names to their parent type names.
+    // In Rust, child types become enum variants, not standalone structs.
+    // When importing a child type, we need to import ParentKind instead.
+    const childToParent = new Map();
+    for (const n of nodes) {
+        if (n.discriminator && n.childTypes.length > 0) {
+            for (const child of n.childTypes) {
+                childToParent.set(child.typeName.name, n.typeName.name);
+            }
+        }
+    }
+    // Render context.rs
+    const contextContent = emitRustContext("Prompty Context");
+    await emitRustFile(context, 'context.rs', contextContent, emitTarget["output-dir"]);
+    // Group root nodes by semantic group folder
+    const groupMap = new Map();
+    for (const n of nodes) {
+        if (!n.base) {
+            const g = n.group || "";
+            if (!groupMap.has(g))
+                groupMap.set(g, []);
+            groupMap.get(g).push(n);
+        }
+    }
+    // Render each base type and its children as a single file, into group subfolder
+    const groupModuleNames = new Map(); // group → module names
+    const testGroupModuleNames = new Map(); // group → test module names
+    for (const n of nodes) {
+        if (!n.base) {
+            const group = n.group || "";
+            const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+            const fileContent = emitRustFileDecl(fileDecl, visitor, polymorphicTypeNames, childToParent);
+            const fileName = toSnakeCase(n.typeName.name) + '.rs';
+            const outDir = group ? `${emitTarget["output-dir"]}/${group}` : emitTarget["output-dir"];
+            await emitRustFile(context, fileName, fileContent, outDir);
+            if (!groupModuleNames.has(group))
+                groupModuleNames.set(group, []);
+            groupModuleNames.get(group).push(toSnakeCase(n.typeName.name));
+        }
+        // Render test file — skip children of polymorphic hierarchies (they're enum variants now) and protocols
+        if (emitTarget["test-dir"] && !childToParent.has(n.typeName.name) && !n.isProtocol) {
+            const importPath = emitTarget["import-path"] || "crate";
+            const testContext = buildTestContext(n);
+            const isPolymorphicBase = !!(n.discriminator && n.childTypes.length > 0);
+            const testContent = emitRustTest({
+                ...testContext,
+                importPath,
+                isPolymorphicBase,
+            });
+            const testFileName = toSnakeCase(n.typeName.name) + '_test.rs';
+            const testGroup = n.group || "";
+            const testDir = testGroup ? `${emitTarget["test-dir"]}/${testGroup}` : emitTarget["test-dir"];
+            await emitRustFile(context, testFileName, testContent, testDir);
+            if (!testGroupModuleNames.has(testGroup))
+                testGroupModuleNames.set(testGroup, []);
+            testGroupModuleNames.get(testGroup).push(toSnakeCase(n.typeName.name) + '_test');
+        }
+    }
+    // Render per-group mod.rs files (source)
+    for (const [group, modules] of groupModuleNames) {
+        if (!group)
+            continue; // Root-level types handled in root mod.rs
+        const groupModContent = emitRustGroupMod(modules);
+        await emitRustFile(context, 'mod.rs', groupModContent, `${emitTarget["output-dir"]}/${group}`);
+    }
+    // Render test group mod.rs files and test main.rs
+    if (emitTarget["test-dir"]) {
+        // Emit per-group mod.rs (test)
+        const testGroups = [];
+        for (const [group, testMods] of testGroupModuleNames) {
+            if (group) {
+                const groupModContent = '// Code generated by Typra emitter; DO NOT EDIT.\n\n#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]\n\n'
+                    + testMods.map(m => `mod ${m};`).join('\n') + '\n';
+                await emitRustFile(context, 'mod.rs', groupModContent, `${emitTarget["test-dir"]}/${group}`);
+                testGroups.push(group);
+            }
+        }
+        // Emit root-level test files (no group)
+        const rootTestMods = testGroupModuleNames.get("") || [];
+        const allTopLevel = [...rootTestMods.map(m => `mod ${m};`), ...testGroups.sort().map(g => `mod ${g};`)];
+        const mainContent = '// Code generated by Typra emitter; DO NOT EDIT.\n\n#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]\n\n'
+            + allTopLevel.join('\n') + '\n';
+        await emitRustFile(context, 'main.rs', mainContent, emitTarget["test-dir"]);
+    }
+    // Render root mod.rs
+    const rootModules = groupModuleNames.get("") || [];
+    const groups = Array.from(groupModuleNames.keys()).filter(g => g !== "").sort();
+    const libContent = emitRustLib(['context', ...rootModules], groups);
+    await emitRustFile(context, 'mod.rs', libContent, emitTarget["output-dir"]);
+    // Format emitted files
+    if (emitTarget.format !== false) {
+        const outputDir = emitTarget["output-dir"]
+            ? resolve(process.cwd(), emitTarget["output-dir"])
+            : context.emitterOutputDir;
+        formatRustFiles(outputDir);
+    }
+};
+/**
+ * Format Rust files using cargo fmt.
+ */
+function formatRustFiles(outputDir) {
+    // Run cargo fmt if Cargo.toml exists in parent
+    const cargoToml = resolve(outputDir, '../Cargo.toml');
+    if (existsSync(cargoToml)) {
+        try {
+            execFileSync("cargo", ["fmt", "--manifest-path", cargoToml], {
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+            normalizeRustFileEndings(resolve(outputDir, '..'));
+        }
+        catch (error) {
+            console.warn(`Warning: cargo fmt failed. You may need to install Rust.`);
+        }
+    }
+}
+function normalizeRustFileEndings(dir) {
+    for (const entry of readdirSync(dir)) {
+        const fullPath = resolve(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            normalizeRustFileEndings(fullPath);
+            continue;
+        }
+        if (!entry.endsWith(".rs")) {
+            continue;
+        }
+        const content = readFileSync(fullPath, "utf-8");
+        writeFileSync(fullPath, `${content.trimEnd()}\n`, "utf-8");
+    }
+}
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node) {
+    return buildBaseTestContext(node, undefined, rustTestOptions);
+}
+/**
+ * Write generated Rust content to file.
+ */
+async function emitRustFile(context, filename, content, outputDir) {
+    outputDir = outputDir || `${context.emitterOutputDir}/rust`;
+    const filePath = resolvePath(outputDir, filename);
+    await emitGeneratedFile(context, filePath, `${content.trimEnd()}\n`);
+}
+/**
+ * Emit the context.rs file content (LoadContext/SaveContext structs).
+ */
+function emitRustContext(header) {
+    return `// Code generated by Typra emitter; DO NOT EDIT.
+// ${header}
+
+#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]
+
+/// Callback type for pre-processing input data before parsing.
+pub type PreProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for post-processing the result after instantiation.
+pub type PostProcessFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for pre-processing an object before serialization.
+pub type PreSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Callback type for post-processing a dictionary after serialization.
+pub type PostSaveFn = Box<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>;
+
+/// Context for customizing the loading process of agent definitions.
+///
+/// Provides hooks for pre-processing input data before parsing and
+/// post-processing output data after instantiation.
+pub struct LoadContext {
+    /// Optional callback to transform input data before parsing.
+    pub pre_process: Option<PreProcessFn>,
+    /// Optional callback to transform the result after instantiation.
+    pub post_process: Option<PostProcessFn>,
+}
+
+impl std::fmt::Debug for LoadContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LoadContext")
+            .field("pre_process", &self.pre_process.as_ref().map(|_| "..."))
+            .field("post_process", &self.post_process.as_ref().map(|_| "..."))
+            .finish()
+    }
+}
+
+impl Default for LoadContext {
+    fn default() -> Self {
+        Self {
+            pre_process: None,
+            post_process: None,
+        }
+    }
+}
+
+impl LoadContext {
+    /// Create a new empty LoadContext.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Apply pre-processing to input data if a pre_process callback is set.
+    ///
+    /// # Arguments
+    /// * \`data\` - The raw input value to process.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_input(&self, data: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.pre_process {
+            f(data)
+        } else {
+            data
+        }
+    }
+
+    /// Apply post-processing to the result if a post_process callback is set.
+    ///
+    /// # Arguments
+    /// * \`result\` - The instantiated value to process.
+    ///
+    /// # Returns
+    /// The processed result, or the original if no callback is set.
+    pub fn process_output(&self, result: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.post_process {
+            f(result)
+        } else {
+            result
+        }
+    }
+}
+
+/// Context for customizing the serialization process of agent definitions.
+///
+/// Provides hooks for pre-processing the object before serialization and
+/// post-processing the dictionary after serialization.
+pub struct SaveContext {
+    /// Optional callback to transform the object before serialization.
+    pub pre_save: Option<PreSaveFn>,
+    /// Optional callback to transform the dictionary after serialization.
+    pub post_save: Option<PostSaveFn>,
+    /// Output format for collections: "object" (name as key) or "array" (list of dicts).
+    /// Defaults to "object".
+    pub collection_format: String,
+    /// Use shorthand scalar representation when possible.
+    /// Defaults to true.
+    pub use_shorthand: bool,
+}
+
+impl std::fmt::Debug for SaveContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SaveContext")
+            .field("pre_save", &self.pre_save.as_ref().map(|_| "..."))
+            .field("post_save", &self.post_save.as_ref().map(|_| "..."))
+            .field("collection_format", &self.collection_format)
+            .field("use_shorthand", &self.use_shorthand)
+            .finish()
+    }
+}
+
+impl Default for SaveContext {
+    fn default() -> Self {
+        Self {
+            pre_save: None,
+            post_save: None,
+            collection_format: "object".to_string(),
+            use_shorthand: true,
+        }
+    }
+}
+
+impl SaveContext {
+    /// Create a new SaveContext with defaults.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Apply pre-processing to the object if a pre_save callback is set.
+    ///
+    /// # Arguments
+    /// * \`obj\` - The value to process before serialization.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_object(&self, obj: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.pre_save {
+            f(obj)
+        } else {
+            obj
+        }
+    }
+
+    /// Apply post-processing to the dictionary if a post_save callback is set.
+    ///
+    /// # Arguments
+    /// * \`data\` - The serialized value to process.
+    ///
+    /// # Returns
+    /// The processed value, or the original if no callback is set.
+    pub fn process_dict(&self, data: serde_json::Value) -> serde_json::Value {
+        if let Some(ref f) = self.post_save {
+            f(data)
+        } else {
+            data
+        }
+    }
+
+    /// Convert a value to a YAML string.
+    pub fn to_yaml(&self, data: &serde_json::Value) -> Result<String, serde_yaml::Error> {
+        serde_yaml::to_string(data)
+    }
+
+    /// Convert a value to a JSON string.
+    pub fn to_json(&self, data: &serde_json::Value, indent: bool) -> Result<String, serde_json::Error> {
+        if indent {
+            serde_json::to_string_pretty(data)
+        } else {
+            serde_json::to_string(data)
+        }
+    }
+}
+`;
+}
+/**
+ * Emit the root mod.rs file content (module declarations).
+ *
+ * @param rootModules - Module names emitted directly in the root (e.g. ["context"])
+ * @param groups - Group subfolder names (e.g. ["connection", "tools"])
+ */
+function emitRustLib(rootModules, groups = []) {
+    let out = '// Code generated by Typra emitter; DO NOT EDIT.\n\n#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]\n';
+    for (const module of rootModules) {
+        out += `\npub mod ${module};\npub use ${module}::*;\n`;
+    }
+    for (const group of groups) {
+        out += `\npub mod ${group};\npub use ${group}::*;\n`;
+    }
+    return `${out.trimEnd()}\n`;
+}
+/**
+ * Emit a per-group mod.rs file that declares and re-exports all modules in that group.
+ */
+function emitRustGroupMod(moduleNames) {
+    let out = '// Code generated by Typra emitter; DO NOT EDIT.\n\n#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]\n';
+    for (const module of moduleNames) {
+        out += `\npub mod ${module};\npub use ${module}::*;\n`;
+    }
+    return out;
+}
+/**
+ * Map a factory parameter type string to a Rust test value literal.
+ */
+function factoryParamTestValue(typeStr) {
+    switch (typeStr) {
+        case "string": return '"test".to_string()';
+        case "boolean": return "true";
+        case "integer":
+        case "int32": return "42";
+        case "int64": return "42i64";
+        case "float":
+        case "float64": return "3.14";
+        case "unknown": return 'serde_json::json!("test")';
+        default: return 'serde_json::json!("test")';
+    }
+}
+function rustAssertionValue(node, key, value, delimiter) {
+    if (delimiter !== "" || typeof value !== "number" || !Number.isInteger(value)) {
+        return `${delimiter}${value}${delimiter}`;
+    }
+    const prop = node.properties.find(p => rustFieldName(p.name) === key);
+    const scalar = prop?.typeName.name;
+    if (scalar === "float" || scalar === "float32" || scalar === "float64" || scalar === "number" || scalar === "numeric") {
+        return `${value}.0`;
+    }
+    return `${value}`;
+}
+/**
+ * Emit an integration test file for a TypeSpec model type.
+ */
+function emitRustTest(ctx) {
+    const { node, isAbstract, examples, coercions, factories, importPath, isPolymorphicBase } = ctx;
+    const typeName = node.typeName.name;
+    const snakeName = toSnakeCase(typeName);
+    let out = '';
+    // Collect enum types referenced in properties (for use imports)
+    const enumImports = new Set();
+    for (const prop of node.properties) {
+        if (prop.enumName && node.discriminator !== prop.name) {
+            enumImports.add(prop.enumName);
+        }
+    }
+    out += '// Code generated by Typra emitter; DO NOT EDIT.\n';
+    out += '\n';
+    out += '#![allow(unused_imports, dead_code, non_camel_case_types, unused_variables, clippy::all)]\n';
+    out += '\n';
+    out += `use ${importPath}::${typeName};\n`;
+    for (const enumName of [...enumImports].sort()) {
+        if (enumName !== typeName) {
+            out += `use ${importPath}::${enumName};\n`;
+        }
+    }
+    out += `use ${importPath}::context::{LoadContext, SaveContext};\n`;
+    out += '\n';
+    // Example tests (load JSON, load YAML, roundtrip)
+    for (let i = 0; i < examples.length; i++) {
+        const sample = examples[i];
+        const suffix = i === 0 ? '' : `_${i}`;
+        // JSON load test
+        out += '#[test]\n';
+        out += `fn test_${snakeName}_load_json${suffix}() {\n`;
+        out += '    let json = r####"\n';
+        for (const line of sample.json) {
+            out += `${line}\n`;
+        }
+        out += '"####;\n';
+        out += '    let ctx = LoadContext::default();\n';
+        out += `    let result = ${typeName}::from_json(json, &ctx);\n`;
+        out += '    assert!(result.is_ok(), "Failed to load from JSON: {:?}", result.err());\n';
+        if (!isAbstract) {
+            out += '    let instance = result.unwrap();\n';
+            if (sample.validations.length > 0) {
+                for (const v of sample.validations) {
+                    if (v.isOptional) {
+                        out += `    assert!(instance.${v.key}.is_some(), "Expected ${v.key} to be Some");\n`;
+                        out += `    assert_eq!(instance.${v.key}.as_ref().unwrap(), &${rustAssertionValue(node, v.key, v.value, v.delimiter)});\n`;
+                    }
+                    else if (isPolymorphicBase && v.key === "kind") {
+                        out += `    assert_eq!(instance.kind_str(), ${rustAssertionValue(node, v.key, v.value, v.delimiter)});\n`;
+                    }
+                    else {
+                        out += `    assert_eq!(instance.${v.key}, ${rustAssertionValue(node, v.key, v.value, v.delimiter)});\n`;
+                    }
+                }
+            }
+            else {
+                out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+            }
+        }
+        out += '}\n';
+        out += '\n';
+        // YAML load test
+        out += '#[test]\n';
+        out += `fn test_${snakeName}_load_yaml${suffix}() {\n`;
+        out += '    let yaml = r####"\n';
+        for (const line of sample.yaml) {
+            out += `${line}\n`;
+        }
+        out += '"####;\n';
+        out += '    let ctx = LoadContext::default();\n';
+        out += `    let result = ${typeName}::from_yaml(yaml, &ctx);\n`;
+        out += '    assert!(result.is_ok(), "Failed to load from YAML: {:?}", result.err());\n';
+        if (!isAbstract) {
+            out += '    let instance = result.unwrap();\n';
+            if (sample.validations.length > 0) {
+                for (const v of sample.validations) {
+                    if (v.isOptional) {
+                        out += `    assert!(instance.${v.key}.is_some(), "Expected ${v.key} to be Some");\n`;
+                    }
+                    else if (isPolymorphicBase && v.key === "kind") {
+                        out += `    assert_eq!(instance.kind_str(), ${rustAssertionValue(node, v.key, v.value, v.delimiter)});\n`;
+                    }
+                    else {
+                        out += `    assert_eq!(instance.${v.key}, ${rustAssertionValue(node, v.key, v.value, v.delimiter)});\n`;
+                    }
+                }
+            }
+            else {
+                out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+            }
+        }
+        out += '}\n';
+        out += '\n';
+        // Roundtrip test
+        out += '#[test]\n';
+        out += `fn test_${snakeName}_roundtrip${suffix}() {\n`;
+        out += '    let json = r####"\n';
+        for (const line of sample.json) {
+            out += `${line}\n`;
+        }
+        out += '"####;\n';
+        out += '    let load_ctx = LoadContext::default();\n';
+        out += `    let result = ${typeName}::from_json(json, &load_ctx);\n`;
+        out += '    assert!(result.is_ok(), "Failed to load: {:?}", result.err());\n';
+        if (!isAbstract) {
+            out += '    let instance = result.unwrap();\n';
+            out += '    let save_ctx = SaveContext::default();\n';
+            out += '    let json_output = instance.to_json(&save_ctx);\n';
+            out += '    assert!(json_output.is_ok(), "Failed to serialize to JSON: {:?}", json_output.err());\n';
+        }
+        out += '}\n';
+        out += '\n';
+    }
+    // Coercion tests
+    for (let i = 0; i < coercions.length; i++) {
+        const alt = coercions[i];
+        const suffix = i === 0 ? '' : `_${i + 1}`;
+        out += '#[test]\n';
+        out += `fn test_${snakeName}_from_${alt.title.toLowerCase()}${suffix}() {\n`;
+        out += `    let value = serde_json::json!(${alt.value});\n`;
+        out += '    let ctx = LoadContext::default();\n';
+        out += `    let instance = ${typeName}::load_from_value(&value, &ctx);\n`;
+        if (!isAbstract) {
+            if (alt.validations.length > 0) {
+                for (const item of alt.validations) {
+                    if (item.isOptional) {
+                        out += `    assert!(instance.${item.key}.is_some());\n`;
+                    }
+                    else if (isPolymorphicBase && item.key === "kind") {
+                        out += `    assert_eq!(instance.kind_str(), ${rustAssertionValue(node, item.key, item.value, item.delimiter)});\n`;
+                    }
+                    else {
+                        out += `    assert_eq!(instance.${item.key}, ${rustAssertionValue(node, item.key, item.value, item.delimiter)});\n`;
+                    }
+                }
+            }
+            else {
+                out += '    let _ = instance; // load succeeded, no scalar properties to validate\n';
+            }
+        }
+        else {
+            out += '    let _ = instance; // abstract type, load succeeded\n';
+        }
+        out += '}\n';
+        out += '\n';
+    }
+    // Factory tests
+    for (const factory of factories) {
+        const factorySnake = toSnakeCase(factory.name);
+        const paramEntries = Object.entries(factory.params);
+        const paramValues = paramEntries.map(([, pType]) => factoryParamTestValue(pType)).join(', ');
+        out += '#[test]\n';
+        out += `fn test_${snakeName}_factory_${factorySnake}() {\n`;
+        out += `    let instance = ${typeName}::${factorySnake}(${paramValues});\n`;
+        for (const [propName, value] of Object.entries(factory.sets)) {
+            if (value === true) {
+                out += `    assert!(instance.${toSnakeCase(propName)});\n`;
+            }
+            else if (value === false) {
+                out += `    assert!(!instance.${toSnakeCase(propName)});\n`;
+            }
+        }
+        for (const [pName] of paramEntries) {
+            const prop = node.properties.find(p => p.name === pName);
+            if (prop && prop.isOptional) {
+                out += `    assert!(instance.${toSnakeCase(pName)}.is_some());\n`;
+            }
+        }
+        out += '}\n';
+        out += '\n';
+    }
+    return out;
+}
+//# sourceMappingURL=driver.js.map

package/dist/src/languages/rust/emitter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rust code emitter — Declaration IR → Rust source code.
+ *
+ * Replaces `file.rs.njk` + `_macros.njk` (~1,072 lines of Nunjucks templates)
+ * with a typed TypeScript function that walks the FileDecl tree.
+ *
+ * The emitter produces Rust code using the struct + enum pattern for
+ * polymorphic types. Output is post-processed by `cargo fmt`.
+ *
+ * Key Rust-specific patterns:
+ *   - Polymorphic types use struct + XxxKind enum (not inheritance)
+ *   - Variant-specific fields live on enum variants, not child classes
+ *   - Polymorphic single-ref fields → serde_json::Value
+ *   - Ownership: String, Option<T>, Vec<T>
+ *   - Pattern matching for load/save of variant fields
+ *
+ * Structural blocks emitted (in order):
+ *   1. Header comment (auto-generated warning)
+ *   2. Imports (context, referenced types)
+ *   3. For each polymorphic type:
+ *      a. XxxKind enum with inline struct variants
+ *      b. impl Default for XxxKind
+ *   4. For each type:
+ *      a. Struct definition with #[derive(Debug, Clone, Default)]
+ *      b. impl block:
+ *         - new(), from_json(), from_yaml()
+ *         - load_from_value()
+ *         - kind_str() (polymorphic only)
+ *         - to_value(), to_json(), to_yaml()
+ *         - to_wire() (when wire mappings exist)
+ *         - Collection helpers
+ *         - Factory methods
+ *         - Method stubs (as trait)
+ */
+import { FileDecl } from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+/**
+ * Emit a complete Rust source file from a FileDecl.
+ *
+ * @param file - File declaration to emit
+ * @param visitor - Expression visitor
+ * @param polymorphicTypeNames - Set of type names that have polymorphic dispatch
+ * @param childToParent - Map from child variant name to parent type name
+ */
+export declare function emitRustFile(file: FileDecl, visitor: ExprVisitor, polymorphicTypeNames: Set<string>, childToParent?: Map<string, string>): string;