@tsonic/emitter 0.0.1 → 0.0.3

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@tsonic/emitter",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "C# code generator for Tsonic compiler",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -18,7 +21,7 @@
     "test:watch": "mocha 'dist/**/*.test.js' --watch"
   },
   "dependencies": {
-    "@tsonic/frontend": "0.0.1"
+    "@tsonic/frontend": "0.0.2"
   },
   "devDependencies": {
     "@types/chai": "5.2.2",

package/scripts/update-golden-tests.ts

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

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

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

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

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

package/src/core/imports.test.ts

@@ -1,83 +0,0 @@
-/**
- * Tests for Import Handling
- * Tests emission of .NET and local imports
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Import Handling", () => {
-  it("should handle .NET imports", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/test.ts",
-      namespace: "MyApp",
-      className: "test",
-      isStaticContainer: true,
-      imports: [
-        {
-          kind: "import",
-          source: "System.IO",
-          isLocal: false,
-          isDotNet: true,
-          specifiers: [],
-          resolvedNamespace: "System.IO",
-        },
-        {
-          kind: "import",
-          source: "System.Text.Json",
-          isLocal: false,
-          isDotNet: true,
-          specifiers: [],
-          resolvedNamespace: "System.Text.Json",
-        },
-      ],
-      body: [],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("using System.IO");
-    expect(result).to.include("using System.Text.Json");
-  });
-
-  it("should NOT emit using directives for local imports", () => {
-    // Local module imports are always emitted as fully-qualified references,
-    // so we don't need using directives for them
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/services/api.ts",
-      namespace: "MyApp.services",
-      className: "api",
-      isStaticContainer: true,
-      imports: [
-        {
-          kind: "import",
-          source: "./auth.ts",
-          isLocal: true,
-          isDotNet: false,
-          specifiers: [],
-        },
-        {
-          kind: "import",
-          source: "../models/User.ts",
-          isLocal: true,
-          isDotNet: false,
-          specifiers: [],
-        },
-      ],
-      body: [],
-      exports: [],
-    };
-
-    const result = emitModule(module, { rootNamespace: "MyApp" });
-
-    // Should NOT include using directives for local modules
-    // (identifiers from local imports are emitted fully-qualified)
-    expect(result).to.not.include("using MyApp.services;");
-    expect(result).to.not.include("using MyApp.models;");
-  });
-});