@tsonic/emitter 0.0.1

package/src/statements/control/exceptions.ts

@@ -0,0 +1,59 @@
+/**
+ * Exception handling emitters (try, throw)
+ */
+
+import { IrStatement } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+import { emitBlockStatement } from "../blocks.js";
+
+/**
+ * Emit a try statement
+ */
+export const emitTryStatement = (
+  stmt: Extract<IrStatement, { kind: "tryStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const [tryBlock, tryContext] = emitBlockStatement(stmt.tryBlock, context);
+
+  let code = `${ind}try\n${tryBlock}`;
+  let currentContext = tryContext;
+
+  if (stmt.catchClause) {
+    const param =
+      stmt.catchClause.parameter?.kind === "identifierPattern"
+        ? stmt.catchClause.parameter.name
+        : "ex";
+
+    const [catchBlock, catchContext] = emitBlockStatement(
+      stmt.catchClause.body,
+      currentContext
+    );
+    code += `\n${ind}catch (Exception ${param})\n${catchBlock}`;
+    currentContext = catchContext;
+  }
+
+  if (stmt.finallyBlock) {
+    const [finallyBlock, finallyContext] = emitBlockStatement(
+      stmt.finallyBlock,
+      currentContext
+    );
+    code += `\n${ind}finally\n${finallyBlock}`;
+    currentContext = finallyContext;
+  }
+
+  return [code, currentContext];
+};
+
+/**
+ * Emit a throw statement
+ */
+export const emitThrowStatement = (
+  stmt: Extract<IrStatement, { kind: "throwStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const [exprFrag, newContext] = emitExpression(stmt.expression, context);
+  return [`${ind}throw ${exprFrag.text};`, newContext];
+};

package/src/statements/control/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Control flow statement emitters - Public API
+ */
+
+export {
+  emitWhileStatement,
+  emitForStatement,
+  emitForOfStatement,
+} from "./loops.js";
+export { emitIfStatement, emitSwitchStatement } from "./conditionals.js";
+export { emitTryStatement, emitThrowStatement } from "./exceptions.js";

package/src/statements/control/loops.ts

@@ -0,0 +1,250 @@
+/**
+ * Loop statement emitters (while, for, for-of)
+ */
+
+import { IrStatement, IrExpression } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent, dedent } from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+import { emitStatement } from "../../statement-emitter.js";
+
+/**
+ * Information about a canonical integer loop counter.
+ * Canonical form: `for (let i = 0; i < n; i++)`
+ */
+type CanonicalIntLoop = {
+  readonly varName: string;
+  readonly initialValue: number;
+};
+
+/**
+ * Detect if a for-loop has a canonical integer loop counter pattern.
+ *
+ * Canonical patterns:
+ * - Initializer: `let i = 0` (or any integer literal)
+ * - Update: `i++`, `++i`, `i += 1`, `i = i + 1`
+ *
+ * Returns the variable name and initial value if canonical, undefined otherwise.
+ */
+const detectCanonicalIntLoop = (
+  stmt: Extract<IrStatement, { kind: "forStatement" }>
+): CanonicalIntLoop | undefined => {
+  const { initializer, update } = stmt;
+
+  // Check initializer: must be `let varName = <integer literal>`
+  if (!initializer || initializer.kind !== "variableDeclaration") {
+    return undefined;
+  }
+
+  if (initializer.declarationKind !== "let") {
+    return undefined;
+  }
+
+  if (initializer.declarations.length !== 1) {
+    return undefined;
+  }
+
+  const decl = initializer.declarations[0];
+  if (!decl || decl.name.kind !== "identifierPattern") {
+    return undefined;
+  }
+
+  const varName = decl.name.name;
+
+  // Check initializer value: must be an integer literal
+  const declInit = decl.initializer;
+  if (!declInit || declInit.kind !== "literal") {
+    return undefined;
+  }
+
+  const initValue = declInit.value;
+  if (typeof initValue !== "number" || !Number.isInteger(initValue)) {
+    return undefined;
+  }
+
+  // Check update: must be i++, ++i, i += 1, or i = i + 1
+  if (!update) {
+    return undefined;
+  }
+
+  if (!isIntegerIncrement(update, varName)) {
+    return undefined;
+  }
+
+  return { varName, initialValue: initValue };
+};
+
+/**
+ * Check if an expression is an integer increment of a variable.
+ * Matches: i++, ++i, i += 1, i = i + 1
+ */
+const isIntegerIncrement = (expr: IrExpression, varName: string): boolean => {
+  // i++ or ++i
+  if (expr.kind === "update") {
+    if (expr.operator !== "++") {
+      return false;
+    }
+    if (expr.expression.kind !== "identifier") {
+      return false;
+    }
+    return expr.expression.name === varName;
+  }
+
+  // i += 1 or i = i + 1
+  if (expr.kind === "assignment") {
+    if (expr.left.kind !== "identifier" || expr.left.name !== varName) {
+      return false;
+    }
+
+    // i += 1
+    if (expr.operator === "+=") {
+      if (expr.right.kind !== "literal") {
+        return false;
+      }
+      return expr.right.value === 1;
+    }
+
+    // i = i + 1
+    if (expr.operator === "=") {
+      if (expr.right.kind !== "binary" || expr.right.operator !== "+") {
+        return false;
+      }
+      const binExpr = expr.right;
+      // Check i + 1 or 1 + i
+      const isVarPlusOne =
+        binExpr.left.kind === "identifier" &&
+        binExpr.left.name === varName &&
+        binExpr.right.kind === "literal" &&
+        binExpr.right.value === 1;
+      const isOnePlusVar =
+        binExpr.left.kind === "literal" &&
+        binExpr.left.value === 1 &&
+        binExpr.right.kind === "identifier" &&
+        binExpr.right.name === varName;
+      return isVarPlusOne || isOnePlusVar;
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Emit a while statement
+ */
+export const emitWhileStatement = (
+  stmt: Extract<IrStatement, { kind: "whileStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const [condFrag, condContext] = emitExpression(stmt.condition, context);
+
+  const [bodyCode, bodyContext] = emitStatement(stmt.body, indent(condContext));
+
+  const code = `${ind}while (${condFrag.text})\n${bodyCode}`;
+  return [code, dedent(bodyContext)];
+};
+
+/**
+ * Emit a for statement
+ *
+ * Special handling for canonical integer loop counters:
+ * `for (let i = 0; i < n; i++)` emits as `for (int i = 0; ...)` in C#.
+ * This avoids the double→int conversion cost when using loop variables
+ * as CLR indexers (e.g., list[i]).
+ */
+export const emitForStatement = (
+  stmt: Extract<IrStatement, { kind: "forStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+
+  // Check for canonical integer loop pattern
+  const canonicalLoop = detectCanonicalIntLoop(stmt);
+
+  // Initializer
+  let init = "";
+  if (stmt.initializer) {
+    if (canonicalLoop) {
+      // Canonical integer loop: emit `int varName = value` directly
+      init = `int ${canonicalLoop.varName} = ${canonicalLoop.initialValue}`;
+    } else if (stmt.initializer.kind === "variableDeclaration") {
+      const [initCode, newContext] = emitStatement(
+        stmt.initializer,
+        currentContext
+      );
+      currentContext = newContext;
+      // Strip trailing semicolon from variable declaration
+      init = initCode.trim().replace(/;$/, "");
+    } else {
+      const [initFrag, newContext] = emitExpression(
+        stmt.initializer,
+        currentContext
+      );
+      currentContext = newContext;
+      init = initFrag.text;
+    }
+  }
+
+  // Condition
+  let cond = "";
+  if (stmt.condition) {
+    const [condFrag, newContext] = emitExpression(
+      stmt.condition,
+      currentContext
+    );
+    currentContext = newContext;
+    cond = condFrag.text;
+  }
+
+  // Update
+  let update = "";
+  if (stmt.update) {
+    const [updateFrag, newContext] = emitExpression(
+      stmt.update,
+      currentContext
+    );
+    currentContext = newContext;
+    update = updateFrag.text;
+  }
+
+  // Body - if canonical loop, add the var to intLoopVars so indexers don't cast
+  let bodyContext: EmitterContext;
+  if (canonicalLoop) {
+    const existingIntVars = currentContext.intLoopVars ?? new Set<string>();
+    const newIntVars = new Set([...existingIntVars, canonicalLoop.varName]);
+    const contextWithIntVar = {
+      ...indent(currentContext),
+      intLoopVars: newIntVars,
+    };
+    const [code, ctx] = emitStatement(stmt.body, contextWithIntVar);
+    // Remove the var from intLoopVars after body (restore previous scope)
+    bodyContext = { ...ctx, intLoopVars: existingIntVars };
+    const finalCode = `${ind}for (${init}; ${cond}; ${update})\n${code}`;
+    return [finalCode, dedent(bodyContext)];
+  }
+
+  const [bodyCode, ctx] = emitStatement(stmt.body, indent(currentContext));
+  bodyContext = ctx;
+
+  const code = `${ind}for (${init}; ${cond}; ${update})\n${bodyCode}`;
+  return [code, dedent(bodyContext)];
+};
+
+/**
+ * Emit a for-of statement
+ */
+export const emitForOfStatement = (
+  stmt: Extract<IrStatement, { kind: "forOfStatement" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const [exprFrag, exprContext] = emitExpression(stmt.expression, context);
+
+  const [bodyCode, bodyContext] = emitStatement(stmt.body, indent(exprContext));
+
+  // Use foreach in C#
+  const varName =
+    stmt.variable.kind === "identifierPattern" ? stmt.variable.name : "item";
+  const code = `${ind}foreach (var ${varName} in ${exprFrag.text})\n${bodyCode}`;
+  return [code, dedent(bodyContext)];
+};

package/src/statements/control.ts

@@ -0,0 +1,14 @@
+/**
+ * Control flow statement emitters (if, while, for, switch, try, throw)
+ * Main dispatcher - re-exports from control/ subdirectory
+ */
+
+export {
+  emitIfStatement,
+  emitWhileStatement,
+  emitForStatement,
+  emitForOfStatement,
+  emitSwitchStatement,
+  emitTryStatement,
+  emitThrowStatement,
+} from "./control/index.js";

package/src/statements/declarations/classes.ts

@@ -0,0 +1,89 @@
+/**
+ * Class declaration emission
+ */
+
+import { IrStatement } from "@tsonic/frontend";
+import {
+  EmitterContext,
+  getIndent,
+  indent,
+  withClassName,
+} from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+import { emitType, emitTypeParameters } from "../../type-emitter.js";
+import { emitClassMember } from "../classes.js";
+
+/**
+ * Emit a class declaration
+ */
+export const emitClassDeclaration = (
+  stmt: Extract<IrStatement, { kind: "classDeclaration" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  // Access modifiers
+  const accessibility = stmt.isExported ? "public" : "internal";
+  parts.push(accessibility);
+
+  // Emit struct or class based on isStruct flag
+  parts.push(stmt.isStruct ? "struct" : "class");
+  parts.push(stmt.name);
+
+  // Type parameters
+  const [typeParamsStr, whereClauses, typeParamContext] = emitTypeParameters(
+    stmt.typeParameters,
+    currentContext
+  );
+  currentContext = typeParamContext;
+
+  // Base class and interfaces
+  const heritage: string[] = [];
+
+  // Handle superclass (extends clause)
+  if (stmt.superClass) {
+    const [superClassFrag, newContext] = emitExpression(
+      stmt.superClass,
+      currentContext
+    );
+    currentContext = newContext;
+    heritage.push(superClassFrag.text);
+  }
+
+  // Handle interfaces (implements clause)
+  if (stmt.implements && stmt.implements.length > 0) {
+    for (const iface of stmt.implements) {
+      const [ifaceType, newContext] = emitType(iface, currentContext);
+      currentContext = newContext;
+      heritage.push(ifaceType);
+    }
+  }
+
+  const heritageStr = heritage.length > 0 ? ` : ${heritage.join(", ")}` : "";
+  const whereClause =
+    whereClauses.length > 0
+      ? `\n${ind}    ${whereClauses.join(`\n${ind}    `)}`
+      : "";
+
+  // Class body
+  const baseContext = withClassName(indent(currentContext), stmt.name);
+  // Only set hasSuperClass flag if there's actually a superclass (for inheritance)
+  const bodyContext = stmt.superClass
+    ? { ...baseContext, hasSuperClass: true }
+    : baseContext;
+  const members: string[] = [];
+
+  for (const member of stmt.members) {
+    const [memberCode, newContext] = emitClassMember(member, bodyContext);
+    members.push(memberCode);
+    currentContext = newContext;
+  }
+
+  const signature = parts.join(" ");
+  const memberCode = members.join("\n\n");
+  const code = `${ind}${signature}${typeParamsStr}${heritageStr}${whereClause}\n${ind}{\n${memberCode}\n${ind}}`;
+
+  return [code, currentContext];
+};

package/src/statements/declarations/enums.ts

@@ -0,0 +1,32 @@
+/**
+ * Enum declaration emission
+ */
+
+import { IrStatement } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent } from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+
+/**
+ * Emit an enum declaration
+ */
+export const emitEnumDeclaration = (
+  stmt: Extract<IrStatement, { kind: "enumDeclaration" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const memberInd = getIndent(indent(context));
+
+  const accessibility = stmt.isExported ? "public" : "internal";
+  const members = stmt.members
+    .map((member) => {
+      if (member.initializer) {
+        const [initFrag] = emitExpression(member.initializer, context);
+        return `${memberInd}${member.name} = ${initFrag.text}`;
+      }
+      return `${memberInd}${member.name}`;
+    })
+    .join(",\n");
+
+  const code = `${ind}${accessibility} enum ${stmt.name}\n${ind}{\n${members}\n${ind}}`;
+  return [code, context];
+};

package/src/statements/declarations/functions.ts

@@ -0,0 +1,147 @@
+/**
+ * Function declaration emission
+ */
+
+import { IrStatement } from "@tsonic/frontend";
+import {
+  EmitterContext,
+  getIndent,
+  indent,
+  withAsync,
+  withStatic,
+} from "../../types.js";
+import { emitType, emitTypeParameters } from "../../type-emitter.js";
+import { emitBlockStatement } from "../blocks.js";
+import { emitParameters } from "../classes.js";
+
+/**
+ * Emit a function declaration
+ */
+export const emitFunctionDeclaration = (
+  stmt: Extract<IrStatement, { kind: "functionDeclaration" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  // Access modifiers
+  const accessibility = stmt.isExported ? "public" : "private";
+  parts.push(accessibility);
+
+  if (context.isStatic) {
+    parts.push("static");
+  }
+
+  if (stmt.isAsync && !stmt.isGenerator) {
+    parts.push("async");
+  }
+
+  // Return type
+  if (stmt.isGenerator) {
+    // Generator functions return IEnumerable<exchange> or IAsyncEnumerable<exchange>
+    const exchangeName = `${stmt.name}_exchange`;
+    if (stmt.isAsync) {
+      parts.push(
+        `async global::System.Collections.Generic.IAsyncEnumerable<${exchangeName}>`
+      );
+    } else {
+      parts.push(
+        `global::System.Collections.Generic.IEnumerable<${exchangeName}>`
+      );
+    }
+  } else if (stmt.returnType) {
+    const [returnType, newContext] = emitType(stmt.returnType, currentContext);
+    currentContext = newContext;
+    // If async and return type is Promise, it's already converted to Task
+    // Don't wrap it again
+    if (
+      stmt.isAsync &&
+      stmt.returnType.kind === "referenceType" &&
+      stmt.returnType.name === "Promise"
+    ) {
+      parts.push(returnType); // Already Task<T> from emitType
+    } else {
+      parts.push(
+        stmt.isAsync
+          ? `global::System.Threading.Tasks.Task<${returnType}>`
+          : returnType
+      );
+    }
+  } else {
+    parts.push(stmt.isAsync ? "global::System.Threading.Tasks.Task" : "void");
+  }
+
+  // Function name
+  parts.push(stmt.name);
+
+  // Type parameters
+  const [typeParamsStr, whereClauses, typeParamContext] = emitTypeParameters(
+    stmt.typeParameters,
+    currentContext
+  );
+  currentContext = typeParamContext;
+
+  // Parameters
+  const params = emitParameters(stmt.parameters, currentContext);
+  currentContext = params[1];
+
+  // Function body (not a static context - local variables)
+  const bodyContext = withAsync(
+    withStatic(indent(currentContext), false),
+    stmt.isAsync
+  );
+  const [bodyCode] = emitBlockStatement(stmt.body, bodyContext);
+
+  // Collect out parameters that need initialization
+  const outParams: Array<{ name: string; type: string }> = [];
+  for (const param of stmt.parameters) {
+    // Use param.passing to detect out parameters (type is already unwrapped by frontend)
+    if (param.passing === "out" && param.pattern.kind === "identifierPattern") {
+      // Get the type for default value
+      let typeName = "object";
+      if (param.type) {
+        const [typeStr] = emitType(param.type, currentContext);
+        typeName = typeStr;
+      }
+      outParams.push({ name: param.pattern.name, type: typeName });
+    }
+  }
+
+  // Inject initialization code for generators and out parameters
+  let finalBodyCode = bodyCode;
+  const bodyInd = getIndent(bodyContext);
+  const injectLines: string[] = [];
+
+  // Add generator exchange initialization
+  if (stmt.isGenerator) {
+    const exchangeName = `${stmt.name}_exchange`;
+    injectLines.push(`${bodyInd}var exchange = new ${exchangeName}();`);
+  }
+
+  // Add out parameter initializations
+  if (outParams.length > 0) {
+    for (const outParam of outParams) {
+      injectLines.push(`${bodyInd}${outParam.name} = default;`);
+    }
+  }
+
+  // Inject lines after opening brace
+  if (injectLines.length > 0) {
+    const lines = bodyCode.split("\n");
+    if (lines.length > 1) {
+      lines.splice(1, 0, ...injectLines, "");
+      finalBodyCode = lines.join("\n");
+    }
+  }
+
+  const signature = parts.join(" ");
+  const whereClause =
+    whereClauses.length > 0
+      ? `\n${ind}    ${whereClauses.join(`\n${ind}    `)}`
+      : "";
+  const code = `${ind}${signature}${typeParamsStr}(${params[0]})${whereClause}\n${finalBodyCode}`;
+
+  // Return context - no usings tracking needed with global:: FQN approach
+  return [code, currentContext];
+};

package/src/statements/declarations/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Declaration emitters - Public API
+ */
+
+export { emitVariableDeclaration } from "./variables.js";
+export { emitFunctionDeclaration } from "./functions.js";
+export { emitClassDeclaration } from "./classes.js";
+export { emitInterfaceDeclaration } from "./interfaces.js";
+export { emitEnumDeclaration } from "./enums.js";
+export { emitTypeAliasDeclaration } from "./type-aliases.js";