@tsonic/emitter 0.0.1 → 0.0.3

package/src/expressions/literals.ts

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

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

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

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