@typra/emitter 0.2.0

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

@@ -0,0 +1,315 @@
+import { resolvePath } from "@typespec/compiler";
+import { enumerateTypes } from "../../ir/ast.js";
+import { filterNodes } from "../../emitter.js";
+import { getCombinations, scalarValue } from "../../ir/utilities.js";
+import * as YAML from "yaml";
+import { resolve, dirname } from "path";
+import { execFileSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { TypeRegistry } from "../../ir/expansion.js";
+import { CSharpExprVisitor } from "./visitor.js";
+import { lowerType, collectPolymorphicTypeNames } from "../../ir/lower.js";
+import { emitCSharpClass, emitCSharpEnum } from "./emitter.js";
+import { emitCSharpContext, emitCSharpUtils } from "./scaffolding.js";
+import { emitCSharpTest } from "./test-emitter.js";
+import { toPascalCase } from "../../ir/visitor.js";
+import { emitGeneratedFile } from "../../cleanup/generated-file.js";
+/**
+ * Stale-file deletion is intentionally disabled until manifest cleanup is enabled.
+ */
+function cleanupFlatTypeFiles(relDir, isTypeFile) {
+    void relDir;
+    void isTypeFile;
+    return;
+}
+function cleanupGeneratedCSharpFiles(relDir) {
+    void relDir;
+    return;
+}
+export const generateCsharp = async (context, node, emitTarget, options) => {
+    const allTypes = Array.from(enumerateTypes(node));
+    const nodes = filterNodes(allTypes, options);
+    cleanupGeneratedCSharpFiles(emitTarget["output-dir"]);
+    cleanupGeneratedCSharpFiles(emitTarget["test-dir"]);
+    // Stale flat-file cleanup is disabled in this slice.
+    const isCsTypeFile = (name) => name.endsWith(".cs") && name !== "Context.cs" && name !== "Utils.cs" &&
+        !name.endsWith("Helpers.cs") && !name.endsWith("Extensions.cs");
+    cleanupFlatTypeFiles(emitTarget["output-dir"], isCsTypeFile);
+    cleanupFlatTypeFiles(emitTarget["test-dir"], isCsTypeFile);
+    // Build the expression IR infrastructure
+    const registry = TypeRegistry.fromTypeGraph(allTypes);
+    const visitor = new CSharpExprVisitor(registry);
+    // Determine namespace: use explicit override from config, or fall back to TypeSpec namespace
+    const originalNamespace = node.typeName.namespace;
+    const csharpNamespace = emitTarget.namespace ?? originalNamespace;
+    // Emit context classes (LoadContext, SaveContext)
+    const contextCode = emitCSharpContext(csharpNamespace);
+    await emitCsharpFile(context, node, contextCode, "Context.cs", emitTarget["output-dir"]);
+    const utils = emitCSharpUtils(csharpNamespace);
+    await emitCsharpFile(context, node, utils, "Utils.cs", emitTarget["output-dir"]);
+    // Build Declaration IR once (loop-invariant)
+    const polyNames = collectPolymorphicTypeNames(allTypes[0], registry);
+    const allTypeDecls = nodes.map(nd => lowerType(nd, registry, polyNames));
+    const findTypeDecl = (name) => allTypeDecls.find(t => t.typeName.name === name);
+    // Collect and emit unique enum types from all fields
+    // Map each enum to the group of the first type that uses it
+    const emittedEnums = new Set();
+    const enumGroup = new Map(); // enumName → group
+    for (let i = 0; i < allTypeDecls.length; i++) {
+        const typeDecl = allTypeDecls[i];
+        const nodeGroup = nodes[i]?.group || "";
+        for (const field of typeDecl.fields) {
+            if (field.enumName && !emittedEnums.has(field.enumName)) {
+                enumGroup.set(field.enumName, nodeGroup);
+            }
+        }
+    }
+    for (const typeDecl of allTypeDecls) {
+        for (const field of typeDecl.fields) {
+            if (field.enumName && !field.isOpenEnum && field.allowedValues.length > 0 && !emittedEnums.has(field.enumName)) {
+                emittedEnums.add(field.enumName);
+                const enumCode = emitCSharpEnum({ name: field.enumName, values: field.allowedValues, isOpen: field.isOpenEnum }, csharpNamespace);
+                const csEnumName = field.enumName.charAt(0).toUpperCase() + field.enumName.slice(1);
+                const grp = enumGroup.get(field.enumName) || "";
+                const enumOutDir = grp ? `${emitTarget["output-dir"]}/${grp}` : emitTarget["output-dir"];
+                await emitCsharpFile(context, nodes[0], enumCode, `${csEnumName}.cs`, enumOutDir);
+            }
+        }
+    }
+    for (const n of nodes) {
+        const typeDecl = lowerType(n, registry, polyNames);
+        const classCode = emitCSharpClass(typeDecl, csharpNamespace, visitor, allTypeDecls, findTypeDecl);
+        // Emit into group subfolder (C# uses namespaces, no re-export files needed)
+        const outDir = n.group ? `${emitTarget["output-dir"]}/${n.group}` : emitTarget["output-dir"];
+        await emitCsharpFile(context, n, classCode, `${n.typeName.name}.cs`, outDir);
+        if (emitTarget["test-dir"] && !n.isProtocol) {
+            const testDir = n.group ? `${emitTarget["test-dir"]}/${n.group}` : emitTarget["test-dir"];
+            await emitCsharpFile(context, n, renderTests(n, csharpNamespace), `${n.typeName.name}ConversionTests.cs`, testDir);
+        }
+    }
+    // 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;
+        formatCSharpFiles(outputDir, testDir);
+    }
+};
+// --- Test-rendering helpers ---
+const renderTests = (node, namespace) => {
+    const samples = node.properties.filter(p => p.samples && p.samples.length > 0).map(p => {
+        return p.samples?.map(s => ({
+            ...s.sample,
+        }));
+    });
+    const combinations = samples.length > 0 ?
+        getCombinations(samples) :
+        [];
+    const examples = combinations.map(c => {
+        const sample = Object.assign({}, ...c);
+        // Create YAML document and customize string scalar style for values with special chars
+        const doc = new YAML.Document(sample);
+        YAML.visit(doc, {
+            Scalar(key, node) {
+                // Only quote string values that contain special characters requiring escaping
+                if (typeof node.value === 'string') {
+                    const str = node.value;
+                    if (str.includes('\n') || str.includes('\t') || str.includes('#') || str.includes(':') || str.includes('"')) {
+                        node.type = 'QUOTE_DOUBLE';
+                    }
+                }
+            }
+        });
+        return {
+            json: JSON.stringify(sample, null, 2).split('\n'),
+            yaml: doc.toString({ indent: 2, lineWidth: 0 }).split('\n'),
+            // get all scalars in the sample - using 'validations' (plural) for consistency across languages
+            validations: Object.keys(sample).filter(key => typeof sample[key] !== 'object').map(key => {
+                const val = sample[key];
+                // Check if this field is a closed enum — if so, use EnumName.MemberName syntax
+                // Skip discriminator fields — their enums are excluded from generation
+                const prop = node.properties.find(p => p.name === key);
+                const isDiscriminator = node.discriminator === key;
+                if (prop && prop.enumName && !prop.isOpenEnum && !isDiscriminator && typeof val === 'string') {
+                    const csEnumName = toPascalCase(prop.enumName);
+                    const memberName = toPascalCase(val);
+                    return {
+                        key: renderName(key),
+                        value: `${csEnumName}.${memberName}`,
+                        startDelim: '',
+                        endDelim: '',
+                    };
+                }
+                const needsVerbatim = typeof val === 'string' && (val.includes('\n') || val.includes('"'));
+                return {
+                    key: renderName(key),
+                    value: typeof val === 'boolean' ? (val ? "True" : "False") :
+                        (needsVerbatim ? val.replace(/"/g, '""') : val),
+                    startDelim: typeof val === 'string' ? (needsVerbatim ? '@"' : '"') : '',
+                    endDelim: typeof val === 'string' ? '"' :
+                        typeof val === 'number' && !Number.isInteger(val) ? 'f' : '',
+                };
+            }),
+        };
+    });
+    const coercions = node.coercions.map(alt => {
+        const example = alt.example ? (typeof (alt.example) === "string" ? '"' + alt.example + '"' : alt.example.toString()) : scalarValue[alt.scalar] || "None";
+        return {
+            title: alt.title || alt.scalar,
+            scalar: alt.scalar,
+            value: example,
+            // using 'validations' (plural) for consistency across languages
+            validations: Object.keys(alt.expansion).filter(key => typeof alt.expansion[key] !== 'object').map(key => {
+                const value = alt.expansion[key] === "{value}" ? example : alt.expansion[key];
+                // Check if this field is a closed enum (skip discriminator fields)
+                const prop = node.properties.find(p => p.name === key);
+                const isDiscriminator = node.discriminator === key;
+                if (prop && prop.enumName && !prop.isOpenEnum && !isDiscriminator) {
+                    // Extract the raw string value (strip quotes if present from example substitution)
+                    const rawValue = typeof value === 'string' ? value.replace(/^"|"$/g, '') : String(value);
+                    const csEnumName = toPascalCase(prop.enumName);
+                    const memberName = toPascalCase(rawValue);
+                    return {
+                        key: renderName(key),
+                        value: `${csEnumName}.${memberName}`,
+                        delimiter: '',
+                    };
+                }
+                return {
+                    key: renderName(key),
+                    value: value,
+                    delimiter: typeof value === 'string' && !value.includes('"') && alt.expansion[key] !== "{value}" ? '"' : '',
+                };
+            }),
+        };
+    });
+    return emitCSharpTest({
+        node,
+        namespace,
+        examples,
+        coercions,
+        factories: node.factories,
+        renderName,
+        renderCsharpFactoryMethodName: (factoryName) => renderCsharpFactoryMethodName(factoryName, node),
+        renderCsharpFactoryTestValue,
+    });
+};
+const renderName = (name) => {
+    // convert snake_case to PascalCase
+    const pascal = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    // capitalize the first letter
+    return pascal.charAt(0).toUpperCase() + pascal.slice(1);
+};
+const renderCsharpFactoryParamType = (typeStr) => {
+    switch (typeStr) {
+        case "string": return "string";
+        case "boolean": return "bool";
+        case "integer":
+        case "int32": return "int";
+        case "int64": return "long";
+        case "float":
+        case "float32": return "float";
+        case "float64": return "double";
+        case "unknown": return "object?";
+        default: return "object?";
+    }
+};
+// Returns a factory method name that won't clash with C# property names on the same type.
+// If the capitalized factory name matches a property name, prefix with "Create".
+const renderCsharpFactoryMethodName = (factoryName, node) => {
+    const methodName = factoryName.charAt(0).toUpperCase() + factoryName.slice(1);
+    const propertyNames = node.properties.map(p => renderName(p.name));
+    // Also consider zero-param non-verb method stubs that C# emits as properties
+    for (const m of node.methods) {
+        if (!m.params?.length) {
+            const mName = renderName(m.name);
+            if (!propertyNames.includes(mName)) {
+                propertyNames.push(mName);
+            }
+        }
+    }
+    if (propertyNames.includes(methodName)) {
+        return `Create${methodName}`;
+    }
+    return methodName;
+};
+const renderCsharpFactoryTestValue = (typeStr) => {
+    switch (typeStr) {
+        case "string": return '"test"';
+        case "boolean": return "true";
+        case "integer":
+        case "int32": return "42";
+        case "int64": return "42L";
+        case "float":
+        case "float32": return "3.14f";
+        case "float64": return "3.14";
+        case "unknown": return '"test"';
+        default: return '"test"';
+    }
+};
+const emitCsharpFile = async (context, type, python, filename, outputDir) => {
+    outputDir = outputDir || `${context.emitterOutputDir}/CSharp`;
+    const typePath = type.typeName.namespace.split(".");
+    // replace typename with file
+    typePath.push(filename);
+    const path = resolvePath(outputDir, filename);
+    await emitGeneratedFile(context, path, python);
+};
+/**
+ * Format C# files using dotnet format.
+ * Runs formatter from the .NET project root (where .csproj or .sln is located).
+ */
+function formatCSharpFiles(outputDir, testDir) {
+    const dirs = [outputDir, ...(testDir ? [testDir] : [])];
+    const formatted = new Set();
+    for (const dir of dirs) {
+        const projectRoot = findDotNetProjectRoot(dir);
+        if (!projectRoot) {
+            console.warn(`Warning: Could not find .csproj or .sln file for ${dir}. Skipping formatting.`);
+            continue;
+        }
+        // Avoid formatting the same project twice
+        if (formatted.has(projectRoot)) {
+            continue;
+        }
+        formatted.add(projectRoot);
+        try {
+            execFileSync("dotnet", ["format", projectRoot], {
+                cwd: dirname(projectRoot),
+                stdio: 'pipe',
+                encoding: 'utf-8'
+            });
+        }
+        catch (error) {
+            console.warn(`Warning: dotnet format failed for ${projectRoot}. You may need to run it manually.`);
+        }
+    }
+}
+/**
+ * Find the .NET project root by traversing up from the output directory
+ * looking for .csproj or .sln files.
+ */
+function findDotNetProjectRoot(startDir) {
+    let currentDir = resolve(startDir);
+    const root = resolve('/');
+    // On Windows, also check for drive root (e.g., "C:\")
+    while (currentDir !== root && currentDir !== dirname(currentDir)) {
+        // First check for .csproj (more specific)
+        const files = existsSync(currentDir) ? readdirSync(currentDir) : [];
+        const csprojFile = files.find((f) => f.endsWith('.csproj'));
+        if (csprojFile) {
+            return resolve(currentDir, csprojFile);
+        }
+        // Then check for .sln
+        const slnFile = files.find((f) => f.endsWith('.sln'));
+        if (slnFile) {
+            return resolve(currentDir, slnFile);
+        }
+        currentDir = dirname(currentDir);
+    }
+    return undefined;
+}
+//# sourceMappingURL=driver.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * C# code emitter — Declaration IR → C# source code.
+ *
+ * Replaces `file.cs.njk` Nunjucks template with a typed TypeScript function
+ * that walks the TypeDecl tree and produces a complete C# class file.
+ *
+ * Each TypeDecl becomes one C# file (one class per file).
+ * Polymorphic types use abstract class + child : Base inheritance.
+ *
+ * Structural blocks emitted (in order):
+ *   1. Copyright + using directives
+ *   2. Namespace
+ *   3. XML doc comment
+ *   4. Class declaration
+ *   5. ShorthandProperty
+ *   6. Constructor
+ *   7. Properties
+ *   8. #region Load Methods
+ *   9. #region Save Methods
+ *  10. #region Factory Methods (if any)
+ *  11. #region Helpers (if any)
+ */
+import { TypeDecl, EnumDef } from "../../ir/declarations.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+/**
+ * Emit a complete C# class file for a single TypeDecl.
+ */
+export declare function emitCSharpClass(type: TypeDecl, namespace: string, visitor: ExprVisitor, allTypes: TypeDecl[], findType: (name: string) => TypeDecl | undefined): string;
+/**
+ * Emit a C# enum file for a named string-literal type.
+ * Uses JsonStringEnumConverter for JSON serialization.
+ */
+export declare function emitCSharpEnum(enumDef: EnumDef, namespace: string): string;