@tsonic/emitter 0.0.1 → 0.0.2

package/src/statements/blocks.ts

@@ -1,115 +0,0 @@
-/**
- * Block and simple statement emitters
- */
-
-import { IrStatement, IrExpression } from "@tsonic/frontend";
-import { EmitterContext, getIndent } from "../types.js";
-import { emitExpression } from "../expression-emitter.js";
-import { emitStatement } from "../statement-emitter.js";
-
-/**
- * Emit a block statement
- */
-export const emitBlockStatement = (
-  stmt: Extract<IrStatement, { kind: "blockStatement" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  let currentContext = context;
-  const statements: string[] = [];
-
-  for (const s of stmt.statements) {
-    const [code, newContext] = emitStatement(s, currentContext);
-    statements.push(code);
-    currentContext = newContext;
-  }
-
-  const bodyCode = statements.join("\n");
-  return [`${ind}{\n${bodyCode}\n${ind}}`, currentContext];
-};
-
-/**
- * Emit a return statement
- */
-export const emitReturnStatement = (
-  stmt: Extract<IrStatement, { kind: "returnStatement" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-
-  if (stmt.expression) {
-    const [exprFrag, newContext] = emitExpression(stmt.expression, context);
-    return [`${ind}return ${exprFrag.text};`, newContext];
-  }
-
-  return [`${ind}return;`, context];
-};
-
-/**
- * Emit yield expression as C# yield return with exchange object pattern
- *
- * TypeScript: yield value
- * C#:
- *   exchange.Output = value;
- *   yield return exchange;
- *
- * TypeScript: yield* otherGenerator()
- * C#:
- *   foreach (var item in OtherGenerator())
- *     yield return item;
- */
-export const emitYieldStatement = (
-  expr: Extract<IrExpression, { kind: "yield" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  let currentContext = context;
-  const parts: string[] = [];
-
-  if (expr.delegate) {
-    // yield* delegation
-    if (expr.expression) {
-      const [delegateFrag, newContext] = emitExpression(
-        expr.expression,
-        currentContext
-      );
-      currentContext = newContext;
-      parts.push(`${ind}foreach (var item in ${delegateFrag.text})`);
-      parts.push(`${ind}    yield return item;`);
-    }
-  } else {
-    // Regular yield
-    if (expr.expression) {
-      const [valueFrag, newContext] = emitExpression(
-        expr.expression,
-        currentContext
-      );
-      currentContext = newContext;
-      parts.push(`${ind}exchange.Output = ${valueFrag.text};`);
-      parts.push(`${ind}yield return exchange;`);
-    } else {
-      // Bare yield (no value)
-      parts.push(`${ind}yield return exchange;`);
-    }
-  }
-
-  return [parts.join("\n"), currentContext];
-};
-
-/**
- * Emit an expression statement
- */
-export const emitExpressionStatement = (
-  stmt: Extract<IrStatement, { kind: "expressionStatement" }>,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-
-  // Special handling for yield expressions in generators
-  if (stmt.expression.kind === "yield") {
-    return emitYieldStatement(stmt.expression, context);
-  }
-
-  const [exprFrag, newContext] = emitExpression(stmt.expression, context);
-  return [`${ind}${exprFrag.text};`, newContext];
-};

package/src/statements/classes/inline-types.ts

@@ -1,79 +0,0 @@
-/**
- * Inline object type extraction and emission
- */
-
-import { IrInterfaceMember } from "@tsonic/frontend";
-import { EmitterContext, getIndent, indent } from "../../types.js";
-import { capitalize } from "./helpers.js";
-import { emitInterfaceMemberAsProperty } from "./properties.js";
-
-/**
- * Extracted inline object type
- */
-export type ExtractedType = {
-  readonly className: string;
-  readonly members: readonly IrInterfaceMember[];
-};
-
-/**
- * Extract inline object types from interface members and generate class declarations
- */
-export const extractInlineObjectTypes = (
-  members: readonly IrInterfaceMember[]
-): readonly ExtractedType[] => {
-  const extracted: ExtractedType[] = [];
-
-  for (const member of members) {
-    if (
-      member.kind === "propertySignature" &&
-      member.type?.kind === "objectType"
-    ) {
-      // Generate class name from property name (capitalize)
-      const className = capitalize(member.name);
-      extracted.push({
-        className,
-        members: member.type.members,
-      });
-    }
-  }
-
-  return extracted;
-};
-
-/**
- * Emit an extracted inline object type as a class
- */
-export const emitExtractedType = (
-  extracted: ExtractedType,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const ind = getIndent(context);
-  let currentContext = context;
-
-  const parts: string[] = [];
-  parts.push(`${ind}public class ${extracted.className}`);
-  parts.push(`${ind}{`);
-
-  // Emit properties
-  const bodyContext = indent(currentContext);
-  const propertyParts: string[] = [];
-  let bodyCurrentContext = bodyContext;
-
-  for (const member of extracted.members) {
-    const [memberCode, newContext] = emitInterfaceMemberAsProperty(
-      member,
-      bodyCurrentContext
-    );
-    propertyParts.push(memberCode);
-    bodyCurrentContext = newContext;
-  }
-
-  if (propertyParts.length > 0) {
-    parts.push(propertyParts.join("\n"));
-  }
-
-  parts.push(`${ind}}`);
-
-  // Return context at original indent level
-  return [parts.join("\n"), context];
-};

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

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