@typra/emitter 0.2.0

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

@@ -0,0 +1,879 @@
+/**
+ * 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 { toPascalCase } from "../../ir/visitor.js";
+// ============================================================================
+// Type maps
+// ============================================================================
+const GO_TYPE_MAP = {
+    string: "string",
+    number: "float64",
+    boolean: "bool",
+    int64: "int64",
+    int32: "int32",
+    float64: "float64",
+    float32: "float32",
+    integer: "int",
+    float: "float64",
+    numeric: "float64",
+    any: "interface{}",
+    unknown: "interface{}",
+    dictionary: "map[string]interface{}",
+};
+/** Go types that need numeric type-switch coercion in Load. */
+const NUMERIC_GO_TYPES = new Set(["int", "int32", "int64", "float32", "float64"]);
+/** Float Go types get an identity case (v = n) in the type switch. */
+const FLOAT_GO_TYPES = new Set(["float32", "float64"]);
+// ============================================================================
+// Main entry point
+// ============================================================================
+/**
+ * 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 function emitGoFileContent(types, packageName, visitor, polymorphicTypeNames, enums = [], group = "") {
+    const lines = [];
+    // Protocol-only files have a simpler header (no JSON/YAML imports)
+    const hasNonProtocol = types.some(t => !t.isProtocol);
+    if (hasNonProtocol) {
+        emitHeader(lines, packageName, group);
+    }
+    else {
+        emitProtocolHeader(lines, packageName, group);
+    }
+    // Emit enum type definitions
+    for (const enumDef of enums) {
+        emitGoEnum(enumDef, lines);
+    }
+    // Emit each type in the hierarchy
+    for (const type of types) {
+        emitTypeBlock(type, lines, visitor, polymorphicTypeNames);
+    }
+    return lines.join("\n");
+}
+// ============================================================================
+// File header
+// ============================================================================
+function emitHeader(lines, packageName, group = "") {
+    lines.push("// Code generated by Typra emitter; DO NOT EDIT.");
+    if (group) {
+        lines.push(`// Group: ${group}`);
+    }
+    lines.push("");
+    lines.push(`package ${packageName}`);
+    lines.push("");
+    lines.push("import (");
+    lines.push('\t"encoding/json"');
+    lines.push("");
+    lines.push('\t"gopkg.in/yaml.v3"');
+    lines.push(")");
+    lines.push("");
+}
+function emitProtocolHeader(lines, packageName, group = "") {
+    lines.push("// Code generated by Typra emitter; DO NOT EDIT.");
+    if (group) {
+        lines.push(`// Group: ${group}`);
+    }
+    lines.push("");
+    lines.push(`package ${packageName}`);
+    lines.push("");
+}
+/**
+ * Emit a Go enum type (type alias + const block).
+ */
+function emitGoEnum(enumDef, lines) {
+    lines.push(`// ${enumDef.name} represents the allowed values for ${enumDef.name}.`);
+    lines.push(`type ${enumDef.name} string`);
+    lines.push("");
+    lines.push("const (");
+    for (const value of enumDef.values) {
+        const constName = `${enumDef.name}${toPascalCase(value)}`;
+        lines.push(`\t${constName} ${enumDef.name} = "${value}"`);
+    }
+    lines.push(")");
+    lines.push("");
+}
+// ============================================================================
+// Type block — one complete type definition
+// ============================================================================
+function emitTypeBlock(type, lines, visitor, polymorphicTypeNames) {
+    const typeName = type.typeName.name;
+    // Protocol types → emit as Go interface
+    if (type.isProtocol) {
+        emitProtocolInterface(type, lines);
+        return;
+    }
+    const isPolymorphicBase = type.polymorphicDispatch !== null;
+    // Description comment
+    emitDescriptionComment(typeName, type.description, lines);
+    // Struct definition
+    emitStruct(type, lines, polymorphicTypeNames);
+    // Load function
+    emitLoadFunction(type, lines, polymorphicTypeNames);
+    // Save method
+    emitSaveMethod(type, lines, polymorphicTypeNames);
+    // ToWire method (only when wire mappings exist)
+    if (type.wire) {
+        emitToWireMethod(type, lines);
+    }
+    // ToJSON method
+    emitToJSON(typeName, lines);
+    // ToYAML method
+    emitToYAML(typeName, lines);
+    // FromJSON function
+    emitFromJSON(typeName, isPolymorphicBase, lines);
+    // FromYAML function
+    emitFromYAML(typeName, isPolymorphicBase, lines);
+    // Factory functions
+    if (type.factories.length > 0) {
+        for (const factory of type.factories) {
+            emitFactoryFunction(typeName, factory, visitor, lines);
+        }
+    }
+    // Method stubs
+    if (type.methods.length > 0) {
+        emitMethodStubs(typeName, type.methods, lines);
+    }
+}
+// ============================================================================
+// Description comment
+// ============================================================================
+function emitDescriptionComment(typeName, description, lines) {
+    if (!description) {
+        lines.push(`// ${typeName} represents a schema type`);
+        return;
+    }
+    const descLines = description.split(/\r?\n/);
+    const firstLine = descLines[0];
+    lines.push(`// ${typeName} represents ${firstLine}`);
+    for (let i = 1; i < descLines.length; i++) {
+        const line = descLines[i];
+        if (line.trim() === "") {
+            lines.push("//");
+        }
+        else {
+            lines.push(`// ${line}`);
+        }
+    }
+    // Blank line after description (unless it's "a schema type")
+    if (description !== "a schema type") {
+        lines.push("");
+    }
+}
+// ============================================================================
+// Struct definition
+// ============================================================================
+function emitStruct(type, lines, polymorphicTypeNames) {
+    const typeName = type.typeName.name;
+    lines.push(`type ${typeName} struct {`);
+    for (const field of type.fields) {
+        const goType = getGoFieldType(field.category, field.isOptional, polymorphicTypeNames, field.enumName);
+        const fieldName = toPascalCase(field.name);
+        const tag = getStructTag(field.name, field.isOptional);
+        lines.push(`\t${fieldName} ${goType} ${tag}`);
+    }
+    lines.push("}");
+    lines.push("");
+}
+// ============================================================================
+// Load function
+// ============================================================================
+function emitLoadFunction(type, lines, polymorphicTypeNames) {
+    const typeName = type.typeName.name;
+    const isPolymorphicBase = type.polymorphicDispatch !== null;
+    const hasCoercions = type.load.coercions.length > 0;
+    const returnType = isPolymorphicBase ? "interface{}" : typeName;
+    // Comment
+    lines.push(`// Load${typeName} creates a ${typeName} from a map[string]interface{}`);
+    if (isPolymorphicBase) {
+        lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+    }
+    // Signature
+    lines.push(`func Load${typeName}(data interface{}, ctx *LoadContext) (${returnType}, error) {`);
+    lines.push(`\tresult := ${typeName}{}`);
+    lines.push("");
+    // 1. Polymorphic dispatch
+    if (type.polymorphicDispatch) {
+        emitPolymorphicDispatch(type.polymorphicDispatch, lines);
+    }
+    // 2. Coercions
+    if (hasCoercions) {
+        emitCoercions(type.load.coercions, typeName, lines);
+    }
+    // 3. Map loading
+    lines.push("\t// Load from map");
+    lines.push("\tif m, ok := data.(map[string]interface{}); ok {");
+    for (const assign of type.load.assignments) {
+        emitLoadAssignment(assign, polymorphicTypeNames, lines);
+    }
+    lines.push("\t}");
+    lines.push("");
+    lines.push("\treturn result, nil");
+    lines.push("}");
+    lines.push("");
+}
+// ============================================================================
+// Polymorphic dispatch
+// ============================================================================
+function emitPolymorphicDispatch(dispatch, lines) {
+    lines.push("\t// Handle polymorphic types based on discriminator");
+    lines.push("\tif m, ok := data.(map[string]interface{}); ok {");
+    lines.push(`\t\tif discriminator, ok := m["${dispatch.discriminatorField}"]; ok {`);
+    lines.push("\t\t\tswitch discriminator {");
+    for (const variant of dispatch.variants) {
+        lines.push(`\t\t\tcase "${variant.value}":`);
+        lines.push(`\t\t\t\treturn Load${variant.typeName.name}(data, ctx)`);
+    }
+    // Default variant
+    if (dispatch.defaultVariant && !dispatch.defaultVariant.isSelfReference) {
+        lines.push("\t\t\tdefault:");
+        lines.push(`\t\t\t\treturn Load${dispatch.defaultVariant.typeName.name}(data, ctx)`);
+    }
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+    lines.push("\t}");
+}
+// ============================================================================
+// Coercions
+// ============================================================================
+function emitCoercions(coercions, typeName, lines) {
+    lines.push("\t// Handle alternate scalar representations");
+    lines.push("\tswitch v := data.(type) {");
+    for (const coercion of coercions) {
+        const goType = GO_TYPE_MAP[coercion.scalarType] || coercion.scalarType;
+        lines.push(`\tcase ${goType}:`);
+        lines.push(`\t\t// Shorthand: ${goType} -> ${typeName}`);
+        // Build expansion map
+        const entries = [];
+        for (const assign of coercion.assignments) {
+            if (assign.isInput) {
+                entries.push(`"${assign.fieldName}": v`);
+            }
+            else {
+                entries.push(`"${assign.fieldName}": "${assign.literalValue}"`);
+            }
+        }
+        lines.push(`\t\texpansion := map[string]interface{}{${entries.join(", ")}}`);
+        lines.push(`\t\treturn Load${typeName}(expansion, ctx)`);
+    }
+    lines.push("\t}");
+}
+// ============================================================================
+// Load assignment (per-property)
+// ============================================================================
+function emitLoadAssignment(assign, polymorphicTypeNames, lines) {
+    const fieldName = toPascalCase(assign.fieldName);
+    const cat = assign.category;
+    switch (cat.kind) {
+        case "scalar":
+            emitLoadScalar(assign, fieldName, cat.scalarType, lines);
+            break;
+        case "complex":
+            emitLoadComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+            break;
+        case "collection_scalar":
+            emitLoadCollectionScalar(assign, fieldName, cat.scalarType, lines);
+            break;
+        case "collection_complex":
+            emitLoadCollectionComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+            break;
+        case "dict":
+            emitLoadDict(assign, fieldName, lines);
+            break;
+    }
+}
+function emitLoadScalar(assign, fieldName, scalarType, lines) {
+    const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+    if (NUMERIC_GO_TYPES.has(goType)) {
+        emitLoadNumeric(assign, fieldName, goType, lines);
+        return;
+    }
+    if (goType === "interface{}") {
+        // any/unknown type
+        if (assign.isOptional) {
+            lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+            lines.push(`\t\t\tresult.${fieldName} = &val`);
+            lines.push("\t\t}");
+        }
+        else {
+            lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+            lines.push(`\t\t\tresult.${fieldName} = val`);
+            lines.push("\t\t}");
+        }
+        return;
+    }
+    if (goType === "bool") {
+        if (assign.isOptional) {
+            lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+            lines.push(`\t\t\tv := val.(bool)`);
+            lines.push(`\t\t\tresult.${fieldName} = &v`);
+            lines.push("\t\t}");
+        }
+        else {
+            lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+            lines.push(`\t\t\tresult.${fieldName} = val.(bool)`);
+            lines.push("\t\t}");
+        }
+        return;
+    }
+    // string (and others) — if the field is a named enum type, cast from string
+    const castType = assign.enumName ?? goType;
+    if (assign.isOptional) {
+        lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+        lines.push(`\t\t\tv := ${castType}(val.(string))`);
+        lines.push(`\t\t\tresult.${fieldName} = &v`);
+        lines.push("\t\t}");
+    }
+    else {
+        lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+        lines.push(`\t\t\tresult.${fieldName} = ${castType}(val.(string))`);
+        lines.push("\t\t}");
+    }
+}
+function emitLoadNumeric(assign, fieldName, goType, lines) {
+    const isFloat = FLOAT_GO_TYPES.has(goType);
+    // Build the coercion cases
+    const cases = [];
+    // int types: int, int32, int64, float64
+    // float types: int, int32, int64, float32, float64
+    cases.push({ caseType: "int", expr: `${goType}(n)` });
+    cases.push({ caseType: "int32", expr: `${goType}(n)` });
+    cases.push({ caseType: "int64", expr: `${goType}(n)` });
+    if (isFloat) {
+        // Identity case for float types uses direct assignment
+        if (goType === "float32") {
+            cases.push({ caseType: "float32", expr: "n" });
+            cases.push({ caseType: "float64", expr: `${goType}(n)` });
+        }
+        else {
+            // float64
+            cases.push({ caseType: "float32", expr: `${goType}(n)` });
+            cases.push({ caseType: "float64", expr: "n" });
+        }
+    }
+    else {
+        // int types don't include float32
+        cases.push({ caseType: "float64", expr: `${goType}(n)` });
+    }
+    if (assign.isOptional) {
+        lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip`);
+        lines.push(`\t\t\tvar v ${goType}`);
+        lines.push("\t\t\tswitch n := val.(type) {");
+        for (const c of cases) {
+            lines.push(`\t\t\tcase ${c.caseType}:`);
+            lines.push(`\t\t\t\tv = ${c.expr}`);
+        }
+        lines.push("\t\t\t}");
+        lines.push(`\t\t\tresult.${fieldName} = &v`);
+        lines.push("\t\t}");
+    }
+    else {
+        lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil { // Handle various numeric types from JSON/YAML/roundtrip`);
+        lines.push(`\t\t\tvar v ${goType}`);
+        lines.push("\t\t\tswitch n := val.(type) {");
+        for (const c of cases) {
+            lines.push(`\t\t\tcase ${c.caseType}:`);
+            lines.push(`\t\t\t\tv = ${c.expr}`);
+        }
+        lines.push("\t\t\t}");
+        lines.push(`\t\t\tresult.${fieldName} = v`);
+        lines.push("\t\t}");
+    }
+}
+function emitLoadComplex(assign, fieldName, typeName, polymorphicTypeNames, lines) {
+    const isPolymorphic = polymorphicTypeNames.has(typeName);
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push(`\t\t\tif m, ok := val.(map[string]interface{}); ok {`);
+    lines.push(`\t\t\t\tloaded, _ := Load${typeName}(m, ctx)`);
+    if (isPolymorphic) {
+        if (assign.isOptional) {
+            lines.push(`\t\t\t\t// Polymorphic type - keep as interface{} (no pointer needed, interface{} can be nil)`);
+        }
+        else {
+            lines.push(`\t\t\t\t// Polymorphic type - keep as interface{}`);
+        }
+        lines.push(`\t\t\t\tresult.${fieldName} = loaded`);
+    }
+    else {
+        if (assign.isOptional) {
+            lines.push(`\t\t\t\tresult.${fieldName} = &loaded`);
+        }
+        else {
+            lines.push(`\t\t\t\tresult.${fieldName} = loaded`);
+        }
+    }
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+}
+function emitLoadCollectionScalar(assign, fieldName, scalarType, lines) {
+    const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push("\t\t\tif arr, ok := val.([]interface{}); ok {");
+    if (goType === "interface{}") {
+        // any/unknown — assign entire array directly
+        lines.push(`\t\t\t\tresult.${fieldName} = arr`);
+    }
+    else {
+        // Typed elements — per-element cast
+        lines.push(`\t\t\t\tresult.${fieldName} = make([]${goType}, len(arr))`);
+        lines.push("\t\t\t\tfor i, v := range arr {");
+        lines.push(`\t\t\t\t\tresult.${fieldName}[i] = v.(${goType})`);
+        lines.push("\t\t\t\t}");
+    }
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+}
+function emitLoadCollectionComplex(assign, fieldName, typeName, polymorphicTypeNames, lines) {
+    const isPolymorphic = polymorphicTypeNames.has(typeName);
+    const goElemType = isPolymorphic ? "interface{}" : typeName;
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push("\t\t\tif arr, ok := val.([]interface{}); ok {");
+    lines.push(`\t\t\t\tresult.${fieldName} = make([]${goElemType}, len(arr))`);
+    lines.push("\t\t\t\tfor i, v := range arr {");
+    lines.push("\t\t\t\t\tif item, ok := v.(map[string]interface{}); ok {");
+    lines.push(`\t\t\t\t\t\tloaded, _ := Load${typeName}(item, ctx)`);
+    if (isPolymorphic) {
+        lines.push("\t\t\t\t\t\t// Polymorphic type - store as interface{}");
+        lines.push(`\t\t\t\t\t\tresult.${fieldName}[i] = loaded`);
+    }
+    else {
+        lines.push(`\t\t\t\t\t\tresult.${fieldName}[i] = loaded`);
+    }
+    lines.push("\t\t\t\t\t}");
+    lines.push("\t\t\t\t}");
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+}
+function emitLoadDict(assign, fieldName, lines) {
+    lines.push(`\t\tif val, ok := m["${assign.sourceName}"]; ok && val != nil {`);
+    lines.push("\t\t\tif m, ok := val.(map[string]interface{}); ok {");
+    lines.push(`\t\t\t\tresult.${fieldName} = m`);
+    lines.push("\t\t\t}");
+    lines.push("\t\t}");
+}
+// ============================================================================
+// Save method
+// ============================================================================
+function emitSaveMethod(type, lines, polymorphicTypeNames) {
+    const typeName = type.typeName.name;
+    lines.push(`// Save serializes ${typeName} to map[string]interface{}`);
+    lines.push(`func (obj *${typeName}) Save(ctx *SaveContext) map[string]interface{} {`);
+    lines.push("\tresult := make(map[string]interface{})");
+    for (const assign of type.save.assignments) {
+        emitSaveAssignment(assign, polymorphicTypeNames, lines);
+    }
+    lines.push("");
+    lines.push("\treturn result");
+    lines.push("}");
+    lines.push("");
+}
+// ============================================================================
+// Save assignment (per-property)
+// ============================================================================
+function emitSaveAssignment(assign, polymorphicTypeNames, lines) {
+    const fieldName = toPascalCase(assign.fieldName);
+    const cat = assign.category;
+    switch (cat.kind) {
+        case "scalar":
+            emitSaveScalar(assign, fieldName, cat.scalarType, lines);
+            break;
+        case "complex":
+            emitSaveComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+            break;
+        case "collection_scalar":
+            emitSaveCollectionScalar(assign, fieldName, lines);
+            break;
+        case "collection_complex":
+            emitSaveCollectionComplex(assign, fieldName, cat.typeName, polymorphicTypeNames, lines);
+            break;
+        case "dict":
+            emitSaveDict(assign, fieldName, lines);
+            break;
+    }
+}
+function emitSaveScalar(assign, fieldName, scalarType, lines) {
+    const goType = GO_TYPE_MAP[scalarType] || "interface{}";
+    // Named enum fields must be cast back to string so roundtrip Load can do val.(string)
+    const saveExpr = assign.enumName ? `string(obj.${fieldName})` : `obj.${fieldName}`;
+    const saveExprDeref = assign.enumName ? `string(*obj.${fieldName})` : `*obj.${fieldName}`;
+    if (assign.isOptional) {
+        lines.push(`\tif obj.${fieldName} != nil {`);
+        lines.push(`\t\tresult["${assign.targetName}"] = ${saveExprDeref}`);
+        lines.push("\t}");
+    }
+    else {
+        lines.push(`\tresult["${assign.targetName}"] = ${saveExpr}`);
+    }
+}
+function emitSaveComplex(assign, fieldName, typeName, polymorphicTypeNames, lines) {
+    const isPolymorphic = polymorphicTypeNames.has(typeName);
+    if (isPolymorphic) {
+        if (assign.isOptional) {
+            // Optional polymorphic complex — double nil check pattern
+            lines.push(`\tif obj.${fieldName} != nil {`);
+            lines.push(`\t\t// Handle polymorphic type (stored as interface{} without pointer)`);
+            lines.push(`\t\tif obj.${fieldName} != nil {`);
+            lines.push(`\t\t\tswitch v := obj.${fieldName}.(type) {`);
+            lines.push("\t\t\tcase interface {");
+            lines.push("\t\t\t\tSave(*SaveContext) map[string]interface{}");
+            lines.push("\t\t\t}:");
+            lines.push(`\t\t\t\tresult["${assign.targetName}"] = v.Save(ctx)`);
+            lines.push("\t\t\tdefault:");
+            lines.push(`\t\t\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+            lines.push("\t\t\t}");
+            lines.push("\t\t}");
+            lines.push("\t}");
+        }
+        else {
+            // Required polymorphic complex — blank line before, type switch
+            lines.push("");
+            lines.push("\t// Handle polymorphic type via type switch");
+            lines.push(`\tswitch v := obj.${fieldName}.(type) {`);
+            lines.push("\tcase interface {");
+            lines.push("\t\tSave(*SaveContext) map[string]interface{}");
+            lines.push("\t}:");
+            lines.push(`\t\tresult["${assign.targetName}"] = v.Save(ctx)`);
+            lines.push("\tdefault:");
+            lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+            lines.push("\t}");
+        }
+    }
+    else {
+        if (assign.isOptional) {
+            lines.push(`\tif obj.${fieldName} != nil {`);
+            lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}.Save(ctx)`);
+            lines.push("\t}");
+        }
+        else {
+            // Required non-polymorphic complex — blank line before
+            lines.push("");
+            lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}.Save(ctx)`);
+        }
+    }
+}
+function emitSaveCollectionScalar(assign, fieldName, lines) {
+    // Collection scalars are always saved directly (no nil check)
+    lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}`);
+}
+function emitSaveCollectionComplex(assign, fieldName, typeName, polymorphicTypeNames, lines) {
+    const isPolymorphic = polymorphicTypeNames.has(typeName);
+    lines.push(`\tif obj.${fieldName} != nil {`);
+    if (isPolymorphic) {
+        lines.push(`\t\tarr := make([]interface{}, len(obj.${fieldName}))`);
+        lines.push(`\t\tfor i, item := range obj.${fieldName} {`);
+        lines.push("\t\t\t// Handle polymorphic type via type switch");
+        lines.push("\t\t\tswitch v := item.(type) {");
+        lines.push("\t\t\tcase interface {");
+        lines.push("\t\t\t\tSave(*SaveContext) map[string]interface{}");
+        lines.push("\t\t\t}:");
+        lines.push("\t\t\t\tarr[i] = v.Save(ctx)");
+        lines.push("\t\t\tdefault:");
+        lines.push("\t\t\t\tarr[i] = item");
+        lines.push("\t\t\t}");
+        lines.push("\t\t}");
+        lines.push(`\t\tresult["${assign.targetName}"] = arr`);
+    }
+    else {
+        lines.push(`\t\tarr := make([]interface{}, len(obj.${fieldName}))`);
+        lines.push(`\t\tfor i, item := range obj.${fieldName} {`);
+        lines.push("\t\t\tarr[i] = item.Save(ctx)");
+        lines.push("\t\t}");
+        lines.push(`\t\tresult["${assign.targetName}"] = arr`);
+    }
+    lines.push("\t}");
+}
+function emitSaveDict(assign, fieldName, lines) {
+    if (assign.isOptional) {
+        lines.push(`\tif obj.${fieldName} != nil {`);
+        lines.push(`\t\tresult["${assign.targetName}"] = obj.${fieldName}`);
+        lines.push("\t}");
+    }
+    else {
+        lines.push(`\tresult["${assign.targetName}"] = obj.${fieldName}`);
+    }
+}
+// ============================================================================
+// ToWire method (provider-specific wire format)
+// ============================================================================
+function emitToWireMethod(type, lines) {
+    const typeName = type.typeName.name;
+    const wire = type.wire;
+    lines.push(`// ToWire converts to provider-specific wire format.`);
+    lines.push(`func (obj *${typeName}) ToWire(provider string) map[string]interface{} {`);
+    lines.push(`\tdata := obj.Save(nil)`);
+    lines.push(`\tresult := make(map[string]interface{})`);
+    lines.push(`\twireMap := map[string]map[string]string{`);
+    for (const mapping of wire.mappings) {
+        const entries = Object.entries(mapping.wireNames)
+            .map(([provider, wireName]) => `"${provider}": "${wireName}"`)
+            .join(", ");
+        lines.push(`\t\t"${mapping.fieldName}": {${entries}},`);
+    }
+    lines.push(`\t}`);
+    lines.push(`\tfor key, value := range data {`);
+    lines.push(`\t\tif mapping, ok := wireMap[key]; ok {`);
+    lines.push(`\t\t\tif wireName, ok := mapping[provider]; ok {`);
+    lines.push(`\t\t\t\tresult[wireName] = value`);
+    lines.push(`\t\t\t}`);
+    lines.push(`\t\t}`);
+    lines.push(`\t}`);
+    lines.push(`\treturn result`);
+    lines.push(`}`);
+    lines.push(``);
+}
+// ============================================================================
+// ToJSON / ToYAML methods
+// ============================================================================
+function emitToJSON(typeName, lines) {
+    lines.push(`// ToJSON serializes ${typeName} to JSON string`);
+    lines.push(`func (obj *${typeName}) ToJSON() (string, error) {`);
+    lines.push("\tctx := NewSaveContext()");
+    lines.push("\tdata := obj.Save(ctx)");
+    lines.push("\tbytes, err := json.Marshal(data)");
+    lines.push("\tif err != nil {");
+    lines.push('\t\treturn "", err');
+    lines.push("\t}");
+    lines.push("\treturn string(bytes), nil");
+    lines.push("}");
+    lines.push("");
+}
+function emitToYAML(typeName, lines) {
+    lines.push(`// ToYAML serializes ${typeName} to YAML string`);
+    lines.push(`func (obj *${typeName}) ToYAML() (string, error) {`);
+    lines.push("\tctx := NewSaveContext()");
+    lines.push("\tdata := obj.Save(ctx)");
+    lines.push("\tbytes, err := yaml.Marshal(data)");
+    lines.push("\tif err != nil {");
+    lines.push('\t\treturn "", err');
+    lines.push("\t}");
+    lines.push("\treturn string(bytes), nil");
+    lines.push("}");
+    lines.push("");
+}
+// ============================================================================
+// FromJSON / FromYAML functions
+// ============================================================================
+function emitFromJSON(typeName, isPolymorphic, lines) {
+    lines.push(`// FromJSON creates ${typeName} from JSON string`);
+    if (isPolymorphic) {
+        lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+    }
+    const returnType = isPolymorphic ? "interface{}" : typeName;
+    const errorReturn = isPolymorphic ? "nil" : `${typeName}{}`;
+    lines.push(`func ${typeName}FromJSON(jsonStr string) (${returnType}, error) {`);
+    lines.push("\tvar data map[string]interface{}");
+    lines.push("\tif err := json.Unmarshal([]byte(jsonStr), &data); err != nil {");
+    lines.push(`\t\treturn ${errorReturn}, err`);
+    lines.push("\t}");
+    lines.push("\tctx := NewLoadContext()");
+    lines.push(`\treturn Load${typeName}(data, ctx)`);
+    lines.push("}");
+    lines.push("");
+}
+function emitFromYAML(typeName, isPolymorphic, lines) {
+    lines.push(`// FromYAML creates ${typeName} from YAML string`);
+    if (isPolymorphic) {
+        lines.push("// Returns interface{} because this is a polymorphic base type that can resolve to different child types");
+    }
+    const returnType = isPolymorphic ? "interface{}" : typeName;
+    const errorReturn = isPolymorphic ? "nil" : `${typeName}{}`;
+    lines.push(`func ${typeName}FromYAML(yamlStr string) (${returnType}, error) {`);
+    lines.push("\tvar data map[string]interface{}");
+    lines.push("\tif err := yaml.Unmarshal([]byte(yamlStr), &data); err != nil {");
+    lines.push(`\t\treturn ${errorReturn}, err`);
+    lines.push("\t}");
+    lines.push("\tctx := NewLoadContext()");
+    lines.push(`\treturn Load${typeName}(data, ctx)`);
+    lines.push("}");
+    lines.push("");
+}
+// ============================================================================
+// Type helpers
+// ============================================================================
+function getGoFieldType(category, isOptional, polymorphicTypeNames, enumName) {
+    // Named enum — use enum type alias
+    if (enumName) {
+        return isOptional ? `*${enumName}` : enumName;
+    }
+    switch (category.kind) {
+        case "scalar": {
+            const goType = GO_TYPE_MAP[category.scalarType] || "interface{}";
+            if (goType === "interface{}") {
+                return isOptional ? "*interface{}" : "interface{}";
+            }
+            return isOptional ? `*${goType}` : goType;
+        }
+        case "complex": {
+            const isPolymorphic = polymorphicTypeNames.has(category.typeName);
+            if (isPolymorphic) {
+                // Polymorphic complex: always interface{} (no pointer even for optional)
+                return "interface{}";
+            }
+            return isOptional ? `*${category.typeName}` : category.typeName;
+        }
+        case "collection_scalar": {
+            const goType = GO_TYPE_MAP[category.scalarType] || "interface{}";
+            return `[]${goType}`;
+        }
+        case "collection_complex": {
+            const isPolymorphic = polymorphicTypeNames.has(category.typeName);
+            if (isPolymorphic) {
+                return "[]interface{}";
+            }
+            return `[]${category.typeName}`;
+        }
+        case "dict":
+            return "map[string]interface{}";
+    }
+}
+function getStructTag(fieldName, isOptional) {
+    const jsonTag = isOptional ? `${fieldName},omitempty` : fieldName;
+    const yamlTag = isOptional ? `${fieldName},omitempty` : fieldName;
+    return `\`json:"${jsonTag}" yaml:"${yamlTag}"\``;
+}
+// ============================================================================
+// Factory functions
+// ============================================================================
+/** Emit a package-level factory function that creates a pre-populated struct. */
+function emitFactoryFunction(typeName, factory, visitor, lines) {
+    const funcName = getGoFactoryName(factory.name, typeName);
+    const params = Object.entries(factory.params)
+        .map(([pName, pType]) => `${pName} ${goFactoryParamType(pType)}`)
+        .join(", ");
+    lines.push(`// ${funcName} creates a ${typeName} with preset field values.`);
+    lines.push(`func ${funcName}(${params}) ${typeName} {`);
+    lines.push(`\treturn ${visitor.visitExpr(factory.body)}`);
+    lines.push("}");
+    lines.push("");
+}
+/** Map factory name to an exported Go function name, prefixed with the type for disambiguation. */
+function getGoFactoryName(factoryName, typeName) {
+    // Go factories are package-level functions, so prefix with type name to avoid collisions.
+    // e.g., Message.user → NewUserMessage, GuardrailResult.allow → NewAllowGuardrailResult
+    const capitalizedFactory = factoryName.charAt(0).toUpperCase() + factoryName.slice(1);
+    return `New${capitalizedFactory}${typeName}`;
+}
+/** Map IR type strings to Go parameter types. */
+function goFactoryParamType(typeStr) {
+    switch (typeStr) {
+        case "string":
+            return "string";
+        case "boolean":
+            return "bool";
+        case "int32":
+            return "int32";
+        case "int64":
+        case "integer":
+            return "int64";
+        case "float32":
+            return "float32";
+        case "float64":
+        case "float":
+            return "float64";
+        case "unknown":
+        case "any":
+            return "interface{}";
+        default:
+            return typeStr;
+    }
+}
+// ============================================================================
+// Method stubs
+// ============================================================================
+/** Emit Go interface + comment stubs for @method-decorated helpers. */
+function emitMethodStubs(typeName, methods, lines) {
+    // Emit an interface that the user implements in a separate file.
+    const interfaceName = `${typeName}Helpers`;
+    lines.push(`// ${interfaceName} defines helper methods for ${typeName}.`);
+    lines.push(`// Implement these in a separate file (e.g., ${typeName.toLowerCase()}_helpers.go).`);
+    lines.push(`type ${interfaceName} interface {`);
+    for (const method of methods) {
+        if (method.description) {
+            lines.push(`\t// ${toPascalCase(method.name)} — ${method.description}`);
+        }
+        lines.push(`\t${toPascalCase(method.name)}() ${goMethodReturnType(method.returns)}`);
+    }
+    lines.push("}");
+    lines.push("");
+}
+function goMethodReturnType(returns) {
+    return GO_TYPE_MAP[returns] || returns;
+}
+// ============================================================================
+// Protocol interface emission
+// ============================================================================
+/** Map a protocol type string to a Go type. */
+function protocolGoType(typeStr) {
+    // Handle nullable types
+    if (typeStr.endsWith("?")) {
+        const inner = typeStr.slice(0, -1);
+        return `*${protocolGoType(inner)}`;
+    }
+    // Handle array types
+    if (typeStr.endsWith("[]")) {
+        const inner = typeStr.slice(0, -2);
+        return `[]${protocolGoType(inner)}`;
+    }
+    if (typeStr === "Record<unknown>" || typeStr === "dictionary")
+        return "map[string]interface{}";
+    if (typeStr === "unknown" || typeStr === "any")
+        return "interface{}";
+    return GO_TYPE_MAP[typeStr] || typeStr;
+}
+/**
+ * Emit a Go interface for a protocol type.
+ */
+function emitProtocolInterface(type, lines) {
+    const name = type.typeName.name;
+    if (type.description) {
+        emitDescriptionComment(name, type.description, lines);
+    }
+    lines.push(`type ${name} interface {`);
+    for (const method of type.methods) {
+        if (method.description) {
+            lines.push(`\t// ${toPascalCase(method.name)} — ${method.description}`);
+        }
+        const params = Object.entries(method.params)
+            .map(([pName, pType]) => `${pName} ${protocolGoType(pType)}`)
+            .join(", ");
+        const ret = protocolGoType(method.returns);
+        if (method.sync) {
+            // Sync method — return type without error for optional
+            if (method.optional) {
+                lines.push(`\t${toPascalCase(method.name)}(${params}) ${ret}`);
+            }
+            else {
+                lines.push(`\t${toPascalCase(method.name)}(${params}) (${ret}, error)`);
+            }
+        }
+        else {
+            lines.push(`\t${toPascalCase(method.name)}(${params}) (${ret}, error)`);
+        }
+    }
+    lines.push("}");
+    lines.push("");
+}
+//# sourceMappingURL=emitter.js.map