@tsonic/emitter 0.0.1 → 0.0.2

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

package/src/specialization/type-aliases.test.ts

@@ -1,134 +0,0 @@
-/**
- * Tests for Type Aliases
- * Covers spec/16-types-and-interfaces.md §3 - Type Aliases
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Type Aliases (spec/16 §3)", () => {
-  it("should emit structural type alias as sealed class with __Alias suffix", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/types.ts",
-      namespace: "MyApp",
-      className: "types",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "typeAliasDeclaration",
-          name: "Point",
-          typeParameters: undefined,
-          type: {
-            kind: "objectType",
-            members: [
-              {
-                kind: "propertySignature",
-                name: "x",
-                type: { kind: "primitiveType", name: "number" },
-                isOptional: false,
-                isReadonly: false,
-              },
-              {
-                kind: "propertySignature",
-                name: "y",
-                type: { kind: "primitiveType", name: "number" },
-                isOptional: false,
-                isReadonly: false,
-              },
-            ],
-          },
-          isStruct: false,
-          isExported: true,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public sealed class Point__Alias");
-    expect(result).to.include("public double x { get; set; }");
-    expect(result).to.include("public double y { get; set; }");
-  });
-
-  it("should emit non-structural type alias as comment", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/types.ts",
-      namespace: "MyApp",
-      className: "types",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "typeAliasDeclaration",
-          name: "ID",
-          typeParameters: undefined,
-          type: { kind: "primitiveType", name: "number" },
-          isStruct: false,
-          isExported: true,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("// type ID = double");
-  });
-
-  it("should emit recursive type alias with self-reference", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/types.ts",
-      namespace: "MyApp",
-      className: "types",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "typeAliasDeclaration",
-          name: "Node",
-          typeParameters: undefined,
-          type: {
-            kind: "objectType",
-            members: [
-              {
-                kind: "propertySignature",
-                name: "name",
-                type: { kind: "primitiveType", name: "string" },
-                isOptional: false,
-                isReadonly: false,
-              },
-              {
-                kind: "propertySignature",
-                name: "next",
-                type: {
-                  kind: "referenceType",
-                  name: "Node",
-                  typeArguments: [],
-                },
-                isOptional: true,
-                isReadonly: false,
-              },
-            ],
-          },
-          isStruct: false,
-          isExported: true,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public sealed class Node__Alias");
-    expect(result).to.include("public string name { get; set; } = default!;");
-    // Self-reference should be nullable
-    expect(result).to.include("public Node? next { get; set; } = default!;");
-  });
-});

package/src/specialization/types.ts

@@ -1,19 +0,0 @@
-/**
- * Type definitions for specialization system
- */
-
-import {
-  IrFunctionDeclaration,
-  IrClassDeclaration,
-  IrType,
-} from "@tsonic/frontend";
-
-/**
- * Specialization request - tracks a function/class that needs a specialized version
- */
-export type SpecializationRequest = {
-  readonly kind: "function" | "class";
-  readonly name: string;
-  readonly typeArguments: readonly IrType[];
-  readonly declaration: IrFunctionDeclaration | IrClassDeclaration;
-};

package/src/statement-emitter.ts

@@ -1,117 +0,0 @@
-/**
- * Statement Emitter - IR statements to C# code
- * Main dispatcher - delegates to specialized modules
- */
-
-import { IrStatement } from "@tsonic/frontend";
-import { EmitterContext, getIndent } from "./types.js";
-
-// Import statement emitters from specialized modules
-import {
-  emitVariableDeclaration,
-  emitFunctionDeclaration,
-  emitClassDeclaration,
-  emitInterfaceDeclaration,
-  emitEnumDeclaration,
-  emitTypeAliasDeclaration,
-} from "./statements/declarations.js";
-
-import {
-  emitBlockStatement,
-  emitReturnStatement,
-  emitExpressionStatement,
-} from "./statements/blocks.js";
-
-import {
-  emitIfStatement,
-  emitWhileStatement,
-  emitForStatement,
-  emitForOfStatement,
-  emitSwitchStatement,
-  emitTryStatement,
-  emitThrowStatement,
-} from "./statements/control.js";
-
-/**
- * Emit a C# statement from an IR statement
- */
-export const emitStatement = (
-  stmt: IrStatement,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-
-  switch (stmt.kind) {
-    case "variableDeclaration":
-      return emitVariableDeclaration(stmt, context);
-
-    case "functionDeclaration":
-      return emitFunctionDeclaration(stmt, context);
-
-    case "classDeclaration":
-      return emitClassDeclaration(stmt, context);
-
-    case "interfaceDeclaration":
-      return emitInterfaceDeclaration(stmt, context);
-
-    case "enumDeclaration":
-      return emitEnumDeclaration(stmt, context);
-
-    case "typeAliasDeclaration":
-      return emitTypeAliasDeclaration(stmt, context);
-
-    case "blockStatement":
-      return emitBlockStatement(stmt, context);
-
-    case "ifStatement":
-      return emitIfStatement(stmt, context);
-
-    case "whileStatement":
-      return emitWhileStatement(stmt, context);
-
-    // Note: doWhileStatement not in current IR types
-    // case "doWhileStatement":
-    //   return emitDoWhileStatement(stmt, context);
-
-    case "forStatement":
-      return emitForStatement(stmt, context);
-
-    case "forOfStatement":
-      return emitForOfStatement(stmt, context);
-
-    // Note: forInStatement not in current IR types
-    // case "forInStatement":
-    //   return emitForInStatement(stmt, context);
-
-    case "switchStatement":
-      return emitSwitchStatement(stmt, context);
-
-    case "tryStatement":
-      return emitTryStatement(stmt, context);
-
-    case "throwStatement":
-      return emitThrowStatement(stmt, context);
-
-    case "returnStatement":
-      return emitReturnStatement(stmt, context);
-
-    case "breakStatement":
-      return [`${ind}break;`, context];
-
-    case "continueStatement":
-      return [`${ind}continue;`, context];
-
-    case "expressionStatement":
-      return emitExpressionStatement(stmt, context);
-
-    case "emptyStatement":
-      return [`${ind};`, context];
-
-    default:
-      return [`${ind}// TODO: unhandled statement`, context];
-  }
-};
-
-// Re-export commonly used functions for backward compatibility
-export { emitBlockStatement } from "./statements/blocks.js";
-export { emitParameters } from "./statements/classes.js";