@tsonic/emitter 0.0.1

package/src/generator.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for generator emission
+ * Per spec/13-generators.md
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "./emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Generator Emission", () => {
+  it("should generate exchange class for simple generator", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/counter.ts",
+      namespace: "Test",
+      className: "counter",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "counter",
+          parameters: [],
+          returnType: {
+            kind: "referenceType",
+            name: "Generator",
+            typeArguments: [
+              { kind: "primitiveType", name: "number" },
+              { kind: "primitiveType", name: "undefined" },
+              { kind: "primitiveType", name: "undefined" },
+            ],
+          },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "variableDeclaration",
+                declarationKind: "let",
+                isExported: false,
+                declarations: [
+                  {
+                    kind: "variableDeclarator",
+                    name: { kind: "identifierPattern", name: "i" },
+                    type: { kind: "primitiveType", name: "number" },
+                    initializer: { kind: "literal", value: 0 },
+                  },
+                ],
+              },
+              {
+                kind: "whileStatement",
+                condition: { kind: "literal", value: true },
+                body: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "yield",
+                        expression: { kind: "identifier", name: "i" },
+                        delegate: false,
+                      },
+                    },
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "assignment",
+                        operator: "+=",
+                        left: { kind: "identifier", name: "i" },
+                        right: { kind: "literal", value: 1 },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          isAsync: false,
+          isGenerator: true,
+          isExported: true,
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should contain exchange class
+    expect(code).to.include("public sealed class counter_exchange");
+    expect(code).to.include("public object? Input { get; set; }");
+    expect(code).to.include("public double Output { get; set; }");
+
+    // Should have IEnumerable return type
+    expect(code).to.include(
+      "public static IEnumerable<counter_exchange> counter()"
+    );
+
+    // Should use System.Collections.Generic
+    expect(code).to.include("using System.Collections.Generic");
+
+    // Should initialize exchange variable
+    expect(code).to.include("var exchange = new counter_exchange()");
+
+    // Should emit yield with exchange object pattern
+    expect(code).to.include("exchange.Output = i");
+    expect(code).to.include("yield return exchange");
+  });
+
+  it("should handle async generator", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/asyncCounter.ts",
+      namespace: "Test",
+      className: "asyncCounter",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "asyncCounter",
+          parameters: [],
+          returnType: {
+            kind: "referenceType",
+            name: "AsyncGenerator",
+            typeArguments: [
+              { kind: "primitiveType", name: "number" },
+              { kind: "primitiveType", name: "undefined" },
+              { kind: "primitiveType", name: "undefined" },
+            ],
+          },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "variableDeclaration",
+                declarationKind: "let",
+                isExported: false,
+                declarations: [
+                  {
+                    kind: "variableDeclarator",
+                    name: { kind: "identifierPattern", name: "i" },
+                    type: { kind: "primitiveType", name: "number" },
+                    initializer: { kind: "literal", value: 0 },
+                  },
+                ],
+              },
+              {
+                kind: "whileStatement",
+                condition: { kind: "literal", value: true },
+                body: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "yield",
+                        expression: { kind: "identifier", name: "i" },
+                        delegate: false,
+                      },
+                    },
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "assignment",
+                        operator: "+=",
+                        left: { kind: "identifier", name: "i" },
+                        right: { kind: "literal", value: 1 },
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          isAsync: true,
+          isGenerator: true,
+          isExported: true,
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should contain exchange class
+    expect(code).to.include("public sealed class asyncCounter_exchange");
+
+    // Should have IAsyncEnumerable return type with async
+    expect(code).to.include(
+      "public static async IAsyncEnumerable<asyncCounter_exchange> asyncCounter()"
+    );
+  });
+});

package/src/golden-tests/config-parser.ts

@@ -0,0 +1,67 @@
+/**
+ * Config.yaml parser for golden tests
+ */
+
+import YAML from "yaml";
+import { TestEntry } from "./types.js";
+
+/**
+ * Parse config.yaml and extract test entries
+ */
+export const parseConfigYaml = (yamlContent: string): readonly TestEntry[] => {
+  const parsed = YAML.parse(yamlContent);
+
+  if (!Array.isArray(parsed)) {
+    throw new Error("config.yaml must be an array of test entries");
+  }
+
+  const entries: TestEntry[] = [];
+
+  for (const item of parsed) {
+    if (typeof item === "object" && item !== null) {
+      // Check if it's the simple YAML format: { "File.ts": "title" }
+      const keys = Object.keys(item);
+
+      if (keys.length === 1 && keys[0] && keys[0].endsWith(".ts")) {
+        // Simple format parsed as object
+        const input = keys[0];
+        const title = item[input];
+
+        if (typeof title !== "string") {
+          throw new Error(`Title must be a string for ${input}`);
+        }
+
+        entries.push({ input, title });
+      } else if (item.input && item.title) {
+        // Explicit format: { input: "File.ts", title: "..." }
+        const input = item.input;
+        const title = item.title;
+
+        if (typeof input !== "string" || typeof title !== "string") {
+          throw new Error(
+            "Each test entry must have 'input' and 'title' fields"
+          );
+        }
+
+        entries.push({ input, title });
+      } else {
+        throw new Error(`Invalid test entry: ${JSON.stringify(item)}`);
+      }
+    } else if (typeof item === "string") {
+      // Quoted string format: "File.ts: title here"
+      const match = item.match(/^(\S+\.ts):\s*(.+)$/);
+      if (!match || !match[1] || !match[2]) {
+        throw new Error(`Invalid test entry format: ${item}`);
+      }
+
+      entries.push({
+        input: match[1],
+        title: match[2].trim(),
+      });
+    } else {
+      throw new Error(`Invalid test entry: ${JSON.stringify(item)}`);
+    }
+  }
+
+  return entries;
+};

package/src/golden-tests/discovery.ts

@@ -0,0 +1,61 @@
+/**
+ * Test scenario discovery
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { Scenario } from "./types.js";
+import { parseConfigYaml } from "./config-parser.js";
+
+/**
+ * Discover all test scenarios by walking the testcases directory (synchronous)
+ */
+export const discoverScenarios = (baseDir: string): readonly Scenario[] => {
+  const scenarios: Scenario[] = [];
+
+  const walk = (dir: string, pathParts: string[]): void => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    // Check if this directory contains config.yaml
+    const hasConfig = entries.some((e) => e.name === "config.yaml");
+
+    if (hasConfig) {
+      // This is a test directory - read config
+      const configPath = path.join(dir, "config.yaml");
+      const configContent = fs.readFileSync(configPath, "utf-8");
+      const testEntries = parseConfigYaml(configContent);
+
+      // Create scenarios for each test entry
+      for (const entry of testEntries) {
+        const inputPath = path.join(dir, entry.input);
+        const baseName = path.basename(entry.input, ".ts");
+        const expectedPath = path.join(dir, `${baseName}.cs`);
+
+        // Verify files exist
+        if (!fs.existsSync(inputPath)) {
+          throw new Error(`Input file not found: ${inputPath}`);
+        }
+        if (!fs.existsSync(expectedPath)) {
+          throw new Error(`Expected file not found: ${expectedPath}`);
+        }
+
+        scenarios.push({
+          pathParts,
+          title: entry.title,
+          inputPath,
+          expectedPath,
+        });
+      }
+    }
+
+    // Recurse into subdirectories
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        walk(path.join(dir, entry.name), [...pathParts, entry.name]);
+      }
+    }
+  };
+
+  walk(baseDir, []);
+  return scenarios;
+};

package/src/golden-tests/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Golden test harness - Public API
+ */
+
+export type { TestEntry, Scenario, DescribeNode } from "./types.js";
+export { parseConfigYaml } from "./config-parser.js";
+export { discoverScenarios } from "./discovery.js";
+export { buildDescribeTree } from "./tree-builder.js";
+export { normalizeCs, runScenario } from "./runner.js";
+export { registerNode } from "./registration.js";

package/src/golden-tests/registration.ts

@@ -0,0 +1,26 @@
+/**
+ * Test registration for Mocha
+ */
+
+import { describe, it } from "mocha";
+import { DescribeNode } from "./types.js";
+import { runScenario } from "./runner.js";
+
+/**
+ * Register describe blocks recursively
+ */
+export const registerNode = (node: DescribeNode): void => {
+  describe(node.name, () => {
+    // Register child describe blocks
+    for (const child of node.children.values()) {
+      registerNode(child);
+    }
+
+    // Register tests at this level
+    for (const scenario of node.tests) {
+      it(scenario.title, async () => {
+        await runScenario(scenario);
+      });
+    }
+  });
+};

package/src/golden-tests/runner.ts

@@ -0,0 +1,131 @@
+/**
+ * Test scenario runner
+ */
+
+import { expect } from "chai";
+import * as fs from "fs";
+import * as path from "path";
+import { compile, buildIr } from "@tsonic/frontend";
+import { emitCSharpFiles } from "../emitter.js";
+import { generateFileHeader } from "../constants.js";
+import { Scenario } from "./types.js";
+
+/**
+ * Normalize C# output for comparison
+ */
+export const normalizeCs = (code: string): string => {
+  return (
+    code
+      .trim()
+      // Normalize line endings
+      .replace(/\r\n/g, "\n")
+      // Remove trailing whitespace
+      .replace(/\s+$/gm, "")
+      // Normalize timestamp line (make comparison timestamp-agnostic)
+      .replace(/\/\/ Generated at: .+/, "// Generated at: TIMESTAMP")
+      // Normalize file path to just filename (strip directory path)
+      .replace(/\/\/ Generated from: .+\/([^/]+)$/, "// Generated from: $1")
+  );
+};
+
+/**
+ * Run a single test scenario
+ */
+export const runScenario = async (scenario: Scenario): Promise<void> => {
+  // Read expected output (without header)
+  const expectedCsBody = fs.readFileSync(scenario.expectedPath, "utf-8");
+
+  // Determine source root (parent of input file)
+  const sourceRoot = path.dirname(scenario.inputPath);
+
+  // Build namespace from path parts (case-preserved, hyphens stripped per spec)
+  // e.g., ['types', 'interfaces'] → 'TestCases.types.interfaces'
+  // Note: pathParts contains directory path only (no filename), so no slicing needed
+  const namespaceParts = scenario.pathParts.map((part) =>
+    part.replace(/-/g, "")
+  ); // Strip hyphens
+  const rootNamespace = ["TestCases", ...namespaceParts].join(".");
+
+  // Step 1: Compile TypeScript → Program
+  // Use standard lib for golden tests (they don't have BCL bindings)
+  const compileResult = compile([scenario.inputPath], {
+    sourceRoot,
+    rootNamespace,
+    useStandardLib: true,
+  });
+
+  if (!compileResult.ok) {
+    // Show diagnostics if compilation failed
+    const errors = compileResult.error.diagnostics
+      .map((d) => `${d.code}: ${d.message}`)
+      .join("\n");
+    throw new Error(`Compilation failed:\n${errors}`);
+  }
+
+  // Step 2: Build IR from Program
+  const irResult = buildIr(compileResult.value.program, {
+    sourceRoot,
+    rootNamespace,
+  });
+
+  if (!irResult.ok) {
+    const errors = irResult.error
+      .map((d) => `${d.code}: ${d.message}`)
+      .join("\n");
+    throw new Error(`IR build failed:\n${errors}`);
+  }
+
+  // Step 3: Emit IR → C#
+  // Note: Don't set entryPointPath - golden tests are NOT entry points
+  const emitResult = emitCSharpFiles(irResult.value, {
+    rootNamespace,
+  });
+
+  if (!emitResult.ok) {
+    const errors = emitResult.errors
+      .map((d) => `${d.code}: ${d.message}`)
+      .join("\n");
+    throw new Error(`Emit failed:\n${errors}`);
+  }
+
+  const csharpFiles = emitResult.files;
+
+  // Find the generated file for our input
+  // The key should be the class name derived from the input file
+  const className = path.basename(scenario.inputPath, ".ts");
+  const generatedKey = Array.from(csharpFiles.keys()).find((key) =>
+    key.endsWith(`${className}.cs`)
+  );
+
+  if (!generatedKey) {
+    throw new Error(
+      `Could not find generated C# file for ${scenario.inputPath}. Available: ${Array.from(csharpFiles.keys()).join(", ")}`
+    );
+  }
+
+  const actualCs = csharpFiles.get(generatedKey);
+  if (!actualCs) {
+    throw new Error(
+      `Generated file key exists but content is missing: ${generatedKey}`
+    );
+  }
+
+  // Generate expected header using shared constant (with TIMESTAMP placeholder)
+  // Use just the filename for comparison (actual files may have full paths)
+  const fileName = path.basename(scenario.inputPath);
+  const expectedHeader = generateFileHeader(fileName, {
+    timestamp: "TIMESTAMP",
+  });
+
+  // Combine header with expected body
+  const expectedCs = expectedHeader + expectedCsBody;
+
+  // Normalize and compare
+  const normalizedActual = normalizeCs(actualCs);
+  const normalizedExpected = normalizeCs(expectedCs);
+
+  expect(normalizedActual).to.equal(
+    normalizedExpected,
+    `C# output mismatch for ${scenario.pathParts.join("/")}`
+  );
+};

package/src/golden-tests/tree-builder.ts

@@ -0,0 +1,43 @@
+/**
+ * Build describe tree structure for nested tests
+ */
+
+import { Scenario, DescribeNode } from "./types.js";
+
+/**
+ * Build a tree structure for nested describe blocks
+ */
+export const buildDescribeTree = (
+  scenarios: readonly Scenario[]
+): DescribeNode | null => {
+  if (scenarios.length === 0) return null;
+
+  const root: DescribeNode = {
+    name: "Golden Tests",
+    children: new Map(),
+    tests: [],
+  };
+
+  for (const scenario of scenarios) {
+    let current = root;
+
+    // Navigate/create tree nodes for each path part
+    for (const part of scenario.pathParts) {
+      let node = current.children.get(part);
+      if (!node) {
+        node = {
+          name: part,
+          children: new Map(),
+          tests: [],
+        };
+        current.children.set(part, node);
+      }
+      current = node;
+    }
+
+    // Add test to the leaf node
+    current.tests.push(scenario);
+  }
+
+  return root;
+};

package/src/golden-tests/types.ts

@@ -0,0 +1,21 @@
+/**
+ * Golden test types
+ */
+
+export type TestEntry = {
+  readonly input: string;
+  readonly title: string;
+};
+
+export type Scenario = {
+  readonly pathParts: readonly string[];
+  readonly title: string;
+  readonly inputPath: string;
+  readonly expectedPath: string;
+};
+
+export type DescribeNode = {
+  readonly name: string;
+  readonly children: Map<string, DescribeNode>;
+  tests: Scenario[];
+};

package/src/golden.test.ts

@@ -0,0 +1,40 @@
+/**
+ * Golden Test Harness for Tsonic Emitter
+ *
+ * Automatically discovers and runs test cases from testcases/ directory.
+ * Each directory with config.yaml defines tests:
+ *   - config.yaml: List of tests (input.ts → expected output)
+ *   - FileName.ts: TypeScript source
+ *   - FileName.cs: Expected C# output
+ */
+
+import * as path from "path";
+import { fileURLToPath } from "url";
+import {
+  discoverScenarios,
+  buildDescribeTree,
+  registerNode,
+} from "./golden-tests/index.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TESTCASES_DIR = path.join(__dirname, "../testcases");
+
+/**
+ * Main test suite setup (synchronous discovery for Mocha compatibility)
+ */
+try {
+  const scenarios = discoverScenarios(TESTCASES_DIR);
+
+  if (scenarios.length === 0) {
+    console.warn("⚠️  No golden test cases found in testcases/");
+  } else {
+    const tree = buildDescribeTree(scenarios);
+    if (tree) {
+      registerNode(tree);
+    }
+  }
+} catch (error) {
+  console.error("❌ Failed to setup golden tests:", error);
+  throw error;
+}