@typra/emitter 0.2.0

package/dist/src/languages/csharp/test-emitter.js

@@ -0,0 +1,274 @@
+/**
+ * C# test emitter — TypeNode → xUnit test file.
+ *
+ * Replaces `test.cs.njk` Nunjucks template with a typed TypeScript function
+ * that produces a complete C# xUnit test class.
+ *
+ * Each TypeNode with samples/coercions/factories gets one test file
+ * containing LoadYaml, LoadJson, roundtrip, and validity tests.
+ */
+import { toPascalCase } from "../../ir/visitor.js";
+// ============================================================================
+// Main entry point
+// ============================================================================
+/**
+ * Emit a complete C# xUnit test file for a type node.
+ */
+export function emitCSharpTest(ctx) {
+    const typeName = ctx.node.typeName.name;
+    const L = [];
+    L.push('using Xunit;');
+    L.push('');
+    L.push('#pragma warning disable IDE0130');
+    L.push(`namespace ${ctx.namespace};`);
+    L.push('#pragma warning restore IDE0130');
+    L.push('');
+    L.push('');
+    L.push(`public class ${typeName}ConversionTests`);
+    L.push('{');
+    // --- Example tests (6 per example) ---
+    ctx.examples.forEach((sample, i) => {
+        const suffix = i === 0 ? '' : `${i}`;
+        // LoadYamlInput
+        L.push('    [Fact]');
+        L.push(`    public void LoadYamlInput${suffix}()`);
+        L.push('    {');
+        L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+        L.push('');
+        L.push(`        var instance = ${typeName}.FromYaml(yamlData);`);
+        L.push('');
+        L.push('        Assert.NotNull(instance);');
+        const yamlAssertions = emitExampleAssertions(sample.validations, 'instance');
+        if (yamlAssertions)
+            L.push(yamlAssertions);
+        L.push('    }');
+        L.push('');
+        // LoadJsonInput
+        L.push('    [Fact]');
+        L.push(`    public void LoadJsonInput${suffix}()`);
+        L.push('    {');
+        L.push(...emitRawStringLiteral('jsonData', sample.json));
+        L.push('');
+        L.push(`        var instance = ${typeName}.FromJson(jsonData);`);
+        L.push('        Assert.NotNull(instance);');
+        const jsonAssertions = emitExampleAssertions(sample.validations, 'instance');
+        if (jsonAssertions)
+            L.push(jsonAssertions);
+        L.push('    }');
+        L.push('');
+        // RoundtripJson
+        L.push('    [Fact]');
+        L.push(`    public void RoundtripJson${suffix}()`);
+        L.push('    {');
+        L.push('        // Test that FromJson -> ToJson -> FromJson produces equivalent data');
+        L.push(...emitRawStringLiteral('jsonData', sample.json));
+        L.push('');
+        L.push(`        var original = ${typeName}.FromJson(jsonData);`);
+        L.push('        Assert.NotNull(original);');
+        L.push('');
+        L.push('        var json = original.ToJson();');
+        L.push('        Assert.False(string.IsNullOrEmpty(json));');
+        L.push('');
+        L.push(`        var reloaded = ${typeName}.FromJson(json);`);
+        L.push('        Assert.NotNull(reloaded);');
+        const rtJsonAssertions = emitExampleAssertions(sample.validations, 'reloaded');
+        if (rtJsonAssertions)
+            L.push(rtJsonAssertions);
+        L.push('    }');
+        L.push('');
+        // RoundtripYaml
+        L.push('    [Fact]');
+        L.push(`    public void RoundtripYaml${suffix}()`);
+        L.push('    {');
+        L.push('        // Test that FromYaml -> ToYaml -> FromYaml produces equivalent data');
+        L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+        L.push('');
+        L.push(`        var original = ${typeName}.FromYaml(yamlData);`);
+        L.push('        Assert.NotNull(original);');
+        L.push('');
+        L.push('        var yaml = original.ToYaml();');
+        L.push('        Assert.False(string.IsNullOrEmpty(yaml));');
+        L.push('');
+        L.push(`        var reloaded = ${typeName}.FromYaml(yaml);`);
+        L.push('        Assert.NotNull(reloaded);');
+        const rtYamlAssertions = emitExampleAssertions(sample.validations, 'reloaded');
+        if (rtYamlAssertions)
+            L.push(rtYamlAssertions);
+        L.push('    }');
+        L.push('');
+        // ToJsonProducesValidJson
+        L.push('    [Fact]');
+        L.push(`    public void ToJsonProducesValidJson${suffix}()`);
+        L.push('    {');
+        L.push(...emitRawStringLiteral('jsonData', sample.json));
+        L.push('');
+        L.push(`        var instance = ${typeName}.FromJson(jsonData);`);
+        L.push('        var json = instance.ToJson();');
+        L.push('');
+        L.push('        // Verify it\'s valid JSON by parsing it');
+        L.push('        var parsed = System.Text.Json.JsonDocument.Parse(json);');
+        L.push('        Assert.NotNull(parsed);');
+        L.push('    }');
+        L.push('');
+        // ToYamlProducesValidYaml
+        L.push('    [Fact]');
+        L.push(`    public void ToYamlProducesValidYaml${suffix}()`);
+        L.push('    {');
+        L.push(...emitRawStringLiteral('yamlData', sample.yaml));
+        L.push('');
+        L.push(`        var instance = ${typeName}.FromYaml(yamlData);`);
+        L.push('        var yaml = instance.ToYaml();');
+        L.push('');
+        L.push('        // Verify it\'s valid YAML by parsing it');
+        L.push('        var deserializer = new YamlDotNet.Serialization.DeserializerBuilder().Build();');
+        L.push('        var parsed = deserializer.Deserialize<object>(yaml);');
+        L.push('        Assert.NotNull(parsed);');
+        L.push('    }');
+    });
+    // --- Coercion tests (2 per coercion) ---
+    if (ctx.coercions.length > 0) {
+        for (const alt of ctx.coercions) {
+            const titleScalar = alt.scalar.charAt(0).toUpperCase() + alt.scalar.slice(1);
+            // Build the C# data literal
+            let dataLine;
+            if (alt.scalar === 'string') {
+                dataLine = `        var data = "${alt.value.toString().replace(/\\/g, '\\\\').replace(/"/g, '\\"')}";`;
+            }
+            else {
+                let dataValue;
+                if (alt.value.toString() === "True")
+                    dataValue = "true";
+                else if (alt.value.toString() === "False")
+                    dataValue = "false";
+                else
+                    dataValue = alt.value.toString();
+                dataLine = `        var data = "${dataValue}";`;
+            }
+            // LoadJsonFrom{Scalar}
+            L.push('');
+            L.push('    [Fact]');
+            L.push(`    public void LoadJsonFrom${titleScalar}()`);
+            L.push('    {');
+            L.push(`        // alternate representation as ${alt.scalar}`);
+            L.push(dataLine);
+            L.push(`        var instance = ${typeName}.FromJson(data);`);
+            L.push('        Assert.NotNull(instance);');
+            const jsonCoercionAssertions = emitCoercionAssertions(alt.validations);
+            if (jsonCoercionAssertions)
+                L.push(jsonCoercionAssertions);
+            L.push('    }');
+            // LoadYamlFrom{Scalar}
+            L.push('');
+            L.push('    [Fact]');
+            L.push(`    public void LoadYamlFrom${titleScalar}()`);
+            L.push('    {');
+            L.push(`        // alternate representation as ${alt.scalar}`);
+            L.push(dataLine);
+            L.push(`        var instance = ${typeName}.FromYaml(data);`);
+            L.push('        Assert.NotNull(instance);');
+            L.push('');
+            const yamlCoercionAssertions = emitCoercionAssertions(alt.validations);
+            if (yamlCoercionAssertions)
+                L.push(yamlCoercionAssertions);
+            L.push('    }');
+        }
+    }
+    // --- Factory tests (1 per factory) ---
+    if (ctx.factories.length > 0) {
+        for (const factory of ctx.factories) {
+            const methodName = ctx.renderCsharpFactoryMethodName(factory.name);
+            const paramValues = Object.values(factory.params)
+                .map(pType => ctx.renderCsharpFactoryTestValue(pType))
+                .join(', ');
+            L.push('');
+            L.push('    [Fact]');
+            L.push(`    public void Factory${methodName}()`);
+            L.push('    {');
+            L.push(`        var instance = ${typeName}.${methodName}(${paramValues});`);
+            L.push('        Assert.NotNull(instance);');
+            for (const [propName, value] of Object.entries(factory.sets)) {
+                if (value === true) {
+                    L.push(`        Assert.True(instance.${ctx.renderName(propName)});`);
+                }
+                else if (value === false) {
+                    L.push(`        Assert.False(instance.${ctx.renderName(propName)});`);
+                }
+                else if (typeof value === 'number') {
+                    L.push(`        Assert.Equal(${value}, instance.${ctx.renderName(propName)});`);
+                }
+                else if (typeof value === 'string') {
+                    // Check if this property is a closed enum (skip discriminator fields)
+                    const prop = ctx.node.properties.find(p => p.name === propName);
+                    const isDiscriminator = ctx.node.discriminator === propName;
+                    if (prop && prop.enumName && !prop.isOpenEnum && !isDiscriminator) {
+                        const csEnumName = toPascalCase(prop.enumName);
+                        const memberName = toPascalCase(value);
+                        L.push(`        Assert.Equal(${csEnumName}.${memberName}, instance.${ctx.renderName(propName)});`);
+                    }
+                    else {
+                        L.push(`        Assert.Equal("${value}", instance.${ctx.renderName(propName)});`);
+                    }
+                }
+            }
+            L.push('    }');
+        }
+    }
+    L.push('}');
+    L.push('');
+    return L.join('\n');
+}
+// ============================================================================
+// Assertion helpers
+// ============================================================================
+/** Render Assert.Equal / Assert.True / Assert.False lines for example validations. */
+function emitExampleAssertions(validations, varName) {
+    return validations.map(v => {
+        if (v.value === "True" || v.value === "False") {
+            return `        Assert.${v.value === "False" ? "False" : "True"}(${varName}.${v.key});`;
+        }
+        if (v.startDelim === '@"') {
+            return `        Assert.Equal(${v.startDelim}${v.value}${v.endDelim}.Replace("\\r\\n", "\\n"), ${varName}.${v.key});`;
+        }
+        return `        Assert.Equal(${v.startDelim}${v.value}${v.endDelim}, ${varName}.${v.key});`;
+    }).join('\n');
+}
+/** Render assertion lines for coercion validations (with isFloat / bool / normal dispatch). */
+function emitCoercionAssertions(validations) {
+    return validations.map(v => {
+        const valueStr = v.value.toString();
+        if (valueStr === "True" || valueStr === "False") {
+            return [
+                `        Assert.NotNull(instance.${v.key});`,
+                `        Assert.IsType<bool>(instance.${v.key});`,
+                `        Assert.${valueStr === "False" ? "False" : "True"}((bool)instance.${v.key});`,
+            ].join('\n');
+        }
+        // Enum values (e.g., McpApprovalModeKind.Never) — emit direct assertion
+        if (v.delimiter === '' && /^[A-Z]/.test(valueStr)) {
+            return `        Assert.Equal(${v.value}, instance.${v.key});`;
+        }
+        // isFloat: value string contains '.'
+        if (valueStr.includes('.')) {
+            return [
+                `        Assert.NotNull(instance.${v.key});`,
+                `        Assert.True(instance.${v.key} is float || instance.${v.key} is double || instance.${v.key} is int || instance.${v.key} is long);`,
+                `        Assert.Equal(${v.value}, Convert.ToDouble(instance.${v.key}), 5);`,
+            ].join('\n');
+        }
+        return `        Assert.Equal(${v.delimiter}${v.value}${v.delimiter}, instance.${v.key});`;
+    }).join('\n');
+}
+// ============================================================================
+// Raw string literal helper
+// ============================================================================
+/** Emit a raw-string-literal block for C# (lines at column 0, delimiters on own lines). */
+function emitRawStringLiteral(varName, dataLines) {
+    const lines = [];
+    lines.push(`        string ${varName} = """`);
+    for (const line of dataLines) {
+        lines.push(line);
+    }
+    lines.push('""";');
+    return lines;
+}
+//# sourceMappingURL=test-emitter.js.map

package/dist/src/languages/csharp/visitor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * C# expression visitor — Expr IR → C# source fragments.
+ */
+import { Expr, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+export declare class CSharpExprVisitor implements ExprVisitor {
+    registry?: TypeRegistry;
+    constructor(registry?: TypeRegistry);
+    visitExpr(expr: Expr): string;
+    private visitConstruct;
+    private visitVariant;
+    private visitArray;
+    private escapeString;
+}

package/dist/src/languages/csharp/visitor.js

@@ -0,0 +1,79 @@
+/**
+ * C# expression visitor — Expr IR → C# source fragments.
+ */
+import { toPascalCase, assertNever } from "../../ir/visitor.js";
+export class CSharpExprVisitor {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    visitExpr(expr) {
+        switch (expr.kind) {
+            case "string":
+                return `"${this.escapeString(expr.value)}"`;
+            case "number":
+                return String(expr.value);
+            case "boolean":
+                return expr.value ? "true" : "false";
+            case "null":
+                return "null";
+            case "param":
+                return expr.name;
+            case "construct":
+                return this.visitConstruct(expr);
+            case "variant":
+                return this.visitVariant(expr);
+            case "array":
+                return this.visitArray(expr);
+            case "dict":
+                return `new Dictionary<string, object?> { ${expr.entries.map(e => `{ "${e.key}", ${this.visitExpr(e.value)} }`).join(", ")} }`;
+            case "field_read":
+                return `${expr.objectName}.${toPascalCase(expr.fieldName)}`;
+            default:
+                return assertNever(expr);
+        }
+    }
+    visitConstruct(expr) {
+        const typeName = expr.typeName.name;
+        if (expr.fields.length === 0) {
+            return `new ${typeName}()`;
+        }
+        // C# uses object initializer syntax: new Type { Prop = value }
+        const fields = expr.fields.map(f => {
+            let val = this.visitExpr(f.value);
+            // For enum fields, convert string literals to EnumName.MemberName
+            if (f.value.kind === "string" && this.registry) {
+                const typeNode = this.registry.get(typeName);
+                if (typeNode) {
+                    const prop = typeNode.properties.find(p => p.name === f.propertyName);
+                    if (prop?.enumName) {
+                        val = `${prop.enumName}.${toPascalCase(f.value.value)}`;
+                    }
+                }
+            }
+            return `${toPascalCase(f.propertyName)} = ${val}`;
+        }).join(", ");
+        return `new ${typeName} { ${fields} }`;
+    }
+    visitVariant(expr) {
+        // In C#, polymorphic children are full classes
+        const variantName = expr.variantTypeName.name;
+        if (expr.fields.length === 0) {
+            return `new ${variantName}()`;
+        }
+        const fields = expr.fields.map(f => `${toPascalCase(f.propertyName)} = ${this.visitExpr(f.value)}`).join(", ");
+        return `new ${variantName} { ${fields} }`;
+    }
+    visitArray(expr) {
+        const elementType = expr.elementTypeName.name;
+        if (expr.items.length === 0) {
+            return `new List<${elementType}>()`;
+        }
+        const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+        return `new List<${elementType}> { ${items} }`;
+    }
+    escapeString(s) {
+        return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+}
+//# sourceMappingURL=visitor.js.map

package/dist/src/languages/go/driver.d.ts

@@ -0,0 +1,12 @@
+import { EmitContext } from "@typespec/compiler";
+import { EmitTarget, TypraEmitterOptions } from "../../lib.js";
+import { TypeNode } from "../../ir/ast.js";
+import { GeneratorOptions } from "../../emitter.js";
+/**
+ * Type mapping from TypeSpec scalar types to Go types.
+ */
+export declare const goTypeMapper: Record<string, string>;
+/**
+ * Main entry point for Go code generation.
+ */
+export declare const generateGo: (context: EmitContext<TypraEmitterOptions>, node: TypeNode, emitTarget: EmitTarget, options?: GeneratorOptions) => Promise<void>;

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

@@ -0,0 +1,128 @@
+import { resolvePath } from "@typespec/compiler";
+import { execFileSync } from "child_process";
+import { resolve } from "path";
+import { enumerateTypes, } from "../../ir/ast.js";
+import { filterNodes } from "../../emitter.js";
+import { buildBaseTestContext, goTestOptions } from "../../testing/test-context.js";
+import { toSnakeCase } from "../../ir/utilities.js";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { GoExprVisitor } from "./visitor.js";
+import { lowerFile } from "../../ir/lower.js";
+import { emitGoFileContent } from "./emitter.js";
+import { emitGoContext } from "./scaffolding.js";
+import { emitGoTest } from "./test-emitter.js";
+import { emitGeneratedFile } from "../../cleanup/generated-file.js";
+/**
+ * Type mapping from TypeSpec scalar types to Go types.
+ */
+export const goTypeMapper = {
+    "string": "string",
+    "number": "float64",
+    "array": "[]",
+    "object": "map[string]interface{}",
+    "boolean": "bool",
+    "int64": "int64",
+    "int32": "int32",
+    "float64": "float64",
+    "float32": "float32",
+    "integer": "int",
+    "float": "float64",
+    "numeric": "float64",
+    "any": "interface{}",
+    "dictionary": "map[string]interface{}",
+};
+/**
+ * Main entry point for Go code generation.
+ */
+export const generateGo = async (context, node, emitTarget, options) => {
+    const allTypes = Array.from(enumerateTypes(node));
+    const nodes = filterNodes(allTypes, options);
+    // Build the expression IR infrastructure
+    const registry = TypeRegistry.fromTypeGraph(allTypes);
+    const visitor = new GoExprVisitor(registry);
+    // Determine package name from root node namespace (e.g., "Typra" -> "typra")
+    const packageName = node.typeName.namespace.toLowerCase().replace(/\./g, '');
+    // Collect all polymorphic type names across all nodes
+    const polymorphicTypeNames = new Set();
+    for (const n of nodes) {
+        const polyTypes = n.retrievePolymorphicTypes();
+        if (polyTypes) {
+            polymorphicTypeNames.add(n.typeName.name);
+        }
+    }
+    // Emit context file (LoadContext/SaveContext utilities)
+    const contextContent = emitGoContext({ header: "Typra Context", packageName });
+    await emitGoFile(context, 'context.go', contextContent, emitTarget["output-dir"]);
+    // Emit each base type and its children as a single file (Go stays flat — no subfolders)
+    for (const n of nodes) {
+        // Skip child types - they're rendered with their parent
+        if (!n.base) {
+            const fileDecl = lowerFile(n, registry, polymorphicTypeNames);
+            // Go stays flat: pass group as a header comment only, no subfolder emission
+            const fileContent = emitGoFileContent(fileDecl.types, packageName, visitor, polymorphicTypeNames, fileDecl.enums, n.group || "");
+            const fileName = toSnakeCase(n.typeName.name) + '.go';
+            await emitGoFile(context, fileName, fileContent, emitTarget["output-dir"]);
+        }
+        // Emit test file for each type (skip protocols — they have no data to test)
+        if (emitTarget["test-dir"] && !n.isProtocol) {
+            const importPath = emitTarget["import-path"] || packageName;
+            const testContext = { ...buildTestContext(n, packageName), importPath };
+            const testContent = emitGoTest(testContext);
+            const testFileName = toSnakeCase(n.typeName.name) + '_test.go';
+            await emitGoFile(context, testFileName, testContent, emitTarget["test-dir"]);
+        }
+    }
+    // Format emitted files if format option is enabled (default: true)
+    if (emitTarget.format !== false) {
+        const outputDir = emitTarget["output-dir"]
+            ? resolve(process.cwd(), emitTarget["output-dir"])
+            : context.emitterOutputDir;
+        const testDir = emitTarget["test-dir"]
+            ? resolve(process.cwd(), emitTarget["test-dir"])
+            : undefined;
+        formatGoFiles(outputDir, testDir);
+    }
+};
+/**
+ * Format Go files using gofmt and goimports.
+ */
+function formatGoFiles(outputDir, testDir) {
+    const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+    for (const dir of dirs) {
+        // Run gofmt — use execFileSync to avoid shell injection
+        try {
+            execFileSync("gofmt", ["-w", dir], {
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+        }
+        catch (error) {
+            console.warn(`Warning: gofmt formatting failed for ${dir}. You may need to install Go.`);
+        }
+        // Run goimports if available
+        try {
+            execFileSync("goimports", ["-w", dir], {
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+        }
+        catch (error) {
+            // goimports is optional, don't warn if not available
+        }
+    }
+}
+/**
+ * Build context for rendering a test file.
+ */
+function buildTestContext(node, packageName) {
+    return buildBaseTestContext(node, packageName, goTestOptions);
+}
+/**
+ * Write generated Go content to file.
+ */
+async function emitGoFile(context, filename, content, outputDir) {
+    outputDir = outputDir || `${context.emitterOutputDir}/go`;
+    const filePath = resolvePath(outputDir, filename);
+    await emitGeneratedFile(context, filePath, content);
+}
+//# sourceMappingURL=driver.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * Go code emitter — Declaration IR → Go source code.
+ *
+ * Replaces `file.go.njk` Nunjucks template with a typed TypeScript function
+ * that walks the TypeDecl tree and produces a complete Go source file.
+ *
+ * Each file contains one type hierarchy (parent + children).
+ * Go has no inheritance — child structs duplicate parent fields.
+ * Polymorphic types use interface{} and type switches.
+ *
+ * Structural blocks emitted per type (in order):
+ *   1. Description comment
+ *   2. Struct definition
+ *   3. Load function
+ *   4. Save method
+ *   5. ToJSON method
+ *   6. ToYAML method
+ *   7. FromJSON function
+ *   8. FromYAML function
+ */
+import { TypeDecl, EnumDef } from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+/**
+ * Emit a complete Go source file for a type hierarchy.
+ *
+ * @param types - All TypeDecls in this file (parent first, then children)
+ * @param packageName - Go package name (lowercase)
+ * @param visitor - Expression visitor for coercion rendering
+ * @param polymorphicTypeNames - Set of type names that are polymorphic bases
+ * @param enums - Enum definitions used in this file
+ * @param group - Semantic group from TSP source subfolder (used as header comment only; Go stays flat)
+ */
+export declare function emitGoFileContent(types: TypeDecl[], packageName: string, visitor: ExprVisitor, polymorphicTypeNames: Set<string>, enums?: EnumDef[], group?: string): string;