@tsonic/emitter 0.0.1 → 0.0.3

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

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

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

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

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

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