@tsonic/emitter 0.0.1

package/src/expressions/literals.ts

@@ -0,0 +1,138 @@
+/**
+ * Literal expression emitters
+ */
+
+import { IrExpression, IrType } from "@tsonic/frontend";
+import { EmitterContext, CSharpFragment } from "../types.js";
+
+/**
+ * C# types that require integer values (not double).
+ * Used to determine when numeric literals should emit as int vs double.
+ */
+const INT_REQUIRED_TYPES = new Set([
+  "int",
+  "Int32",
+  "System.Int32",
+  "long",
+  "Int64",
+  "System.Int64",
+  "short",
+  "Int16",
+  "System.Int16",
+  "byte",
+  "Byte",
+  "System.Byte",
+  "sbyte",
+  "SByte",
+  "System.SByte",
+  "uint",
+  "UInt32",
+  "System.UInt32",
+  "ulong",
+  "UInt64",
+  "System.UInt64",
+  "ushort",
+  "UInt16",
+  "System.UInt16",
+]);
+
+/**
+ * Check if a C# type requires integer values
+ */
+export const requiresInteger = (clrType: string | undefined): boolean => {
+  if (!clrType) return false;
+  return INT_REQUIRED_TYPES.has(clrType);
+};
+
+/**
+ * Emit a literal value (string, number, boolean, null, undefined)
+ *
+ * @param expr - The literal expression
+ * @param context - Emitter context
+ * @param expectedClrType - Optional expected C# type (for int-required contexts)
+ */
+export const emitLiteral = (
+  expr: Extract<IrExpression, { kind: "literal" }>,
+  context: EmitterContext,
+  expectedClrType?: string
+): [CSharpFragment, EmitterContext] => {
+  const { value } = expr;
+
+  if (value === null) {
+    return [{ text: "null" }, context];
+  }
+
+  if (value === undefined) {
+    return [{ text: "default" }, context];
+  }
+
+  if (typeof value === "string") {
+    // Escape the string for C#
+    const escaped = value
+      .replace(/\\/g, "\\\\")
+      .replace(/"/g, '\\"')
+      .replace(/\n/g, "\\n")
+      .replace(/\r/g, "\\r")
+      .replace(/\t/g, "\\t");
+    return [{ text: `"${escaped}"` }, context];
+  }
+
+  if (typeof value === "number") {
+    // Check if context requires integer (array index, int parameter, etc.)
+    // Priority: explicit expectedClrType > context.isArrayIndex > default (double)
+    const needsInteger =
+      requiresInteger(expectedClrType) || context.isArrayIndex === true;
+
+    if (needsInteger) {
+      // Integer-required context: emit without decimal
+      const text = Number.isInteger(value)
+        ? String(value)
+        : String(Math.floor(value));
+      return [{ text }, context];
+    }
+
+    // TypeScript `number` is always `double` in C#
+    // Emit as double: ensure decimal point for integer values
+    if (Number.isInteger(value) && !String(value).includes(".")) {
+      return [{ text: `${value}.0` }, context];
+    }
+    return [{ text: String(value) }, context];
+  }
+
+  if (typeof value === "boolean") {
+    return [{ text: value ? "true" : "false" }, context];
+  }
+
+  return [{ text: String(value) }, context];
+};
+
+/**
+ * Helper to determine expected CLR type from IrType for numeric contexts.
+ * Returns the CLR type name if it requires integer, undefined otherwise.
+ *
+ * TODO: Expand this to handle more cases:
+ * - Method parameter types (requires signature lookup)
+ * - LINQ methods: Take(int), Skip(int), ElementAt(int)
+ * - String methods: Substring(int, int)
+ * - Generic type argument inference contexts
+ */
+export const getExpectedClrTypeForNumeric = (
+  irType: IrType | undefined
+): string | undefined => {
+  if (!irType) return undefined;
+
+  if (irType.kind === "primitiveType") {
+    // TS number -> C# double (default)
+    // TS doesn't have int type, so this won't trigger
+    return undefined;
+  }
+
+  if (irType.kind === "referenceType") {
+    // Check if it's an int type from .NET interop
+    if (requiresInteger(irType.name)) {
+      return irType.name;
+    }
+  }
+
+  return undefined;
+};

package/src/expressions/operators.ts

@@ -0,0 +1,211 @@
+/**
+ * Operator expression emitters (binary, logical, unary, update, assignment, conditional)
+ */
+
+import { IrExpression } from "@tsonic/frontend";
+import { EmitterContext, CSharpFragment } from "../types.js";
+import { emitExpression } from "../expression-emitter.js";
+
+/**
+ * Get operator precedence for proper parenthesization
+ */
+const getPrecedence = (operator: string): number => {
+  const precedences: Record<string, number> = {
+    "||": 5,
+    "??": 5,
+    "&&": 6,
+    "|": 7,
+    "^": 8,
+    "&": 9,
+    "==": 10,
+    "!=": 10,
+    "===": 10,
+    "!==": 10,
+    "<": 11,
+    ">": 11,
+    "<=": 11,
+    ">=": 11,
+    instanceof: 11,
+    in: 11,
+    "<<": 12,
+    ">>": 12,
+    ">>>": 12,
+    "+": 13,
+    "-": 13,
+    "*": 14,
+    "/": 14,
+    "%": 14,
+    "**": 15,
+  };
+
+  return precedences[operator] ?? 16;
+};
+
+/**
+ * Emit a binary operator expression
+ */
+export const emitBinary = (
+  expr: Extract<IrExpression, { kind: "binary" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [leftFrag, leftContext] = emitExpression(expr.left, context);
+  const [rightFrag, rightContext] = emitExpression(expr.right, leftContext);
+
+  // Map JavaScript operators to C# operators
+  const operatorMap: Record<string, string> = {
+    "===": "==",
+    "!==": "!=",
+    "==": "==", // Loose equality - needs special handling
+    "!=": "!=", // Loose inequality - needs special handling
+    instanceof: "is",
+    in: "/* in */", // Needs special handling
+  };
+
+  const op = operatorMap[expr.operator] ?? expr.operator;
+
+  // Handle typeof operator specially
+  if (expr.operator === "instanceof") {
+    const text = `${leftFrag.text} is ${rightFrag.text}`;
+    return [{ text, precedence: 7 }, rightContext];
+  }
+
+  const text = `${leftFrag.text} ${op} ${rightFrag.text}`;
+  return [{ text, precedence: getPrecedence(expr.operator) }, rightContext];
+};
+
+/**
+ * Check if an IR type is boolean
+ */
+const isBooleanType = (type: IrExpression["inferredType"]): boolean => {
+  if (!type) return false;
+  return type.kind === "primitiveType" && type.name === "boolean";
+};
+
+/**
+ * Emit a logical operator expression (&&, ||, ??)
+ *
+ * In TypeScript, || is used both for:
+ * 1. Boolean OR (when operands are booleans)
+ * 2. Nullish coalescing fallback (when left operand is nullable)
+ *
+ * In C#:
+ * - || only works with booleans
+ * - ?? is used for nullish coalescing
+ *
+ * We check if || is used with non-boolean operands and emit ?? instead.
+ */
+export const emitLogical = (
+  expr: Extract<IrExpression, { kind: "logical" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [leftFrag, leftContext] = emitExpression(expr.left, context);
+  const [rightFrag, rightContext] = emitExpression(expr.right, leftContext);
+
+  // If || is used with non-boolean left operand, use ?? instead for nullish coalescing
+  const operator =
+    expr.operator === "||" && !isBooleanType(expr.left.inferredType)
+      ? "??"
+      : expr.operator;
+
+  const text = `${leftFrag.text} ${operator} ${rightFrag.text}`;
+  return [{ text, precedence: getPrecedence(expr.operator) }, rightContext];
+};
+
+/**
+ * Emit a unary operator expression (-, +, !, ~, typeof, void, delete)
+ */
+export const emitUnary = (
+  expr: Extract<IrExpression, { kind: "unary" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [operandFrag, newContext] = emitExpression(expr.expression, context);
+
+  if (expr.operator === "typeof") {
+    // typeof becomes global::Tsonic.Runtime.Operators.typeof()
+    const text = `global::Tsonic.Runtime.Operators.@typeof(${operandFrag.text})`;
+    return [{ text }, newContext];
+  }
+
+  if (expr.operator === "void") {
+    // void expression - evaluate and discard
+    const text = `(${operandFrag.text}, default)`;
+    return [{ text }, newContext];
+  }
+
+  if (expr.operator === "delete") {
+    // delete needs special handling
+    const text = `/* delete ${operandFrag.text} */`;
+    return [{ text }, newContext];
+  }
+
+  const text = `${expr.operator}${operandFrag.text}`;
+  return [{ text, precedence: 15 }, newContext];
+};
+
+/**
+ * Emit an update operator expression (++, --)
+ */
+export const emitUpdate = (
+  expr: Extract<IrExpression, { kind: "update" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [operandFrag, newContext] = emitExpression(expr.expression, context);
+
+  const text = expr.prefix
+    ? `${expr.operator}${operandFrag.text}`
+    : `${operandFrag.text}${expr.operator}`;
+
+  return [{ text, precedence: 15 }, newContext];
+};
+
+/**
+ * Emit an assignment expression (=, +=, -=, etc.)
+ */
+export const emitAssignment = (
+  expr: Extract<IrExpression, { kind: "assignment" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  // Left side can be an expression or a pattern (for destructuring)
+  let leftText: string;
+  let leftContext: EmitterContext;
+
+  if (
+    "kind" in expr.left &&
+    (expr.left.kind === "identifierPattern" ||
+      expr.left.kind === "arrayPattern" ||
+      expr.left.kind === "objectPattern")
+  ) {
+    // It's a pattern - for now emit a comment for destructuring
+    if (expr.left.kind === "identifierPattern") {
+      leftText = expr.left.name;
+      leftContext = context;
+    } else {
+      leftText = "/* destructuring */";
+      leftContext = context;
+    }
+  } else {
+    const [leftFrag, ctx] = emitExpression(expr.left as IrExpression, context);
+    leftText = leftFrag.text;
+    leftContext = ctx;
+  }
+
+  const [rightFrag, rightContext] = emitExpression(expr.right, leftContext);
+
+  const text = `${leftText} ${expr.operator} ${rightFrag.text}`;
+  return [{ text, precedence: 3 }, rightContext];
+};
+
+/**
+ * Emit a conditional (ternary) expression
+ */
+export const emitConditional = (
+  expr: Extract<IrExpression, { kind: "conditional" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [condFrag, condContext] = emitExpression(expr.condition, context);
+  const [trueFrag, trueContext] = emitExpression(expr.whenTrue, condContext);
+  const [falseFrag, falseContext] = emitExpression(expr.whenFalse, trueContext);
+
+  const text = `${condFrag.text} ? ${trueFrag.text} : ${falseFrag.text}`;
+  return [{ text, precedence: 4 }, falseContext];
+};

package/src/expressions/other.ts

@@ -0,0 +1,63 @@
+/**
+ * Miscellaneous expression emitters (template literals, spread, await)
+ */
+
+import { IrExpression } from "@tsonic/frontend";
+import { EmitterContext, CSharpFragment } from "../types.js";
+import { emitExpression } from "../expression-emitter.js";
+
+/**
+ * Emit a template literal as C# interpolated string
+ */
+export const emitTemplateLiteral = (
+  expr: Extract<IrExpression, { kind: "templateLiteral" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  let currentContext = context;
+  const parts: string[] = [];
+
+  for (let i = 0; i < expr.quasis.length; i++) {
+    const quasi = expr.quasis[i];
+    if (quasi !== undefined && quasi !== null) {
+      parts.push(quasi);
+    }
+
+    const exprAtIndex = expr.expressions[i];
+    if (i < expr.expressions.length && exprAtIndex) {
+      const [exprFrag, newContext] = emitExpression(
+        exprAtIndex,
+        currentContext
+      );
+      parts.push(`{${exprFrag.text}}`);
+      currentContext = newContext;
+    }
+  }
+
+  const text = `$"${parts.join("")}"`;
+  return [{ text }, currentContext];
+};
+
+/**
+ * Emit a spread expression
+ */
+export const emitSpread = (
+  expr: Extract<IrExpression, { kind: "spread" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [exprFrag, newContext] = emitExpression(expr.expression, context);
+  // Spread syntax needs context-specific handling
+  const text = `...${exprFrag.text}`;
+  return [{ text }, newContext];
+};
+
+/**
+ * Emit an await expression
+ */
+export const emitAwait = (
+  expr: Extract<IrExpression, { kind: "await" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  const [exprFrag, newContext] = emitExpression(expr.expression, context);
+  const text = `await ${exprFrag.text}`;
+  return [{ text }, newContext];
+};

package/src/generator-exchange.ts

@@ -0,0 +1,120 @@
+/**
+ * Generator Exchange Object Generator
+ * Per spec/13-generators.md - Generate exchange objects for bidirectional communication
+ */
+
+import { IrModule, IrFunctionDeclaration } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent } from "./types.js";
+import { emitType } from "./type-emitter.js";
+
+/**
+ * Collect all generator functions from a module
+ */
+const collectGenerators = (module: IrModule): IrFunctionDeclaration[] => {
+  const generators: IrFunctionDeclaration[] = [];
+
+  for (const stmt of module.body) {
+    if (stmt.kind === "functionDeclaration" && stmt.isGenerator) {
+      generators.push(stmt);
+    }
+    // TODO: Also handle generator methods in classes
+  }
+
+  return generators;
+};
+
+/**
+ * Generate exchange object class for a generator function
+ *
+ * Example:
+ * function* accumulator(start = 0): Generator<number, void, number> { }
+ *
+ * Generates:
+ * public sealed class accumulator_exchange
+ * {
+ *     public double? Input { get; set; }
+ *     public double Output { get; set; }
+ * }
+ */
+const generateExchangeClass = (
+  func: IrFunctionDeclaration,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  const bodyInd = getIndent(indent(context));
+  const parts: string[] = [];
+  let currentContext = context;
+
+  const exchangeName = `${func.name}_exchange`;
+
+  parts.push(`${ind}public sealed class ${exchangeName}`);
+  parts.push(`${ind}{`);
+
+  // Determine output type from return type or yield expressions
+  // For now, use 'object' as default, will refine based on type inference
+  let outputType = "object";
+  let inputType = "object";
+
+  if (func.returnType && func.returnType.kind === "referenceType") {
+    // Generator<Yield, Return, Next>
+    // typeArguments[0] is the Yield type (Output)
+    // typeArguments[2] is the Next type (Input)
+    const typeRef = func.returnType;
+    if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+      const yieldTypeArg = typeRef.typeArguments[0];
+      if (yieldTypeArg) {
+        const [yieldType, newContext1] = emitType(yieldTypeArg, currentContext);
+        currentContext = newContext1;
+        outputType = yieldType;
+      }
+
+      if (typeRef.typeArguments.length > 2) {
+        const nextTypeArg = typeRef.typeArguments[2];
+        if (nextTypeArg) {
+          const [nextType, newContext2] = emitType(nextTypeArg, currentContext);
+          currentContext = newContext2;
+          inputType = nextType;
+        }
+      }
+    }
+  }
+
+  // Input property (always nullable since generator might not receive value)
+  parts.push(`${bodyInd}public ${inputType}? Input { get; set; }`);
+
+  // Output property
+  parts.push(`${bodyInd}public ${outputType} Output { get; set; }`);
+
+  parts.push(`${ind}}`);
+
+  return [parts.join("\n"), currentContext];
+};
+
+/**
+ * Generate all exchange objects for generators in a module
+ */
+export const generateGeneratorExchanges = (
+  module: IrModule,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const generators = collectGenerators(module);
+
+  if (generators.length === 0) {
+    return ["", context];
+  }
+
+  const parts: string[] = [];
+  let currentContext = context;
+
+  for (const generator of generators) {
+    const [exchangeCode, newContext] = generateExchangeClass(
+      generator,
+      currentContext
+    );
+    currentContext = newContext;
+    parts.push(exchangeCode);
+    parts.push(""); // Blank line between exchange classes
+  }
+
+  return [parts.join("\n"), currentContext];
+};