@tsonic/emitter 0.0.1 → 0.0.2

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[];
-};

package/src/hierarchical-bindings.test.ts

@@ -1,258 +0,0 @@
-/**
- * Full pipeline test: TypeScript -> IR -> C#
- * Tests hierarchical bindings end-to-end
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import * as ts from "typescript";
-import {
-  buildIrModule,
-  DotnetMetadataRegistry,
-  BindingRegistry,
-  createDotNetImportResolver,
-} from "@tsonic/frontend";
-import { emitModule } from "./emitter.js";
-
-describe("Hierarchical Bindings - Full Pipeline", () => {
-  it("should compile TypeScript with hierarchical bindings to correct C#", () => {
-    const source = `
-      export function processData() {
-        const arr = [1, 2, 3];
-        const result = systemLinq.enumerable.selectMany(arr, x => [x, x * 2]);
-        return result;
-      }
-    `;
-
-    // Create hierarchical binding manifest
-    const bindings = new BindingRegistry();
-    bindings.addBindings("/test/system-linq.json", {
-      assembly: "System.Linq",
-      namespaces: [
-        {
-          name: "System.Linq",
-          alias: "systemLinq",
-          types: [
-            {
-              name: "Enumerable",
-              alias: "enumerable",
-              kind: "class",
-              members: [
-                {
-                  kind: "method",
-                  name: "SelectMany",
-                  alias: "selectMany",
-                  binding: {
-                    assembly: "System.Linq",
-                    type: "System.Linq.Enumerable",
-                    member: "SelectMany",
-                  },
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    });
-
-    // Create TypeScript program
-    const fileName = "/test/sample.ts";
-    const sourceFile = ts.createSourceFile(
-      fileName,
-      source,
-      ts.ScriptTarget.ES2022,
-      true,
-      ts.ScriptKind.TS
-    );
-
-    const program = ts.createProgram(
-      [fileName],
-      {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.ES2022,
-      },
-      {
-        getSourceFile: (name) => (name === fileName ? sourceFile : undefined),
-        writeFile: () => {},
-        getCurrentDirectory: () => "/test",
-        getDirectories: () => [],
-        fileExists: () => true,
-        readFile: () => source,
-        getCanonicalFileName: (f) => f,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n",
-        getDefaultLibFileName: (_options) => "lib.d.ts",
-      }
-    );
-
-    const testProgram = {
-      program,
-      checker: program.getTypeChecker(),
-      options: { sourceRoot: "/test", rootNamespace: "TestApp", strict: true },
-      sourceFiles: [sourceFile],
-      metadata: new DotnetMetadataRegistry(),
-      bindings,
-      dotnetResolver: createDotNetImportResolver("/test"),
-    };
-
-    // Step 1: Build IR
-    const irResult = buildIrModule(sourceFile, testProgram, {
-      sourceRoot: "/test",
-      rootNamespace: "TestApp",
-    });
-
-    if (!irResult.ok) {
-      throw new Error(
-        `IR build must succeed for full pipeline test: ${JSON.stringify(irResult.error)}`
-      );
-    }
-
-    const irModule = irResult.value;
-
-    // Step 2: Emit C# code
-    const csharpCode = emitModule(irModule);
-
-    // Verify correct CLR member call
-    expect(csharpCode).to.include(
-      "System.Linq.Enumerable.SelectMany",
-      "C# should use full CLR type.member from binding"
-    );
-
-    // Verify using statement was added
-    expect(csharpCode).to.include(
-      "using System.Linq",
-      "C# should include using for assembly"
-    );
-
-    // Verify intermediate TypeScript names are NOT in output
-    expect(csharpCode).to.not.include(
-      "systemLinq",
-      "C# should not contain TS namespace identifier"
-    );
-    expect(csharpCode).to.not.include(
-      "enumerable",
-      "C# should not contain TS type identifier"
-    );
-
-    // Verify function structure (may be void if return type not inferred)
-    expect(csharpCode).to.match(
-      /public static (void|object) processData\(/,
-      "C# should have processData function"
-    );
-  });
-
-  it("should handle multiple hierarchical bindings in same code", () => {
-    const source = `
-      export function multipleBindings() {
-        const a = myLib.typeA.methodA(1);
-        const b = myLib.typeB.methodB("test");
-        return a + b;
-      }
-    `;
-
-    const bindings = new BindingRegistry();
-    bindings.addBindings("/test/mylib.json", {
-      assembly: "MyLib",
-      namespaces: [
-        {
-          name: "MyLib",
-          alias: "myLib",
-          types: [
-            {
-              name: "TypeA",
-              alias: "typeA",
-              kind: "class",
-              members: [
-                {
-                  kind: "method",
-                  name: "MethodA",
-                  alias: "methodA",
-                  binding: {
-                    assembly: "MyLib",
-                    type: "MyLib.TypeA",
-                    member: "MethodA",
-                  },
-                },
-              ],
-            },
-            {
-              name: "TypeB",
-              alias: "typeB",
-              kind: "class",
-              members: [
-                {
-                  kind: "method",
-                  name: "MethodB",
-                  alias: "methodB",
-                  binding: {
-                    assembly: "MyLib",
-                    type: "MyLib.TypeB",
-                    member: "MethodB",
-                  },
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    });
-
-    const fileName = "/test/multi.ts";
-    const sourceFile = ts.createSourceFile(
-      fileName,
-      source,
-      ts.ScriptTarget.ES2022,
-      true
-    );
-
-    const program = ts.createProgram(
-      [fileName],
-      {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.ES2022,
-      },
-      {
-        getSourceFile: (name) => (name === fileName ? sourceFile : undefined),
-        writeFile: () => {},
-        getCurrentDirectory: () => "/test",
-        getDirectories: () => [],
-        fileExists: () => true,
-        readFile: () => source,
-        getCanonicalFileName: (f) => f,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n",
-        getDefaultLibFileName: (_options) => "lib.d.ts",
-      }
-    );
-
-    const testProgram = {
-      program,
-      checker: program.getTypeChecker(),
-      options: { sourceRoot: "/test", rootNamespace: "TestApp", strict: true },
-      sourceFiles: [sourceFile],
-      metadata: new DotnetMetadataRegistry(),
-      bindings,
-      dotnetResolver: createDotNetImportResolver("/test"),
-    };
-
-    const irResult = buildIrModule(sourceFile, testProgram, {
-      sourceRoot: "/test",
-      rootNamespace: "TestApp",
-    });
-
-    if (!irResult.ok) {
-      throw new Error("IR build failed for multiple bindings test");
-    }
-
-    const csharpCode = emitModule(irResult.value);
-
-    // Both CLR calls should be present
-    expect(csharpCode).to.include("MyLib.TypeA.MethodA");
-    expect(csharpCode).to.include("MyLib.TypeB.MethodB");
-
-    // TypeScript identifiers should not appear
-    expect(csharpCode).to.not.include("myLib");
-    expect(csharpCode).to.not.include("typeA");
-    expect(csharpCode).to.not.include("typeB");
-  });
-});