@tsonic/emitter 0.0.1

package/src/specialization/generic-functions.test.ts

@@ -0,0 +1,292 @@
+/**
+ * Tests for Generic Functions
+ * Covers spec/15-generics.md §3-5 - Generic Functions
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Generic Functions (spec/15 §3-5)", () => {
+  it("should emit generic function with single type parameter", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/utils.ts",
+      namespace: "MyApp",
+      className: "utils",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "identity",
+          typeParameters: [
+            {
+              kind: "typeParameter",
+              name: "T",
+              constraint: undefined,
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: false,
+            },
+          ],
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "value" },
+              type: { kind: "referenceType", name: "T", typeArguments: [] },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "referenceType", name: "T", typeArguments: [] },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "returnStatement",
+                expression: { kind: "identifier", name: "value" },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("public static T identity<T>(T value)");
+    expect(result).to.include("return value");
+  });
+
+  it("should emit generic function with multiple type parameters", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/utils.ts",
+      namespace: "MyApp",
+      className: "utils",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "pair",
+          typeParameters: [
+            {
+              kind: "typeParameter",
+              name: "T",
+              constraint: undefined,
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: false,
+            },
+            {
+              kind: "typeParameter",
+              name: "U",
+              constraint: undefined,
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: false,
+            },
+          ],
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "first" },
+              type: { kind: "referenceType", name: "T", typeArguments: [] },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "second" },
+              type: { kind: "referenceType", name: "U", typeArguments: [] },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: {
+            kind: "arrayType",
+            elementType: {
+              kind: "unionType",
+              types: [
+                { kind: "referenceType", name: "T", typeArguments: [] },
+                { kind: "referenceType", name: "U", typeArguments: [] },
+              ],
+            },
+          },
+          body: {
+            kind: "blockStatement",
+            statements: [],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("<T, U>");
+    expect(result).to.include("pair");
+    expect(result).to.include("T first");
+    expect(result).to.include("U second");
+  });
+
+  it("should emit generic function with nominal constraint", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/utils.ts",
+      namespace: "MyApp",
+      className: "utils",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "process",
+          typeParameters: [
+            {
+              kind: "typeParameter",
+              name: "T",
+              constraint: {
+                kind: "referenceType",
+                name: "Comparable",
+                typeArguments: [],
+              },
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: false,
+            },
+          ],
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "item" },
+              type: { kind: "referenceType", name: "T", typeArguments: [] },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "voidType" },
+          body: {
+            kind: "blockStatement",
+            statements: [],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("<T>");
+    expect(result).to.include("where T : Comparable");
+  });
+
+  it("should emit generic function with structural constraint and adapter", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/utils.ts",
+      namespace: "MyApp",
+      className: "utils",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "getId",
+          typeParameters: [
+            {
+              kind: "typeParameter",
+              name: "T",
+              constraint: {
+                kind: "objectType",
+                members: [
+                  {
+                    kind: "propertySignature",
+                    name: "id",
+                    type: { kind: "primitiveType", name: "number" },
+                    isOptional: false,
+                    isReadonly: false,
+                  },
+                ],
+              },
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: true,
+              structuralMembers: [
+                {
+                  kind: "propertySignature",
+                  name: "id",
+                  type: { kind: "primitiveType", name: "number" },
+                  isOptional: false,
+                  isReadonly: false,
+                },
+              ],
+            },
+          ],
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "obj" },
+              type: { kind: "referenceType", name: "T", typeArguments: [] },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "primitiveType", name: "number" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "returnStatement",
+                expression: {
+                  kind: "memberAccess",
+                  object: { kind: "identifier", name: "obj" },
+                  property: "id",
+                  isComputed: false,
+                  isOptional: false,
+                },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should generate adapter interface
+    expect(result).to.include("public interface __Constraint_T");
+    expect(result).to.include("double id { get; }");
+
+    // Should generate adapter wrapper class
+    expect(result).to.include(
+      "public sealed class __Wrapper_T : __Constraint_T"
+    );
+    expect(result).to.include("public double id { get; set; }");
+
+    // Function should reference the constraint
+    expect(result).to.include("where T : __Constraint_T");
+  });
+});

package/src/specialization/helpers.ts

@@ -0,0 +1,39 @@
+/**
+ * Helper functions for specialization (key generation, serialization)
+ */
+
+import { IrType } from "@tsonic/frontend";
+
+/**
+ * Create a unique key for a specialization request
+ */
+export const createSpecializationKey = (
+  name: string,
+  typeArgs: readonly IrType[]
+): string => {
+  // Simple serialization of type arguments for deduplication
+  const typeStrs = typeArgs.map((t) => serializeType(t));
+  return `${name}<${typeStrs.join(",")}>`;
+};
+
+/**
+ * Simple type serialization for deduplication
+ */
+export const serializeType = (type: IrType): string => {
+  switch (type.kind) {
+    case "primitiveType":
+      return type.name;
+    case "referenceType":
+      if (type.typeArguments && type.typeArguments.length > 0) {
+        const args = type.typeArguments.map(serializeType).join(",");
+        return `${type.name}<${args}>`;
+      }
+      return type.name;
+    case "arrayType":
+      return `${serializeType(type.elementType)}[]`;
+    case "literalType":
+      return `literal:${type.value}`;
+    default:
+      return type.kind;
+  }
+};

package/src/specialization/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Specialization system barrel exports
+ */
+
+// Types
+export type { SpecializationRequest } from "./types.js";
+
+// Collection
+export { collectSpecializations } from "./collection.js";
+
+// Generation
+export { generateSpecializations } from "./generation.js";
+
+// Naming
+export {
+  generateSpecializedFunctionName,
+  generateSpecializedClassName,
+} from "./naming.js";
+
+// Helpers
+export { createSpecializationKey, serializeType } from "./helpers.js";
+
+// Substitution
+export {
+  substituteType,
+  substituteStatement,
+  substituteExpression,
+} from "./substitution.js";

package/src/specialization/interfaces.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for Interfaces
+ * Covers spec/16-types-and-interfaces.md §2 - Interfaces
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Interfaces (spec/16 §2)", () => {
+  it("should emit interface as C# class with auto-properties", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/User.ts",
+      namespace: "MyApp",
+      className: "User",
+      isStaticContainer: false,
+      imports: [],
+      body: [
+        {
+          kind: "interfaceDeclaration",
+          name: "User",
+          typeParameters: undefined,
+          extends: [],
+          isStruct: false,
+          members: [
+            {
+              kind: "propertySignature",
+              name: "id",
+              type: { kind: "primitiveType", name: "number" },
+              isOptional: false,
+              isReadonly: false,
+            },
+            {
+              kind: "propertySignature",
+              name: "name",
+              type: { kind: "primitiveType", name: "string" },
+              isOptional: false,
+              isReadonly: false,
+            },
+            {
+              kind: "propertySignature",
+              name: "active",
+              type: { kind: "primitiveType", name: "boolean" },
+              isOptional: true,
+              isReadonly: false,
+            },
+          ],
+          isExported: true,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should emit as C# class, not interface
+    expect(result).to.include("public class User");
+    expect(result).not.to.include("interface User");
+
+    // Should have auto-properties
+    expect(result).to.include("public double id { get; set; }");
+    expect(result).to.include("public string name { get; set; }");
+
+    // Optional property should be nullable
+    expect(result).to.include("public bool? active { get; set; }");
+  });
+
+  it("should emit interface with readonly members", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/Config.ts",
+      namespace: "MyApp",
+      className: "Config",
+      isStaticContainer: false,
+      imports: [],
+      body: [
+        {
+          kind: "interfaceDeclaration",
+          name: "Config",
+          typeParameters: undefined,
+          extends: [],
+          isStruct: false,
+          members: [
+            {
+              kind: "propertySignature",
+              name: "apiUrl",
+              type: { kind: "primitiveType", name: "string" },
+              isOptional: false,
+              isReadonly: true,
+            },
+          ],
+          isExported: true,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Readonly should use private set
+    expect(result).to.include("public string apiUrl { get; }");
+  });
+
+  it("should emit generic interface", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/Result.ts",
+      namespace: "MyApp",
+      className: "Result",
+      isStaticContainer: true, // Changed to true to emit at top level
+      imports: [],
+      body: [
+        {
+          kind: "interfaceDeclaration",
+          name: "Result",
+          typeParameters: [
+            {
+              kind: "typeParameter",
+              name: "T",
+              constraint: undefined,
+              default: undefined,
+              variance: undefined,
+              isStructuralConstraint: false,
+            },
+          ],
+          extends: [],
+          isStruct: false,
+          members: [
+            {
+              kind: "propertySignature",
+              name: "data",
+              type: { kind: "referenceType", name: "T", typeArguments: [] },
+              isOptional: false,
+              isReadonly: false,
+            },
+          ],
+          isExported: true,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Allow for whitespace variations
+    expect(result).to.match(/public\s+class\s+Result\s*<T>/);
+    expect(result).to.include("public T data { get; set; }");
+  });
+});

package/src/specialization/naming.ts

@@ -0,0 +1,34 @@
+/**
+ * Name generation for specialized declarations
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { serializeType } from "./helpers.js";
+
+/**
+ * Generate specialized function name
+ */
+export const generateSpecializedFunctionName = (
+  baseName: string,
+  typeArgs: readonly IrType[]
+): string => {
+  const typeNames = typeArgs.map((t) => {
+    const serialized = serializeType(t);
+    return serialized.replace(/[<>?,\s]/g, "_").replace(/\./g, "_");
+  });
+  return `${baseName}__${typeNames.join("__")}`;
+};
+
+/**
+ * Generate specialized class name
+ */
+export const generateSpecializedClassName = (
+  baseName: string,
+  typeArgs: readonly IrType[]
+): string => {
+  const typeNames = typeArgs.map((t) => {
+    const serialized = serializeType(t);
+    return serialized.replace(/[<>?,\s]/g, "_").replace(/\./g, "_");
+  });
+  return `${baseName}__${typeNames.join("__")}`;
+};