@tsonic/emitter 0.0.1

package/src/specialization/substitution.ts

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

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

@@ -0,0 +1,19 @@
+/**
+ * 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/specialization-generator.ts

@@ -0,0 +1,23 @@
+/**
+ * Specialization Generator - Generate monomorphized versions of generic declarations
+ * Per spec/15-generics.md §5-6 - Monomorphisation
+ * Main dispatcher - delegates to specialized modules
+ */
+
+// Re-export everything from specialization modules for backward compatibility
+export type { SpecializationRequest } from "./specialization/types.js";
+export { collectSpecializations } from "./specialization/collection.js";
+export { generateSpecializations } from "./specialization/generation.js";
+export {
+  generateSpecializedFunctionName,
+  generateSpecializedClassName,
+} from "./specialization/naming.js";
+export {
+  createSpecializationKey,
+  serializeType,
+} from "./specialization/helpers.js";
+export {
+  substituteType,
+  substituteStatement,
+  substituteExpression,
+} from "./specialization/substitution.js";

package/src/statement-emitter.ts

@@ -0,0 +1,117 @@
+/**
+ * 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";

package/src/statements/blocks.ts

@@ -0,0 +1,115 @@
+/**
+ * Block and simple statement emitters
+ */
+
+import { IrStatement, IrExpression } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../types.js";
+import { emitExpression } from "../expression-emitter.js";
+import { emitStatement } from "../statement-emitter.js";
+
+/**
+ * Emit a block statement
+ */
+export const emitBlockStatement = (
+  stmt: Extract<IrStatement, { kind: "blockStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const statements: string[] = [];
+
+  for (const s of stmt.statements) {
+    const [code, newContext] = emitStatement(s, currentContext);
+    statements.push(code);
+    currentContext = newContext;
+  }
+
+  const bodyCode = statements.join("\n");
+  return [`${ind}{\n${bodyCode}\n${ind}}`, currentContext];
+};
+
+/**
+ * Emit a return statement
+ */
+export const emitReturnStatement = (
+  stmt: Extract<IrStatement, { kind: "returnStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+
+  if (stmt.expression) {
+    const [exprFrag, newContext] = emitExpression(stmt.expression, context);
+    return [`${ind}return ${exprFrag.text};`, newContext];
+  }
+
+  return [`${ind}return;`, context];
+};
+
+/**
+ * Emit yield expression as C# yield return with exchange object pattern
+ *
+ * TypeScript: yield value
+ * C#:
+ *   exchange.Output = value;
+ *   yield return exchange;
+ *
+ * TypeScript: yield* otherGenerator()
+ * C#:
+ *   foreach (var item in OtherGenerator())
+ *     yield return item;
+ */
+export const emitYieldStatement = (
+  expr: Extract<IrExpression, { kind: "yield" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  if (expr.delegate) {
+    // yield* delegation
+    if (expr.expression) {
+      const [delegateFrag, newContext] = emitExpression(
+        expr.expression,
+        currentContext
+      );
+      currentContext = newContext;
+      parts.push(`${ind}foreach (var item in ${delegateFrag.text})`);
+      parts.push(`${ind}    yield return item;`);
+    }
+  } else {
+    // Regular yield
+    if (expr.expression) {
+      const [valueFrag, newContext] = emitExpression(
+        expr.expression,
+        currentContext
+      );
+      currentContext = newContext;
+      parts.push(`${ind}exchange.Output = ${valueFrag.text};`);
+      parts.push(`${ind}yield return exchange;`);
+    } else {
+      // Bare yield (no value)
+      parts.push(`${ind}yield return exchange;`);
+    }
+  }
+
+  return [parts.join("\n"), currentContext];
+};
+
+/**
+ * Emit an expression statement
+ */
+export const emitExpressionStatement = (
+  stmt: Extract<IrStatement, { kind: "expressionStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+
+  // Special handling for yield expressions in generators
+  if (stmt.expression.kind === "yield") {
+    return emitYieldStatement(stmt.expression, context);
+  }
+
+  const [exprFrag, newContext] = emitExpression(stmt.expression, context);
+  return [`${ind}${exprFrag.text};`, newContext];
+};

package/src/statements/classes/helpers.ts

@@ -0,0 +1,9 @@
+/**
+ * Class-related helper functions
+ */
+
+/**
+ * Capitalize first letter of a string (for generating class names from property names)
+ */
+export const capitalize = (str: string): string =>
+  str.charAt(0).toUpperCase() + str.slice(1);

package/src/statements/classes/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Class-related helpers - Public API
+ */
+
+export { capitalize } from "./helpers.js";
+export { emitParameters } from "./parameters.js";
+export { emitClassMember } from "./members.js";
+export { emitInterfaceMemberAsProperty } from "./properties.js";
+export {
+  extractInlineObjectTypes,
+  emitExtractedType,
+  type ExtractedType,
+} from "./inline-types.js";

package/src/statements/classes/inline-types.ts

@@ -0,0 +1,79 @@
+/**
+ * Inline object type extraction and emission
+ */
+
+import { IrInterfaceMember } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent } from "../../types.js";
+import { capitalize } from "./helpers.js";
+import { emitInterfaceMemberAsProperty } from "./properties.js";
+
+/**
+ * Extracted inline object type
+ */
+export type ExtractedType = {
+  readonly className: string;
+  readonly members: readonly IrInterfaceMember[];
+};
+
+/**
+ * Extract inline object types from interface members and generate class declarations
+ */
+export const extractInlineObjectTypes = (
+  members: readonly IrInterfaceMember[]
+): readonly ExtractedType[] => {
+  const extracted: ExtractedType[] = [];
+
+  for (const member of members) {
+    if (
+      member.kind === "propertySignature" &&
+      member.type?.kind === "objectType"
+    ) {
+      // Generate class name from property name (capitalize)
+      const className = capitalize(member.name);
+      extracted.push({
+        className,
+        members: member.type.members,
+      });
+    }
+  }
+
+  return extracted;
+};
+
+/**
+ * Emit an extracted inline object type as a class
+ */
+export const emitExtractedType = (
+  extracted: ExtractedType,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+
+  const parts: string[] = [];
+  parts.push(`${ind}public class ${extracted.className}`);
+  parts.push(`${ind}{`);
+
+  // Emit properties
+  const bodyContext = indent(currentContext);
+  const propertyParts: string[] = [];
+  let bodyCurrentContext = bodyContext;
+
+  for (const member of extracted.members) {
+    const [memberCode, newContext] = emitInterfaceMemberAsProperty(
+      member,
+      bodyCurrentContext
+    );
+    propertyParts.push(memberCode);
+    bodyCurrentContext = newContext;
+  }
+
+  if (propertyParts.length > 0) {
+    parts.push(propertyParts.join("\n"));
+  }
+
+  parts.push(`${ind}}`);
+
+  // Return context at original indent level
+  return [parts.join("\n"), context];
+};