@tsonic/emitter 0.0.1 → 0.0.3

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];
-};

package/src/statements/declarations/functions.ts

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

@@ -1,116 +0,0 @@
-/**
- * Interface declaration emission (as C# classes)
- */
-
-import { IrStatement } from "@tsonic/frontend";
-import { EmitterContext, getIndent, indent } from "../../types.js";
-import { emitType, emitTypeParameters } from "../../type-emitter.js";
-import {
-  extractInlineObjectTypes,
-  emitExtractedType,
-  emitInterfaceMemberAsProperty,
-} from "../classes.js";
-
-/**
- * Emit an interface declaration (as C# class)
- */
-export const emitInterfaceDeclaration = (
-  stmt: Extract<IrStatement, { kind: "interfaceDeclaration" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  // Per spec/16-types-and-interfaces.md §2.1:
-  // TypeScript interfaces map to C# classes (not C# interfaces)
-  // because TS interfaces are structural and we need nominal types in C#
-
-  const ind = getIndent(context);
-  let currentContext = context;
-
-  // Extract inline object types and emit them as separate classes
-  const extractedTypes = extractInlineObjectTypes(stmt.members);
-  const extractedClassCodes: string[] = [];
-
-  for (const extracted of extractedTypes) {
-    const [classCode, newContext] = emitExtractedType(
-      extracted,
-      currentContext
-    );
-    extractedClassCodes.push(classCode);
-    currentContext = newContext;
-  }
-
-  const parts: string[] = [];
-
-  // Access modifier
-  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 (if any)
-  if (stmt.typeParameters && stmt.typeParameters.length > 0) {
-    const [typeParamsStr, whereClauses, typeParamContext] = emitTypeParameters(
-      stmt.typeParameters,
-      currentContext
-    );
-    parts.push(typeParamsStr);
-    currentContext = typeParamContext;
-
-    // Extended interfaces/classes
-    if (stmt.extends && stmt.extends.length > 0) {
-      const extended: string[] = [];
-      for (const ext of stmt.extends) {
-        const [extType, newContext] = emitType(ext, currentContext);
-        currentContext = newContext;
-        extended.push(extType);
-      }
-      parts.push(":");
-      parts.push(extended.join(", "));
-    }
-
-    // Where clauses for type parameters
-    if (whereClauses.length > 0) {
-      parts.push("\n" + ind + "    " + whereClauses.join("\n" + ind + "    "));
-    }
-  } else {
-    // Extended interfaces/classes (no generics)
-    if (stmt.extends && stmt.extends.length > 0) {
-      const extended: string[] = [];
-      for (const ext of stmt.extends) {
-        const [extType, newContext] = emitType(ext, currentContext);
-        currentContext = newContext;
-        extended.push(extType);
-      }
-      parts.push(":");
-      parts.push(extended.join(", "));
-    }
-  }
-
-  // Class body with auto-properties
-  const bodyContext = indent(currentContext);
-  const members: string[] = [];
-
-  for (const member of stmt.members) {
-    const [memberCode, newContext] = emitInterfaceMemberAsProperty(
-      member,
-      bodyContext
-    );
-    members.push(memberCode);
-    currentContext = newContext;
-  }
-
-  const signature = parts.join(" ");
-  const memberCode = members.join("\n\n");
-  const mainClassCode = `${ind}${signature}\n${ind}{\n${memberCode}\n${ind}}`;
-
-  // Combine main interface and extracted classes (extracted classes come after)
-  const allParts: string[] = [];
-  allParts.push(mainClassCode);
-  if (extractedClassCodes.length > 0) {
-    allParts.push(...extractedClassCodes);
-  }
-
-  const code = allParts.join("\n");
-
-  return [code, currentContext];
-};