@tsonic/emitter 0.0.1

package/src/statements/classes/members/constructors.ts

@@ -0,0 +1,123 @@
+/**
+ * Constructor member emission
+ */
+
+import { IrClassMember, IrStatement } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent, dedent } from "../../../types.js";
+import { emitExpression } from "../../../expression-emitter.js";
+import { emitBlockStatement } from "../../blocks.js";
+import { emitParameters } from "../parameters.js";
+
+/**
+ * Emit a constructor declaration
+ */
+export const emitConstructorMember = (
+  member: IrClassMember & { kind: "constructorDeclaration" },
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  // Access modifier
+  const accessibility = member.accessibility ?? "public";
+  parts.push(accessibility);
+
+  // Constructor name (same as class name)
+  const constructorName = context.className ?? "UnknownClass";
+  parts.push(constructorName);
+
+  // Parameters
+  const params = emitParameters(member.parameters, currentContext);
+  currentContext = params[1];
+
+  // Constructor body
+  if (!member.body) {
+    // Abstract or interface constructor without body
+    const signature = parts.join(" ");
+    const code = `${ind}${signature}(${params[0]});`;
+    return [code, currentContext];
+  }
+
+  // Check for super() call - MUST be the first statement if present
+  // C# base() calls execute before the constructor body, so we can't preserve
+  // TypeScript semantics if there are statements before super()
+  const [baseCall, bodyStatements, baseCallContext] = extractSuperCall(
+    member.body.statements,
+    currentContext
+  );
+  currentContext = baseCallContext;
+
+  // Check if super() appears later in the body (not supported)
+  const hasLaterSuperCall = bodyStatements.some(
+    (stmt) =>
+      stmt.kind === "expressionStatement" &&
+      stmt.expression.kind === "call" &&
+      stmt.expression.callee.kind === "identifier" &&
+      stmt.expression.callee.name === "super"
+  );
+
+  if (hasLaterSuperCall) {
+    // TODO: This should be a compile error in the IR builder
+    // For now, emit a comment noting the issue
+    const signature = parts.join(" ");
+    const errorComment = `${ind}// ERROR: super() must be the first statement in constructor`;
+    const code = `${errorComment}\n${ind}${signature}(${params[0]})\n${ind}{\n${ind}    // Constructor body omitted due to error\n${ind}}`;
+    return [code, currentContext];
+  }
+
+  // Emit body without the super() call
+  const bodyContext = indent(currentContext);
+  const modifiedBody: typeof member.body = {
+    ...member.body,
+    statements: bodyStatements,
+  };
+  const [bodyCode, finalContext] = emitBlockStatement(
+    modifiedBody,
+    bodyContext
+  );
+
+  const signature = parts.join(" ");
+  const code = `${ind}${signature}(${params[0]})${baseCall}\n${bodyCode}`;
+
+  return [code, dedent(finalContext)];
+};
+
+/**
+ * Extract super() call from first statement if present
+ * Returns [baseCall, remainingStatements, context]
+ */
+const extractSuperCall = (
+  statements: readonly IrStatement[],
+  context: EmitterContext
+): [string, readonly IrStatement[], EmitterContext] => {
+  let currentContext = context;
+
+  if (statements.length === 0) {
+    return ["", statements, currentContext];
+  }
+
+  const firstStmt = statements[0];
+  if (
+    firstStmt &&
+    firstStmt.kind === "expressionStatement" &&
+    firstStmt.expression.kind === "call" &&
+    firstStmt.expression.callee.kind === "identifier" &&
+    firstStmt.expression.callee.name === "super"
+  ) {
+    // Found super() call as first statement - convert to : base(...)
+    const superCall = firstStmt.expression;
+    const argFrags: string[] = [];
+    for (const arg of superCall.arguments) {
+      const [argFrag, newContext] = emitExpression(arg, currentContext);
+      argFrags.push(argFrag.text);
+      currentContext = newContext;
+    }
+    const baseCall = ` : base(${argFrags.join(", ")})`;
+    // Remove super() call from body statements
+    const remainingStatements = statements.slice(1);
+    return [baseCall, remainingStatements, currentContext];
+  }
+
+  return ["", statements, currentContext];
+};

package/src/statements/classes/members/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Class member emission - Public API
+ */
+
+export { emitClassMember } from "./orchestrator.js";
+export { emitPropertyMember } from "./properties.js";
+export { emitMethodMember } from "./methods.js";
+export { emitConstructorMember } from "./constructors.js";

package/src/statements/classes/members/methods.ts

@@ -0,0 +1,137 @@
+/**
+ * Method member emission
+ */
+
+import { IrClassMember } from "@tsonic/frontend";
+import {
+  EmitterContext,
+  getIndent,
+  indent,
+  dedent,
+  withAsync,
+} from "../../../types.js";
+import { emitType, emitTypeParameters } from "../../../type-emitter.js";
+import { emitBlockStatement } from "../../blocks.js";
+import { emitParameters } from "../parameters.js";
+
+/**
+ * Emit a method declaration
+ */
+export const emitMethodMember = (
+  member: IrClassMember & { kind: "methodDeclaration" },
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  // Access modifier
+  const accessibility = member.accessibility ?? "public";
+  parts.push(accessibility);
+
+  if (member.isStatic) {
+    parts.push("static");
+  }
+
+  // Override modifier (from metadata or TS base class detection)
+  if (member.isOverride) {
+    parts.push("override");
+  }
+
+  if (member.isAsync) {
+    parts.push("async");
+  }
+
+  // Return type
+  if (member.returnType) {
+    const [returnType, newContext] = emitType(
+      member.returnType,
+      currentContext
+    );
+    currentContext = newContext;
+    // If async and return type is Promise, it's already converted to Task
+    // Don't wrap it again
+    if (
+      member.isAsync &&
+      member.returnType.kind === "referenceType" &&
+      member.returnType.name === "Promise"
+    ) {
+      parts.push(returnType); // Already Task<T> from emitType
+    } else {
+      parts.push(
+        member.isAsync
+          ? `global::System.Threading.Tasks.Task<${returnType}>`
+          : returnType
+      );
+    }
+  } else {
+    parts.push(member.isAsync ? "global::System.Threading.Tasks.Task" : "void");
+  }
+
+  // Method name
+  parts.push(member.name);
+
+  // Type parameters
+  const [typeParamsStr, whereClauses, typeParamContext] = emitTypeParameters(
+    member.typeParameters,
+    currentContext
+  );
+  currentContext = typeParamContext;
+
+  // Parameters
+  const params = emitParameters(member.parameters, currentContext);
+  currentContext = params[1];
+
+  const whereClause =
+    whereClauses.length > 0
+      ? `\n${ind}    ${whereClauses.join(`\n${ind}    `)}`
+      : "";
+
+  // Method body
+  const bodyContext = withAsync(indent(currentContext), member.isAsync);
+
+  if (!member.body) {
+    // Abstract method without body
+    const signature = parts.join(" ");
+    const code = `${ind}${signature}${typeParamsStr}(${params[0]})${whereClause};`;
+    return [code, currentContext];
+  }
+
+  const [bodyCode, finalContext] = emitBlockStatement(member.body, bodyContext);
+
+  // Collect out parameters that need initialization
+  const outParams: Array<{ name: string; type: string }> = [];
+  for (const param of member.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 out parameter initializations
+  let finalBodyCode = bodyCode;
+  if (outParams.length > 0) {
+    const bodyInd = getIndent(bodyContext);
+    const injectLines: string[] = [];
+    for (const outParam of outParams) {
+      injectLines.push(`${bodyInd}${outParam.name} = default;`);
+    }
+
+    const lines = bodyCode.split("\n");
+    if (lines.length > 1) {
+      lines.splice(1, 0, ...injectLines, "");
+      finalBodyCode = lines.join("\n");
+    }
+  }
+
+  const signature = parts.join(" ");
+  const code = `${ind}${signature}${typeParamsStr}(${params[0]})${whereClause}\n${finalBodyCode}`;
+
+  return [code, dedent(finalContext)];
+};

package/src/statements/classes/members/orchestrator.ts

@@ -0,0 +1,33 @@
+/**
+ * Class member emission orchestrator
+ */
+
+import { IrClassMember } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../../../types.js";
+import { emitPropertyMember } from "./properties.js";
+import { emitMethodMember } from "./methods.js";
+import { emitConstructorMember } from "./constructors.js";
+
+/**
+ * Emit a class member (property, method, or constructor)
+ */
+export const emitClassMember = (
+  member: IrClassMember,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+
+  switch (member.kind) {
+    case "propertyDeclaration":
+      return emitPropertyMember(member, context);
+
+    case "methodDeclaration":
+      return emitMethodMember(member, context);
+
+    case "constructorDeclaration":
+      return emitConstructorMember(member, context);
+
+    default:
+      return [`${ind}// TODO: unhandled class member`, context];
+  }
+};

package/src/statements/classes/members/properties.ts

@@ -0,0 +1,62 @@
+/**
+ * Property member emission
+ */
+
+import { IrClassMember } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../../../types.js";
+import { emitExpression } from "../../../expression-emitter.js";
+import { emitType } from "../../../type-emitter.js";
+
+/**
+ * Emit a property declaration
+ */
+export const emitPropertyMember = (
+  member: IrClassMember & { kind: "propertyDeclaration" },
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const parts: string[] = [];
+
+  // Access modifier
+  const accessibility = member.accessibility ?? "public";
+  parts.push(accessibility);
+
+  if (member.isStatic) {
+    parts.push("static");
+  }
+
+  // Override modifier (from metadata or TS base class detection)
+  if (member.isOverride) {
+    parts.push("override");
+  }
+
+  if (member.isReadonly) {
+    parts.push("readonly");
+  }
+
+  // Property type - uses standard type emission pipeline
+  // Note: type is always set for class fields (from annotation or inference)
+  if (member.type) {
+    const [typeName, newContext] = emitType(member.type, currentContext);
+    currentContext = newContext;
+    parts.push(typeName);
+  } else {
+    parts.push("object");
+  }
+
+  // Property name
+  parts.push(member.name);
+
+  // Emit as field (TypeScript class fields map to C# fields, not properties)
+  let code = `${ind}${parts.join(" ")}`;
+  if (member.initializer) {
+    const [initFrag, finalContext] = emitExpression(
+      member.initializer,
+      currentContext
+    );
+    code += ` = ${initFrag.text}`;
+    currentContext = finalContext;
+  }
+  return [`${code};`, currentContext];
+};

package/src/statements/classes/members.ts

@@ -0,0 +1,6 @@
+/**
+ * Class member emission (properties, methods, constructors)
+ * Main dispatcher - re-exports from members/ subdirectory
+ */
+
+export { emitClassMember } from "./members/index.js";

package/src/statements/classes/parameters.ts

@@ -0,0 +1,69 @@
+/**
+ * Parameter emission for functions and methods
+ */
+
+import { IrParameter, IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+import { emitParameterType } from "../../type-emitter.js";
+
+/**
+ * Emit parameters for functions and methods
+ */
+export const emitParameters = (
+  parameters: readonly IrParameter[],
+  context: EmitterContext
+): [string, EmitterContext] => {
+  let currentContext = context;
+  const params: string[] = [];
+
+  for (const param of parameters) {
+    const isRest = param.isRest;
+    const isOptional = param.isOptional;
+
+    // Use the passing mode from IR (frontend already unwrapped ref<T>/out<T>/in<T>)
+    const paramModifier = param.passing !== "value" ? param.passing : "";
+    const actualType: IrType | undefined = param.type;
+
+    // Parameter type
+    let paramType = "object";
+    if (actualType) {
+      const [typeName, newContext] = emitParameterType(
+        actualType,
+        isOptional,
+        currentContext
+      );
+      currentContext = newContext;
+      paramType = typeName;
+      // TODO: Rest parameters currently map to Tsonic.Runtime.Array<T> to preserve
+      // JavaScript semantics (reduce, join, etc.). In future, could optimize to
+      // params T[] and wrap with Array.from() at call sites.
+    }
+
+    // Parameter name
+    let paramName = "param";
+    if (param.pattern.kind === "identifierPattern") {
+      paramName = param.pattern.name;
+    }
+
+    // Construct parameter string with modifier if present
+    let paramStr = paramModifier
+      ? `${paramModifier} ${paramType} ${paramName}`
+      : `${paramType} ${paramName}`;
+    if (param.initializer) {
+      // Emit the default value directly
+      const [defaultExpr, newContext] = emitExpression(
+        param.initializer,
+        currentContext
+      );
+      currentContext = newContext;
+      paramStr = `${paramType} ${paramName} = ${defaultExpr.text}`;
+    } else if (isOptional && !isRest) {
+      paramStr += " = default";
+    }
+
+    params.push(paramStr);
+  }
+
+  return [params.join(", "), currentContext];
+};

package/src/statements/classes/properties.ts

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

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

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