@tsonic/emitter 0.0.1

package/src/hierarchical-bindings.test.ts

@@ -0,0 +1,258 @@
+/**
+ * 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");
+  });
+});

package/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Tsonic Emitter - C# code generator
+ */
+
+export * from "./types.js";
+export * from "./type-emitter.js";
+export * from "./expression-emitter.js";
+export * from "./statement-emitter.js";
+export {
+  emitModule,
+  emitCSharpFile,
+  emitCSharpFiles,
+  EmitResult,
+} from "./emitter.js";

package/src/integration.test.ts

@@ -0,0 +1,303 @@
+/**
+ * End-to-end integration tests for generics implementation
+ * Tests the complete pipeline: TypeScript -> IR -> C#
+ */
+
+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";
+
+/**
+ * Helper to compile TypeScript source to C#
+ */
+const compileToCSharp = (
+  source: string,
+  fileName = "/test/test.ts"
+): string => {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  const compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.NodeNext,
+    strict: true,
+    noEmit: true,
+  };
+
+  const host = ts.createCompilerHost(compilerOptions);
+  const originalGetSourceFile = host.getSourceFile;
+  host.getSourceFile = (
+    name: string,
+    languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions,
+    onError?: (message: string) => void,
+    shouldCreateNewSourceFile?: boolean
+  ) => {
+    if (name === fileName) {
+      return sourceFile;
+    }
+    return originalGetSourceFile.call(
+      host,
+      name,
+      languageVersionOrOptions,
+      onError,
+      shouldCreateNewSourceFile
+    );
+  };
+
+  const tsProgram = ts.createProgram([fileName], compilerOptions, host);
+
+  const tsonicProgram = {
+    program: tsProgram,
+    checker: tsProgram.getTypeChecker(),
+    options: {
+      sourceRoot: "/test",
+      rootNamespace: "Test",
+    },
+    sourceFiles: [sourceFile],
+    metadata: new DotnetMetadataRegistry(),
+    bindings: new BindingRegistry(),
+    dotnetResolver: createDotNetImportResolver("/test"),
+  };
+
+  // Build IR
+  const irResult = buildIrModule(sourceFile, tsonicProgram, {
+    sourceRoot: "/test",
+    rootNamespace: "Test",
+  });
+
+  if (!irResult.ok) {
+    throw new Error(`IR build failed: ${irResult.error.message}`);
+  }
+
+  // Emit C#
+  return emitModule(irResult.value);
+};
+
+describe("End-to-End Integration", () => {
+  describe("Generic Functions", () => {
+    it("should compile generic identity function to C#", () => {
+      const source = `
+        export function identity<T>(value: T): T {
+          return value;
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit generic function signature
+      expect(csharp).to.match(/public\s+static\s+T\s+identity\s*<T>/);
+      expect(csharp).to.include("(T value)");
+      expect(csharp).to.include("return value;");
+    });
+
+    it("should compile generic function with type alias constraint", () => {
+      const source = `
+        type HasId = { id: number };
+
+        export function getId<T extends HasId>(obj: T): number {
+          return obj.id;
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit type alias as class
+      expect(csharp).to.include("class HasId__Alias");
+      expect(csharp).to.match(/double\s+id\s*\{\s*get;\s*set;/);
+
+      // Should use type alias as constraint
+      expect(csharp).to.include("where T : HasId");
+
+      // Should have function
+      expect(csharp).to.match(/public\s+static\s+double\s+getId<T>/);
+    });
+  });
+
+  describe("Interfaces and Type Aliases", () => {
+    it("should compile interface to C# class", () => {
+      const source = `
+        export interface User {
+          id: number;
+          name: string;
+          email?: string;
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit C# class (not interface)
+      expect(csharp).to.match(/public\s+class\s+User/);
+      expect(csharp).not.to.include("interface User");
+
+      // Should have auto-properties
+      expect(csharp).to.match(/public\s+double\s+id\s*\{\s*get;\s*set;/);
+      expect(csharp).to.match(/public\s+string\s+name\s*\{\s*get;\s*set;/);
+
+      // Optional property should be nullable
+      expect(csharp).to.match(/public\s+string\?\s+email\s*\{\s*get;\s*set;/);
+    });
+
+    it("should compile structural type alias to sealed class", () => {
+      const source = `
+        export type Point = {
+          x: number;
+          y: number;
+        };
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit sealed class with __Alias suffix
+      expect(csharp).to.match(/public\s+sealed\s+class\s+Point__Alias/);
+      expect(csharp).to.match(/public\s+double\s+x\s*\{\s*get;\s*set;/);
+      expect(csharp).to.match(/public\s+double\s+y\s*\{\s*get;\s*set;/);
+    });
+
+    it("should compile generic interface", () => {
+      const source = `
+        export interface Result<T> {
+          ok: boolean;
+          value: T;
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit generic class
+      expect(csharp).to.match(/public\s+class\s+Result\s*<T>/);
+      expect(csharp).to.match(/public\s+bool\s+ok/);
+      expect(csharp).to.match(/public\s+T\s+value/);
+    });
+  });
+
+  describe("Generic Classes", () => {
+    it("should compile generic class with methods", () => {
+      const source = `
+        export class Container<T> {
+          constructor(private value: T) {}
+
+          getValue(): T {
+            return this.value;
+          }
+
+          setValue(newValue: T): void {
+            this.value = newValue;
+          }
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit generic class
+      expect(csharp).to.match(/public\s+class\s+Container\s*<T>/);
+
+      // Should have generic methods
+      expect(csharp).to.match(/public\s+T\s+getValue\s*\(\s*\)/);
+      expect(csharp).to.match(
+        /public\s+void\s+setValue\s*\(\s*T\s+newValue\s*\)/
+      );
+    });
+  });
+
+  describe("Combined Features", () => {
+    it("should compile code with multiple generic features", () => {
+      const source = `
+        export interface Repository<T> {
+          items: T[];
+          add(item: T): void;
+          findById(id: number): T | undefined;
+        }
+
+        export class InMemoryRepository<T extends { id: number }> {
+          private items: T[] = [];
+
+          add(item: T): void {
+            this.items.push(item);
+          }
+
+          findById(id: number): T | undefined {
+            return this.items.find(item => item.id === id);
+          }
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should emit Repository as generic class (interfaces become classes)
+      expect(csharp).to.match(/public\s+class\s+Repository\s*<T>/);
+
+      // Should emit InMemoryRepository as generic class with constraint
+      expect(csharp).to.match(/public\s+class\s+InMemoryRepository\s*<T>/);
+      expect(csharp).to.include("where T : __Constraint_T");
+
+      // Should generate constraint adapter
+      expect(csharp).to.match(/public\s+interface\s+__Constraint_T/);
+      expect(csharp).to.match(/double\s+id\s*\{\s*get;\s*\}/);
+    });
+  });
+
+  describe("Full Module Compilation", () => {
+    it("should compile a complete module with all features", () => {
+      const source = `
+        // Type definitions
+        export interface User {
+          id: number;
+          name: string;
+          email?: string;
+        }
+
+        export type UserId = number;
+
+        // Generic repository
+        export class UserRepository {
+          private users: User[] = [];
+
+          add(user: User): void {
+            this.users.push(user);
+          }
+
+          findById(id: UserId): User | undefined {
+            return this.users.find(u => u.id === id);
+          }
+
+          all(): User[] {
+            return this.users;
+          }
+        }
+
+        // Generic utility function
+        export function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
+          return arr.map(fn);
+        }
+      `;
+
+      const csharp = compileToCSharp(source);
+
+      // Should have all type definitions
+      expect(csharp).to.include("class User");
+      expect(csharp).to.include("// type UserId = double"); // number → double in C#
+
+      // Should have the repository class
+      expect(csharp).to.include("class UserRepository");
+
+      // Should have the generic function
+      expect(csharp).to.match(/public\s+static\s+List<U>\s+map\s*<T,\s*U>/);
+
+      // Should have proper namespace structure
+      expect(csharp).to.include("namespace Test");
+      expect(csharp).to.include("public static class test");
+    });
+  });
+});

package/src/specialization/call-site-rewriting.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for Call-Site Rewriting
+ * Covers spec/15-generics.md §5 - Call-Site Rewriting and Monomorphisation
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Call-Site Rewriting (spec/15 §5)", () => {
+  it("should emit call with explicit type arguments", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/main.ts",
+      namespace: "MyApp",
+      className: "main",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "test",
+          parameters: [],
+          returnType: { kind: "voidType" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "expressionStatement",
+                expression: {
+                  kind: "call",
+                  callee: { kind: "identifier", name: "identity" },
+                  arguments: [{ kind: "literal", value: "hello" }],
+                  isOptional: false,
+                  typeArguments: [{ kind: "primitiveType", name: "string" }],
+                  requiresSpecialization: false,
+                },
+              },
+            ],
+          },
+          isExported: false,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("identity<string>(");
+  });
+
+  it("should emit specialized call when requiresSpecialization is true", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/main.ts",
+      namespace: "MyApp",
+      className: "main",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "test",
+          parameters: [],
+          returnType: { kind: "voidType" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "expressionStatement",
+                expression: {
+                  kind: "call",
+                  callee: { kind: "identifier", name: "process" },
+                  arguments: [{ kind: "literal", value: "data" }],
+                  isOptional: false,
+                  typeArguments: [{ kind: "primitiveType", name: "string" }],
+                  requiresSpecialization: true,
+                },
+              },
+            ],
+          },
+          isExported: false,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should generate specialized name
+    expect(result).to.include("process__string(");
+    expect(result).not.to.include("process<string>(");
+  });
+});