@tsonic/emitter 0.0.1 → 0.0.3

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");
-  });
-});

package/src/integration.test.ts

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

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