@tsonic/emitter 0.0.1 → 0.0.3

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

package/src/statements/blocks.ts

@@ -1,115 +0,0 @@
-/**
- * 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/inline-types.ts

@@ -1,79 +0,0 @@
-/**
- * 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];
-};

package/src/statements/classes/members/constructors.ts

@@ -1,123 +0,0 @@
-/**
- * Constructor member emission
- */
-
-import { IrClassMember, IrStatement } from "@tsonic/frontend";
-import { EmitterContext, getIndent, indent, dedent } from "../../../types.js";
-import { emitExpression } from "../../../expression-emitter.js";
-import { emitBlockStatement } from "../../blocks.js";
-import { emitParameters } from "../parameters.js";
-
-/**
- * Emit a constructor declaration
- */
-export const emitConstructorMember = (
-  member: IrClassMember & { kind: "constructorDeclaration" },
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  let currentContext = context;
-  const parts: string[] = [];
-
-  // Access modifier
-  const accessibility = member.accessibility ?? "public";
-  parts.push(accessibility);
-
-  // Constructor name (same as class name)
-  const constructorName = context.className ?? "UnknownClass";
-  parts.push(constructorName);
-
-  // Parameters
-  const params = emitParameters(member.parameters, currentContext);
-  currentContext = params[1];
-
-  // Constructor body
-  if (!member.body) {
-    // Abstract or interface constructor without body
-    const signature = parts.join(" ");
-    const code = `${ind}${signature}(${params[0]});`;
-    return [code, currentContext];
-  }
-
-  // Check for super() call - MUST be the first statement if present
-  // C# base() calls execute before the constructor body, so we can't preserve
-  // TypeScript semantics if there are statements before super()
-  const [baseCall, bodyStatements, baseCallContext] = extractSuperCall(
-    member.body.statements,
-    currentContext
-  );
-  currentContext = baseCallContext;
-
-  // Check if super() appears later in the body (not supported)
-  const hasLaterSuperCall = bodyStatements.some(
-    (stmt) =>
-      stmt.kind === "expressionStatement" &&
-      stmt.expression.kind === "call" &&
-      stmt.expression.callee.kind === "identifier" &&
-      stmt.expression.callee.name === "super"
-  );
-
-  if (hasLaterSuperCall) {
-    // TODO: This should be a compile error in the IR builder
-    // For now, emit a comment noting the issue
-    const signature = parts.join(" ");
-    const errorComment = `${ind}// ERROR: super() must be the first statement in constructor`;
-    const code = `${errorComment}\n${ind}${signature}(${params[0]})\n${ind}{\n${ind}    // Constructor body omitted due to error\n${ind}}`;
-    return [code, currentContext];
-  }
-
-  // Emit body without the super() call
-  const bodyContext = indent(currentContext);
-  const modifiedBody: typeof member.body = {
-    ...member.body,
-    statements: bodyStatements,
-  };
-  const [bodyCode, finalContext] = emitBlockStatement(
-    modifiedBody,
-    bodyContext
-  );
-
-  const signature = parts.join(" ");
-  const code = `${ind}${signature}(${params[0]})${baseCall}\n${bodyCode}`;
-
-  return [code, dedent(finalContext)];
-};
-
-/**
- * Extract super() call from first statement if present
- * Returns [baseCall, remainingStatements, context]
- */
-const extractSuperCall = (
-  statements: readonly IrStatement[],
-  context: EmitterContext
-): [string, readonly IrStatement[], EmitterContext] => {
-  let currentContext = context;
-
-  if (statements.length === 0) {
-    return ["", statements, currentContext];
-  }
-
-  const firstStmt = statements[0];
-  if (
-    firstStmt &&
-    firstStmt.kind === "expressionStatement" &&
-    firstStmt.expression.kind === "call" &&
-    firstStmt.expression.callee.kind === "identifier" &&
-    firstStmt.expression.callee.name === "super"
-  ) {
-    // Found super() call as first statement - convert to : base(...)
-    const superCall = firstStmt.expression;
-    const argFrags: string[] = [];
-    for (const arg of superCall.arguments) {
-      const [argFrag, newContext] = emitExpression(arg, currentContext);
-      argFrags.push(argFrag.text);
-      currentContext = newContext;
-    }
-    const baseCall = ` : base(${argFrags.join(", ")})`;
-    // Remove super() call from body statements
-    const remainingStatements = statements.slice(1);
-    return [baseCall, remainingStatements, currentContext];
-  }
-
-  return ["", statements, currentContext];
-};