@tsonic/emitter 0.0.1 → 0.0.2

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

package/src/specialization/collection/expressions.ts

@@ -1,184 +0,0 @@
-/**
- * Specialization collection from expressions
- */
-
-import {
-  IrModule,
-  IrExpression,
-  IrFunctionDeclaration,
-  IrClassDeclaration,
-} from "@tsonic/frontend";
-import { SpecializationRequest } from "../types.js";
-import { createSpecializationKey } from "../helpers.js";
-import { collectFromStatement } from "./statements.js";
-
-/**
- * Collect specializations from an expression
- */
-export const collectFromExpression = (
-  expr: IrExpression,
-  requests: SpecializationRequest[],
-  seen: Set<string>,
-  module: IrModule
-): void => {
-  switch (expr.kind) {
-    case "call":
-      // Check if this call requires specialization
-      if (
-        expr.requiresSpecialization &&
-        expr.typeArguments &&
-        expr.typeArguments.length > 0
-      ) {
-        // Get function name from callee
-        if (expr.callee.kind === "identifier") {
-          const funcName = expr.callee.name;
-          const key = createSpecializationKey(funcName, expr.typeArguments);
-
-          if (!seen.has(key)) {
-            seen.add(key);
-
-            // Find the function declaration in the module
-            const funcDecl = module.body.find(
-              (stmt) =>
-                stmt.kind === "functionDeclaration" && stmt.name === funcName
-            ) as IrFunctionDeclaration | undefined;
-
-            if (funcDecl) {
-              requests.push({
-                kind: "function",
-                name: funcName,
-                typeArguments: expr.typeArguments,
-                declaration: funcDecl,
-              });
-            }
-          }
-        }
-      }
-
-      // Recurse into callee and arguments
-      collectFromExpression(expr.callee, requests, seen, module);
-      for (const arg of expr.arguments) {
-        if (arg.kind !== "spread") {
-          collectFromExpression(arg, requests, seen, module);
-        }
-      }
-      break;
-
-    case "new":
-      // Check if this constructor call requires specialization
-      if (
-        expr.requiresSpecialization &&
-        expr.typeArguments &&
-        expr.typeArguments.length > 0
-      ) {
-        if (expr.callee.kind === "identifier") {
-          const className = expr.callee.name;
-          const key = createSpecializationKey(className, expr.typeArguments);
-
-          if (!seen.has(key)) {
-            seen.add(key);
-
-            // Find the class declaration in the module
-            const classDecl = module.body.find(
-              (stmt) =>
-                stmt.kind === "classDeclaration" && stmt.name === className
-            ) as IrClassDeclaration | undefined;
-
-            if (classDecl) {
-              requests.push({
-                kind: "class",
-                name: className,
-                typeArguments: expr.typeArguments,
-                declaration: classDecl,
-              });
-            }
-          }
-        }
-      }
-
-      // Recurse into callee and arguments
-      collectFromExpression(expr.callee, requests, seen, module);
-      for (const arg of expr.arguments) {
-        if (arg.kind !== "spread") {
-          collectFromExpression(arg, requests, seen, module);
-        }
-      }
-      break;
-
-    case "binary":
-    case "logical":
-      collectFromExpression(expr.left, requests, seen, module);
-      collectFromExpression(expr.right, requests, seen, module);
-      break;
-
-    case "unary":
-    case "update":
-    case "await":
-      collectFromExpression(expr.expression, requests, seen, module);
-      break;
-
-    case "assignment":
-      if ("kind" in expr.left) {
-        collectFromExpression(
-          expr.left as IrExpression,
-          requests,
-          seen,
-          module
-        );
-      }
-      collectFromExpression(expr.right, requests, seen, module);
-      break;
-
-    case "conditional":
-      collectFromExpression(expr.condition, requests, seen, module);
-      collectFromExpression(expr.whenTrue, requests, seen, module);
-      collectFromExpression(expr.whenFalse, requests, seen, module);
-      break;
-
-    case "memberAccess":
-      collectFromExpression(expr.object, requests, seen, module);
-      if (typeof expr.property !== "string") {
-        collectFromExpression(expr.property, requests, seen, module);
-      }
-      break;
-
-    case "array":
-      for (const elem of expr.elements) {
-        if (elem === undefined) continue;
-        if ("kind" in elem && elem.kind === "spread") {
-          collectFromExpression(elem.expression, requests, seen, module);
-        } else {
-          collectFromExpression(elem, requests, seen, module);
-        }
-      }
-      break;
-
-    case "object":
-      for (const prop of expr.properties) {
-        if (prop.kind === "property") {
-          if (typeof prop.key !== "string") {
-            collectFromExpression(prop.key, requests, seen, module);
-          }
-          collectFromExpression(prop.value, requests, seen, module);
-        } else if (prop.kind === "spread") {
-          collectFromExpression(prop.expression, requests, seen, module);
-        }
-      }
-      break;
-
-    case "arrowFunction":
-    case "functionExpression":
-      if (typeof expr.body === "object" && "kind" in expr.body) {
-        if (expr.body.kind === "blockStatement") {
-          collectFromStatement(expr.body, requests, seen, module);
-        } else {
-          collectFromExpression(expr.body, requests, seen, module);
-        }
-      }
-      break;
-
-    // Literals, identifiers, etc. don't contain expressions
-    default:
-      break;
-  }
-};

package/src/specialization/collection/orchestrator.ts

@@ -1,25 +0,0 @@
-/**
- * Main specialization collection orchestration
- */
-
-import { IrModule } from "@tsonic/frontend";
-import { SpecializationRequest } from "../types.js";
-import { collectFromStatement } from "./statements.js";
-
-/**
- * Collect all specialization requests from a module
- * Walks the IR tree looking for calls/news with requiresSpecialization flag
- */
-export const collectSpecializations = (
-  module: IrModule
-): readonly SpecializationRequest[] => {
-  const requests: SpecializationRequest[] = [];
-  const seen = new Set<string>(); // Avoid duplicates
-
-  // Walk through all statements and expressions to find specialization needs
-  for (const stmt of module.body) {
-    collectFromStatement(stmt, requests, seen, module);
-  }
-
-  return requests;
-};

package/src/specialization/collection/statements.ts

@@ -1,91 +0,0 @@
-/**
- * Specialization collection from statements
- */
-
-import { IrModule, IrStatement } from "@tsonic/frontend";
-import { SpecializationRequest } from "../types.js";
-import { collectFromExpression } from "./expressions.js";
-
-/**
- * Collect specializations from a statement
- */
-export const collectFromStatement = (
-  stmt: IrStatement,
-  requests: SpecializationRequest[],
-  seen: Set<string>,
-  module: IrModule
-): void => {
-  switch (stmt.kind) {
-    case "expressionStatement":
-      collectFromExpression(stmt.expression, requests, seen, module);
-      break;
-
-    case "variableDeclaration":
-      for (const decl of stmt.declarations) {
-        if (decl.initializer) {
-          collectFromExpression(decl.initializer, requests, seen, module);
-        }
-      }
-      break;
-
-    case "returnStatement":
-      if (stmt.expression) {
-        collectFromExpression(stmt.expression, requests, seen, module);
-      }
-      break;
-
-    case "ifStatement":
-      collectFromExpression(stmt.condition, requests, seen, module);
-      collectFromStatement(stmt.thenStatement, requests, seen, module);
-      if (stmt.elseStatement) {
-        collectFromStatement(stmt.elseStatement, requests, seen, module);
-      }
-      break;
-
-    case "blockStatement":
-      for (const s of stmt.statements) {
-        collectFromStatement(s, requests, seen, module);
-      }
-      break;
-
-    case "whileStatement":
-      collectFromExpression(stmt.condition, requests, seen, module);
-      collectFromStatement(stmt.body, requests, seen, module);
-      break;
-
-    case "forStatement":
-      if (stmt.initializer) {
-        if (stmt.initializer.kind === "variableDeclaration") {
-          collectFromStatement(stmt.initializer, requests, seen, module);
-        } else {
-          collectFromExpression(stmt.initializer, requests, seen, module);
-        }
-      }
-      if (stmt.condition) {
-        collectFromExpression(stmt.condition, requests, seen, module);
-      }
-      if (stmt.update) {
-        collectFromExpression(stmt.update, requests, seen, module);
-      }
-      collectFromStatement(stmt.body, requests, seen, module);
-      break;
-
-    case "functionDeclaration":
-      if (stmt.body) {
-        collectFromStatement(stmt.body, requests, seen, module);
-      }
-      break;
-
-    case "classDeclaration":
-      for (const member of stmt.members) {
-        if (member.kind === "methodDeclaration" && member.body) {
-          collectFromStatement(member.body, requests, seen, module);
-        }
-      }
-      break;
-
-    // Other statement types don't contain expressions
-    default:
-      break;
-  }
-};