@tsonic/emitter 0.0.1 → 0.0.3

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

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

@@ -1,39 +0,0 @@
-/**
- * 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/interfaces.test.ts

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

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

package/src/specialization/substitution.ts

@@ -1,186 +0,0 @@
-/**
- * Type parameter substitution for specialization
- */
-
-import { IrType, IrStatement, IrExpression } from "@tsonic/frontend";
-
-/**
- * Substitute type parameters in an IR type
- */
-export const substituteType = (
-  type: IrType,
-  substitutions: Map<string, IrType>
-): IrType => {
-  switch (type.kind) {
-    case "referenceType":
-      // Check if this is a type parameter that needs substitution
-      if (substitutions.has(type.name)) {
-        const substituted = substitutions.get(type.name);
-        if (substituted) {
-          return substituted;
-        }
-      }
-
-      // Recursively substitute in type arguments
-      if (type.typeArguments && type.typeArguments.length > 0) {
-        return {
-          ...type,
-          typeArguments: type.typeArguments.map((arg) =>
-            substituteType(arg, substitutions)
-          ),
-        };
-      }
-
-      return type;
-
-    case "arrayType":
-      return {
-        ...type,
-        elementType: substituteType(type.elementType, substitutions),
-      };
-
-    case "functionType":
-      return {
-        ...type,
-        parameters: type.parameters.map((param) => {
-          const substitutedType = param.type
-            ? substituteType(param.type, substitutions)
-            : param.type;
-          return {
-            ...param,
-            type: substitutedType,
-          };
-        }),
-        returnType: type.returnType
-          ? substituteType(type.returnType, substitutions)
-          : type.returnType,
-      };
-
-    case "unionType":
-      return {
-        ...type,
-        types: type.types.map((t) => substituteType(t, substitutions)),
-      };
-
-    case "intersectionType":
-      return {
-        ...type,
-        types: type.types.map((t) => substituteType(t, substitutions)),
-      };
-
-    // Primitive types, literal types, etc. don't need substitution
-    default:
-      return type;
-  }
-};
-
-/**
- * Substitute type parameters in a statement
- */
-export const substituteStatement = (
-  stmt: IrStatement,
-  substitutions: Map<string, IrType>
-): IrStatement => {
-  switch (stmt.kind) {
-    case "blockStatement":
-      return {
-        ...stmt,
-        statements: stmt.statements.map((s) =>
-          substituteStatement(s, substitutions)
-        ),
-      };
-
-    case "returnStatement":
-      return {
-        ...stmt,
-        expression: stmt.expression
-          ? substituteExpression(stmt.expression, substitutions)
-          : undefined,
-      };
-
-    case "expressionStatement":
-      return {
-        ...stmt,
-        expression: substituteExpression(stmt.expression, substitutions),
-      };
-
-    case "variableDeclaration":
-      return {
-        ...stmt,
-        declarations: stmt.declarations.map((decl) => ({
-          ...decl,
-          initializer: decl.initializer
-            ? substituteExpression(decl.initializer, substitutions)
-            : undefined,
-        })),
-      };
-
-    case "ifStatement":
-      return {
-        ...stmt,
-        condition: substituteExpression(stmt.condition, substitutions),
-        thenStatement: substituteStatement(stmt.thenStatement, substitutions),
-        elseStatement: stmt.elseStatement
-          ? substituteStatement(stmt.elseStatement, substitutions)
-          : undefined,
-      };
-
-    // For other statement types, return as-is for now
-    default:
-      return stmt;
-  }
-};
-
-/**
- * Substitute type parameters in an expression
- */
-export const substituteExpression = (
-  expr: IrExpression,
-  substitutions: Map<string, IrType>
-): IrExpression => {
-  switch (expr.kind) {
-    case "call":
-      return {
-        ...expr,
-        callee: substituteExpression(expr.callee, substitutions),
-        arguments: expr.arguments.map((arg) =>
-          arg.kind === "spread"
-            ? {
-                ...arg,
-                expression: substituteExpression(arg.expression, substitutions),
-              }
-            : substituteExpression(arg, substitutions)
-        ),
-        typeArguments: expr.typeArguments
-          ? expr.typeArguments.map((arg) => substituteType(arg, substitutions))
-          : undefined,
-      };
-
-    case "memberAccess":
-      return {
-        ...expr,
-        object: substituteExpression(expr.object, substitutions),
-        property:
-          typeof expr.property === "string"
-            ? expr.property
-            : substituteExpression(expr.property, substitutions),
-      };
-
-    case "binary":
-      return {
-        ...expr,
-        left: substituteExpression(expr.left, substitutions),
-        right: substituteExpression(expr.right, substitutions),
-      };
-
-    case "unary":
-      return {
-        ...expr,
-        expression: substituteExpression(expr.expression, substitutions),
-      };
-
-    // For other expressions, return as-is
-    default:
-      return expr;
-  }
-};