@tsonic/emitter 0.0.1 → 0.0.2

package/src/statements/classes/properties.ts

@@ -1,95 +0,0 @@
-/**
- * Interface member to property emission
- */
-
-import { IrInterfaceMember } from "@tsonic/frontend";
-import { EmitterContext, getIndent } from "../../types.js";
-import { emitType } from "../../type-emitter.js";
-import { capitalize } from "./helpers.js";
-import { emitParameters } from "./parameters.js";
-
-/**
- * Emit interface member as C# auto-property (for classes)
- * Per spec/16-types-and-interfaces.md §2.1
- */
-export const emitInterfaceMemberAsProperty = (
-  member: IrInterfaceMember,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-
-  switch (member.kind) {
-    case "propertySignature": {
-      let currentContext = context;
-      const parts: string[] = [];
-
-      parts.push("public"); // All properties public
-
-      // Property type
-      if (member.type) {
-        // If this is an inline object type, use the extracted class name
-        let typeName: string;
-        if (member.type.kind === "objectType") {
-          // Use capitalized property name as the class name
-          typeName = capitalize(member.name);
-        } else {
-          const [emittedType, newContext] = emitType(
-            member.type,
-            currentContext
-          );
-          currentContext = newContext;
-          typeName = emittedType;
-        }
-        // Optional members become nullable (spec §2.1)
-        const typeStr = member.isOptional ? `${typeName}?` : typeName;
-        parts.push(typeStr);
-      } else {
-        const typeStr = member.isOptional ? "object?" : "object";
-        parts.push(typeStr);
-      }
-
-      // Property name
-      parts.push(member.name);
-
-      // Getter/setter (readonly is get-only)
-      const accessors = member.isReadonly ? "{ get; }" : "{ get; set; }";
-
-      return [`${ind}${parts.join(" ")} ${accessors}`, currentContext];
-    }
-
-    case "methodSignature": {
-      let currentContext = context;
-      const parts: string[] = [];
-
-      parts.push("public"); // All methods public
-
-      // Return type
-      if (member.returnType) {
-        const [returnType, newContext] = emitType(
-          member.returnType,
-          currentContext
-        );
-        currentContext = newContext;
-        parts.push(returnType);
-      } else {
-        parts.push("void");
-      }
-
-      // Method name
-      parts.push(member.name);
-
-      // Parameters
-      const params = emitParameters(member.parameters, currentContext);
-      currentContext = params[1];
-
-      // Methods in interfaces are abstract declarations
-      return [
-        `${ind}${parts.join(" ")}(${params[0]}) => throw new NotImplementedException();`,
-        currentContext,
-      ];
-    }
-
-    default:
-      return [`${ind}// TODO: unhandled interface member`, context];
-  }
-};

package/src/statements/classes.ts

@@ -1,14 +0,0 @@
-/**
- * Class-related helpers (members, constructors, parameters, interface members)
- * Main dispatcher - re-exports from classes/ subdirectory
- */
-
-export {
-  emitClassMember,
-  emitInterfaceMemberAsProperty,
-  extractInlineObjectTypes,
-  emitExtractedType,
-  type ExtractedType,
-  emitParameters,
-  capitalize,
-} from "./classes/index.js";

package/src/statements/control/conditionals.ts

@@ -1,134 +0,0 @@
-/**
- * Conditional statement emitters (if, switch)
- */
-
-import { IrExpression, IrStatement } from "@tsonic/frontend";
-import { EmitterContext, getIndent, indent, dedent } from "../../types.js";
-import { emitExpression } from "../../expression-emitter.js";
-import { emitStatement } from "../../statement-emitter.js";
-
-/**
- * Check if an expression's inferred type is boolean
- */
-const isBooleanCondition = (expr: IrExpression): boolean => {
-  const type = expr.inferredType;
-  if (!type) return false;
-  return type.kind === "primitiveType" && type.name === "boolean";
-};
-
-/**
- * Convert an expression to a valid C# boolean condition.
- * In TypeScript, any value can be used in a boolean context (truthy/falsy).
- * In C#, only boolean expressions are valid conditions.
- *
- * For non-boolean expressions:
- * - Reference types (objects, arrays): emit `expr != null`
- * - Numbers: could emit `expr != 0` (not implemented yet)
- * - Strings: could emit `!string.IsNullOrEmpty(expr)` (not implemented yet)
- */
-const toBooleanCondition = (
-  expr: IrExpression,
-  emittedText: string
-): string => {
-  // If already boolean, use as-is
-  if (isBooleanCondition(expr)) {
-    return emittedText;
-  }
-
-  // For reference types (non-primitive), add != null check
-  const type = expr.inferredType;
-  if (type && type.kind !== "primitiveType") {
-    return `${emittedText} != null`;
-  }
-
-  // Default: assume it's a reference type and add null check
-  // This handles cases where type inference didn't work
-  if (!type) {
-    return `${emittedText} != null`;
-  }
-
-  // For primitives that are not boolean, just use as-is for now
-  // TODO: Handle number truthiness (x != 0) and string truthiness
-  return emittedText;
-};
-
-/**
- * Emit an if statement
- */
-export const emitIfStatement = (
-  stmt: Extract<IrStatement, { kind: "ifStatement" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  const [condFrag, condContext] = emitExpression(stmt.condition, context);
-
-  // Convert to boolean condition if needed
-  const condText = toBooleanCondition(stmt.condition, condFrag.text);
-
-  const [thenCode, thenContext] = emitStatement(
-    stmt.thenStatement,
-    indent(condContext)
-  );
-
-  let code = `${ind}if (${condText})\n${thenCode}`;
-  let finalContext = dedent(thenContext);
-
-  if (stmt.elseStatement) {
-    const [elseCode, elseContext] = emitStatement(
-      stmt.elseStatement,
-      indent(finalContext)
-    );
-    code += `\n${ind}else\n${elseCode}`;
-    finalContext = dedent(elseContext);
-  }
-
-  return [code, finalContext];
-};
-
-/**
- * Emit a switch statement
- */
-export const emitSwitchStatement = (
-  stmt: Extract<IrStatement, { kind: "switchStatement" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  const [exprFrag, exprContext] = emitExpression(stmt.expression, context);
-
-  let currentContext = indent(exprContext);
-  const caseInd = getIndent(currentContext);
-  const cases: string[] = [];
-
-  for (const switchCase of stmt.cases) {
-    if (switchCase.test) {
-      const [testFrag, testContext] = emitExpression(
-        switchCase.test,
-        currentContext
-      );
-      currentContext = testContext;
-      cases.push(`${caseInd}case ${testFrag.text}:`);
-    } else {
-      cases.push(`${caseInd}default:`);
-    }
-
-    const stmtContext = indent(currentContext);
-    for (const s of switchCase.statements) {
-      const [code, newContext] = emitStatement(s, stmtContext);
-      cases.push(code);
-      currentContext = newContext;
-    }
-
-    // Add break if not already present
-    const lastStmt = switchCase.statements[switchCase.statements.length - 1];
-    if (
-      !lastStmt ||
-      (lastStmt.kind !== "breakStatement" &&
-        lastStmt.kind !== "returnStatement")
-    ) {
-      cases.push(`${getIndent(stmtContext)}break;`);
-    }
-  }
-
-  const code = `${ind}switch (${exprFrag.text})\n${ind}{\n${cases.join("\n")}\n${ind}}`;
-  return [code, dedent(currentContext)];
-};

package/src/statements/control/exceptions.ts

@@ -1,59 +0,0 @@
-/**
- * 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/loops.ts

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

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

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

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