@tsonic/emitter 0.0.1 → 0.0.3

package/src/generator.test.ts

@@ -1,193 +0,0 @@
-/**
- * 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

@@ -1,67 +0,0 @@
-/**
- * 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

@@ -1,61 +0,0 @@
-/**
- * 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/registration.ts

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,131 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-/**
- * 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[];
-};