@tsonic/emitter 0.0.1

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tsonic/emitter",
+  "version": "0.0.1",
+  "description": "C# code generator for Tsonic compiler",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "test": "mocha 'dist/**/*.test.js'",
+    "test:watch": "mocha 'dist/**/*.test.js' --watch"
+  },
+  "dependencies": {
+    "@tsonic/frontend": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/chai": "5.2.2",
+    "@types/mocha": "10.0.10",
+    "@types/node": "20.14.0",
+    "chai": "5.3.3",
+    "mocha": "11.7.2",
+    "yaml": "^2.8.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/update-golden-tests.ts

@@ -0,0 +1,119 @@
+/**
+ * Update golden test expected files
+ * Run with: npx tsx scripts/update-golden-tests.ts
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { compile, buildIr } from "@tsonic/frontend";
+import { emitCSharpFiles } from "../src/emitter.js";
+import { parseConfigYaml } from "../src/golden-tests/config-parser.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TESTCASES_DIR = path.join(__dirname, "../testcases");
+
+interface TestEntry {
+  input: string;
+  title: string;
+}
+
+const walkDir = (dir: string, pathParts: string[] = []): void => {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const hasConfig = entries.some((e) => e.name === "config.yaml");
+
+  if (hasConfig) {
+    const configPath = path.join(dir, "config.yaml");
+    const configContent = fs.readFileSync(configPath, "utf-8");
+    const testEntries = parseConfigYaml(configContent);
+
+    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`);
+
+      console.log(`Updating: ${pathParts.join("/")}/${baseName}`);
+
+      try {
+        // Build namespace from path parts
+        const namespaceParts = pathParts.map((part) => part.replace(/-/g, ""));
+        const rootNamespace = ["TestCases", ...namespaceParts].join(".");
+        const sourceRoot = path.dirname(inputPath);
+
+        // Compile
+        const compileResult = compile([inputPath], {
+          sourceRoot,
+          rootNamespace,
+          useStandardLib: true,
+        });
+
+        if (!compileResult.ok) {
+          console.error(`  ERROR: Compilation failed`);
+          continue;
+        }
+
+        // Build IR
+        const irResult = buildIr(compileResult.value.program, {
+          sourceRoot,
+          rootNamespace,
+        });
+
+        if (!irResult.ok) {
+          console.error(`  ERROR: IR build failed`);
+          continue;
+        }
+
+        // Emit C#
+        const emitResult = emitCSharpFiles(irResult.value, { rootNamespace });
+
+        if (!emitResult.ok) {
+          console.error(`  ERROR: Emit failed`);
+          for (const err of emitResult.errors) {
+            console.error(`    ${err.code}: ${err.message}`);
+          }
+          continue;
+        }
+
+        const csharpFiles = emitResult.files;
+
+        // Find the generated file
+        const className = baseName;
+        const generatedKey = Array.from(csharpFiles.keys()).find((key) =>
+          key.endsWith(`${className}.cs`)
+        );
+
+        if (!generatedKey) {
+          console.error(`  ERROR: No generated file found`);
+          continue;
+        }
+
+        const fullOutput = csharpFiles.get(generatedKey)!;
+
+        // Strip the header (first 4 lines: Generated from, Generated at, WARNING, blank)
+        const lines = fullOutput.split("\n");
+        const bodyStartIndex = lines.findIndex(
+          (line, i) => i > 0 && line.startsWith("using")
+        );
+        const body = lines.slice(bodyStartIndex).join("\n");
+
+        // Write to expected file
+        fs.writeFileSync(expectedPath, body);
+        console.log(`  OK: ${expectedPath}`);
+      } catch (err) {
+        console.error(`  ERROR: ${err}`);
+      }
+    }
+  }
+
+  // Recurse into subdirectories
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      walkDir(path.join(dir, entry.name), [...pathParts, entry.name]);
+    }
+  }
+};
+
+console.log("Updating golden test expected files...\n");
+walkDir(TESTCASES_DIR);
+console.log("\nDone!");

package/src/adapter-generator.ts

@@ -0,0 +1,112 @@
+/**
+ * Adapter Generator - Generate C# adapters for structural constraints
+ * Per spec/15-generics.md §4 - Structural Constraints & Adapters
+ */
+
+import { IrTypeParameter } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent } from "./types.js";
+import { emitType } from "./type-emitter.js";
+
+/**
+ * Generate adapter interface and wrapper class for a structural constraint
+ *
+ * Example:
+ * Input: T extends { id: number; name: string }
+ * Output:
+ *   interface __Constraint_T {
+ *     double id { get; }
+ *     string name { get; }
+ *   }
+ *
+ *   sealed class __Wrapper_T : __Constraint_T {
+ *     public double id { get; set; }
+ *     public string name { get; set; }
+ *   }
+ */
+export const generateStructuralAdapter = (
+  typeParam: IrTypeParameter,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  if (!typeParam.isStructuralConstraint || !typeParam.structuralMembers) {
+    return ["", context];
+  }
+
+  const ind = getIndent(context);
+  const bodyInd = getIndent(indent(context));
+  const parts: string[] = [];
+  let currentContext = context;
+
+  const interfaceName = `__Constraint_${typeParam.name}`;
+  const wrapperName = `__Wrapper_${typeParam.name}`;
+
+  // Generate interface
+  parts.push(`${ind}public interface ${interfaceName}`);
+  parts.push(`${ind}{`);
+
+  for (const member of typeParam.structuralMembers) {
+    if (member.kind === "propertySignature") {
+      const [memberType, newContext] = emitType(member.type, currentContext);
+      currentContext = newContext;
+
+      const optional = member.isOptional ? "?" : "";
+      parts.push(`${bodyInd}${memberType}${optional} ${member.name} { get; }`);
+    }
+  }
+
+  parts.push(`${ind}}`);
+  parts.push(""); // Blank line
+
+  // Generate wrapper class
+  parts.push(`${ind}public sealed class ${wrapperName} : ${interfaceName}`);
+  parts.push(`${ind}{`);
+
+  for (const member of typeParam.structuralMembers) {
+    if (member.kind === "propertySignature") {
+      const [memberType, newContext] = emitType(member.type, currentContext);
+      currentContext = newContext;
+
+      const optional = member.isOptional ? "?" : "";
+      parts.push(
+        `${bodyInd}public ${memberType}${optional} ${member.name} { get; set; }`
+      );
+    }
+  }
+
+  parts.push(`${ind}}`);
+
+  return [parts.join("\n"), currentContext];
+};
+
+/**
+ * Generate all structural adapters for a set of type parameters
+ */
+export const generateStructuralAdapters = (
+  typeParams: readonly IrTypeParameter[] | undefined,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  if (!typeParams || typeParams.length === 0) {
+    return ["", context];
+  }
+
+  const adapters: string[] = [];
+  let currentContext = context;
+
+  for (const tp of typeParams) {
+    if (tp.isStructuralConstraint && tp.structuralMembers) {
+      const [adapterCode, newContext] = generateStructuralAdapter(
+        tp,
+        currentContext
+      );
+      if (adapterCode) {
+        adapters.push(adapterCode);
+        currentContext = newContext;
+      }
+    }
+  }
+
+  if (adapters.length === 0) {
+    return ["", context];
+  }
+
+  return [adapters.join("\n\n"), currentContext];
+};

package/src/array.test.ts

@@ -0,0 +1,301 @@
+/**
+ * Tests for array emission
+ * Verifies Tsonic.JSRuntime extension methods usage and JavaScript semantics
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "./emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Array Emission", () => {
+  it("should emit basic array literal with correct type", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/arrays.ts",
+      namespace: "Test",
+      className: "arrays",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "numbers" },
+              type: {
+                kind: "referenceType",
+                name: "Array",
+                typeArguments: [{ kind: "primitiveType", name: "number" }],
+              },
+              initializer: {
+                kind: "array",
+                elements: [
+                  { kind: "literal", value: 1 },
+                  { kind: "literal", value: 2 },
+                  { kind: "literal", value: 3 },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Integer literals create List<int> - C# infers type from literal values
+    // Uses global:: FQN for unambiguous resolution
+    expect(code).to.include(
+      "new global::System.Collections.Generic.List<int> { 1, 2, 3 }"
+    );
+    // No using statements - all types use global:: FQN
+    expect(code).not.to.include("using System.Collections.Generic");
+  });
+
+  it("should emit sparse array with holes", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/sparse.ts",
+      namespace: "Test",
+      className: "sparse",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "sparse" },
+              type: {
+                kind: "referenceType",
+                name: "Array",
+                typeArguments: [{ kind: "primitiveType", name: "number" }],
+              },
+              initializer: {
+                kind: "array",
+                elements: [
+                  { kind: "literal", value: 1 },
+                  undefined, // hole
+                  { kind: "literal", value: 3 },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should handle sparse array with default - integer literals create List<int>
+    expect(code).to.include(
+      "new global::System.Collections.Generic.List<int> { 1, default, 3 }"
+    );
+  });
+
+  it("should emit array with string elements", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/strings.ts",
+      namespace: "Test",
+      className: "strings",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "words" },
+              type: {
+                kind: "referenceType",
+                name: "Array",
+                typeArguments: [{ kind: "primitiveType", name: "string" }],
+              },
+              initializer: {
+                kind: "array",
+                elements: [
+                  { kind: "literal", value: "hello" },
+                  { kind: "literal", value: "world" },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should use string type parameter
+    expect(code).to.include(
+      "new global::System.Collections.Generic.List<string>"
+    );
+    expect(code).to.include('"hello", "world"');
+  });
+
+  it("should emit empty array", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/empty.ts",
+      namespace: "Test",
+      className: "empty",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "empty" },
+              type: {
+                kind: "referenceType",
+                name: "Array",
+                typeArguments: [{ kind: "primitiveType", name: "number" }],
+              },
+              initializer: {
+                kind: "array",
+                elements: [],
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should create empty array
+    expect(code).to.include(
+      "new global::System.Collections.Generic.List<double>()"
+    );
+  });
+
+  it("should emit array method calls correctly", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/methods.ts",
+      namespace: "Test",
+      className: "methods",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "arr" },
+              initializer: {
+                kind: "array",
+                elements: [
+                  { kind: "literal", value: 1 },
+                  { kind: "literal", value: 2 },
+                ],
+              },
+            },
+          ],
+        },
+        {
+          kind: "expressionStatement",
+          expression: {
+            kind: "call",
+            callee: {
+              kind: "memberAccess",
+              object: { kind: "identifier", name: "arr" },
+              property: "push",
+              isComputed: false,
+              isOptional: false,
+            },
+            arguments: [{ kind: "literal", value: 3 }],
+            isOptional: false,
+          },
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should call push method on array instance - C# implicitly converts int to double
+    expect(code).to.include("arr.push(3)");
+  });
+
+  it("should handle array element access", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/access.ts",
+      namespace: "Test",
+      className: "access",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "arr" },
+              initializer: {
+                kind: "array",
+                elements: [{ kind: "literal", value: 10 }],
+              },
+            },
+          ],
+        },
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "first" },
+              initializer: {
+                kind: "memberAccess",
+                object: {
+                  kind: "identifier",
+                  name: "arr",
+                  inferredType: {
+                    kind: "arrayType",
+                    elementType: { kind: "primitiveType", name: "number" },
+                  },
+                },
+                property: { kind: "literal", value: 0 },
+                isComputed: true,
+                isOptional: false,
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should use static helper for array access with global:: prefix
+    expect(code).to.include("global::Tsonic.Runtime.Array.get(arr, 0)");
+  });
+});

package/src/constants.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared constants for the Tsonic emitter
+ */
+
+/**
+ * Generate standard file header for emitted C# files
+ *
+ * @param filePath - Source TypeScript file path
+ * @param options - Header generation options
+ * @returns Multi-line header string with trailing newline
+ */
+export const generateFileHeader = (
+  filePath: string,
+  options: {
+    readonly includeTimestamp?: boolean;
+    readonly timestamp?: string;
+  } = {}
+): string => {
+  const lines: string[] = [];
+
+  lines.push(`// Generated from: ${filePath}`);
+
+  if (options.includeTimestamp ?? true) {
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    lines.push(`// Generated at: ${timestamp}`);
+  }
+
+  lines.push("// WARNING: Do not modify this file manually");
+  lines.push("");
+
+  return lines.join("\n");
+};

package/src/core/exports.ts

@@ -0,0 +1,36 @@
+/**
+ * Export handling
+ */
+
+import { IrExport } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../types.js";
+import { emitExpression } from "../expression-emitter.js";
+
+/**
+ * Emit an export declaration
+ */
+export const emitExport = (
+  exp: IrExport,
+  context: EmitterContext
+): [string | null, EmitterContext] => {
+  switch (exp.kind) {
+    case "named":
+      // Named exports are handled by marking declarations as public
+      return [null, context];
+
+    case "default": {
+      // Default exports need special handling
+      // For MVP, we'll emit a comment
+      const [exprFrag, newContext] = emitExpression(exp.expression, context);
+      const ind = getIndent(context);
+      return [`${ind}// Default export: ${exprFrag.text}`, newContext];
+    }
+
+    case "declaration":
+      // Export declarations are already handled in the body
+      return [null, context];
+
+    default:
+      return [null, context];
+  }
+};