@tsonic/emitter 0.0.1

package/src/statements/declarations/interfaces.ts

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

package/src/statements/declarations/structs.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Tests for struct emission
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitCSharpFile } from "../../index.js";
+import {
+  IrModule,
+  IrClassDeclaration,
+  IrInterfaceDeclaration,
+} from "@tsonic/frontend";
+
+describe("Struct Emission", () => {
+  it("should emit struct for class with isStruct flag", () => {
+    const classDecl: IrClassDeclaration = {
+      kind: "classDeclaration",
+      name: "Point",
+      members: [
+        {
+          kind: "propertyDeclaration",
+          name: "x",
+          type: { kind: "primitiveType", name: "number" },
+          accessibility: "public",
+          isStatic: false,
+          isReadonly: false,
+        },
+        {
+          kind: "propertyDeclaration",
+          name: "y",
+          type: { kind: "primitiveType", name: "number" },
+          accessibility: "public",
+          isStatic: false,
+          isReadonly: false,
+        },
+      ],
+      implements: [],
+      isExported: true,
+      isStruct: true,
+    };
+
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/Point.ts",
+      namespace: "Geometry",
+      className: "Point",
+      isStaticContainer: false,
+      imports: [],
+      body: [classDecl],
+      exports: [],
+    };
+
+    const result = emitCSharpFile(module);
+    expect(result).to.include("public struct Point");
+    expect(result).to.include("public double x");
+    expect(result).to.include("public double y");
+    expect(result).not.to.include("class Point");
+  });
+
+  it("should emit class for class without isStruct flag", () => {
+    const classDecl: IrClassDeclaration = {
+      kind: "classDeclaration",
+      name: "RegularClass",
+      members: [
+        {
+          kind: "propertyDeclaration",
+          name: "value",
+          type: { kind: "primitiveType", name: "number" },
+          accessibility: "public",
+          isStatic: false,
+          isReadonly: false,
+        },
+      ],
+      implements: [],
+      isExported: true,
+      isStruct: false,
+    };
+
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/RegularClass.ts",
+      namespace: "App",
+      className: "RegularClass",
+      isStaticContainer: false,
+      imports: [],
+      body: [classDecl],
+      exports: [],
+    };
+
+    const result = emitCSharpFile(module);
+    expect(result).to.include("public class RegularClass");
+    expect(result).not.to.include("struct RegularClass");
+  });
+
+  it("should emit struct for interface with isStruct flag", () => {
+    const interfaceDecl: IrInterfaceDeclaration = {
+      kind: "interfaceDeclaration",
+      name: "Vector3D",
+      members: [
+        {
+          kind: "propertySignature",
+          name: "x",
+          type: { kind: "primitiveType", name: "number" },
+          isOptional: false,
+          isReadonly: false,
+        },
+        {
+          kind: "propertySignature",
+          name: "y",
+          type: { kind: "primitiveType", name: "number" },
+          isOptional: false,
+          isReadonly: false,
+        },
+        {
+          kind: "propertySignature",
+          name: "z",
+          type: { kind: "primitiveType", name: "number" },
+          isOptional: false,
+          isReadonly: false,
+        },
+      ],
+      extends: [],
+      isExported: true,
+      isStruct: true,
+    };
+
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/Vector3D.ts",
+      namespace: "Geometry",
+      className: "Vector3D",
+      isStaticContainer: false,
+      imports: [],
+      body: [interfaceDecl],
+      exports: [],
+    };
+
+    const result = emitCSharpFile(module);
+    expect(result).to.include("public struct Vector3D");
+    expect(result).to.include("public double x");
+    expect(result).to.include("public double y");
+    expect(result).to.include("public double z");
+    expect(result).not.to.include("class Vector3D");
+  });
+
+  it("should not emit __brand property for struct", () => {
+    const classDecl: IrClassDeclaration = {
+      kind: "classDeclaration",
+      name: "Coord",
+      members: [
+        {
+          kind: "propertyDeclaration",
+          name: "x",
+          type: { kind: "primitiveType", name: "number" },
+          accessibility: "public",
+          isStatic: false,
+          isReadonly: false,
+        },
+        // __brand should already be filtered by the IR builder,
+        // but test that emitter handles it gracefully
+      ],
+      implements: [],
+      isExported: true,
+      isStruct: true,
+    };
+
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/Coord.ts",
+      namespace: "Geometry",
+      className: "Coord",
+      isStaticContainer: false,
+      imports: [],
+      body: [classDecl],
+      exports: [],
+    };
+
+    const result = emitCSharpFile(module);
+    expect(result).to.include("public struct Coord");
+    expect(result).not.to.include("__brand");
+  });
+});

package/src/statements/declarations/type-aliases.ts

@@ -0,0 +1,104 @@
+/**
+ * Type alias declaration emission
+ */
+
+import { IrStatement } from "@tsonic/frontend";
+import { EmitterContext, getIndent, indent } from "../../types.js";
+import { emitType, emitTypeParameters } from "../../type-emitter.js";
+
+/**
+ * Emit a type alias declaration
+ */
+export const emitTypeAliasDeclaration = (
+  stmt: Extract<IrStatement, { kind: "typeAliasDeclaration" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  // Per spec/16-types-and-interfaces.md §3:
+  // - Structural type aliases generate C# classes with __Alias suffix
+  // - Simple aliases (primitives, references) emit as comments or using aliases
+
+  const ind = getIndent(context);
+  let currentContext = context;
+
+  // Check if this is a structural (object) type alias
+  if (stmt.type.kind === "objectType") {
+    // Generate a sealed class (or struct) for structural type alias
+    const parts: string[] = [];
+
+    const accessibility = stmt.isExported ? "public" : "internal";
+    parts.push(accessibility);
+    // Emit struct or sealed class based on isStruct flag
+    if (stmt.isStruct) {
+      parts.push("struct");
+    } else {
+      parts.push("sealed");
+      parts.push("class");
+    }
+    parts.push(`${stmt.name}__Alias`); // Add __Alias suffix per spec §3.4
+
+    // Type parameters (if any)
+    if (stmt.typeParameters && stmt.typeParameters.length > 0) {
+      const [typeParamsStr, whereClauses, typeParamContext] =
+        emitTypeParameters(stmt.typeParameters, currentContext);
+      parts.push(typeParamsStr);
+      currentContext = typeParamContext;
+
+      if (whereClauses.length > 0) {
+        parts.push(
+          "\n" + ind + "    " + whereClauses.join("\n" + ind + "    ")
+        );
+      }
+    }
+
+    // Generate properties from object type members
+    const bodyContext = indent(currentContext);
+    const properties: string[] = [];
+
+    if (stmt.type.kind === "objectType") {
+      for (const member of stmt.type.members) {
+        if (member.kind === "propertySignature") {
+          const propParts: string[] = [];
+          propParts.push("public");
+
+          // Property type
+          if (member.type) {
+            const [propType, newContext] = emitType(
+              member.type,
+              currentContext
+            );
+            currentContext = newContext;
+            // Optional members become nullable
+            const typeStr = member.isOptional ? `${propType}?` : propType;
+            propParts.push(typeStr);
+          } else {
+            propParts.push(member.isOptional ? "object?" : "object");
+          }
+
+          propParts.push(member.name);
+
+          // Readonly uses private set
+          const accessors = member.isReadonly
+            ? "{ get; private set; }"
+            : "{ get; set; }";
+          propParts.push(accessors);
+
+          // Default initializer
+          propParts.push("= default!;");
+
+          properties.push(`${getIndent(bodyContext)}${propParts.join(" ")}`);
+        }
+      }
+    }
+
+    const signature = parts.join(" ");
+    const propsCode = properties.join("\n");
+    const code = `${ind}${signature}\n${ind}{\n${propsCode}\n${ind}}`;
+
+    return [code, currentContext];
+  }
+
+  // For non-structural aliases, emit as comment (C# using aliases are limited)
+  const [typeName, newContext] = emitType(stmt.type, context);
+  const code = `${ind}// type ${stmt.name} = ${typeName}`;
+  return [code, newContext];
+};

package/src/statements/declarations/variables.ts

@@ -0,0 +1,159 @@
+/**
+ * Variable declaration emission
+ */
+
+import { IrStatement, IrArrayPattern } from "@tsonic/frontend";
+import { EmitterContext, getIndent } from "../../types.js";
+import { emitExpression } from "../../expression-emitter.js";
+import { emitType } from "../../type-emitter.js";
+
+/**
+ * Emit a variable declaration
+ */
+export const emitVariableDeclaration = (
+  stmt: Extract<IrStatement, { kind: "variableDeclaration" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const ind = getIndent(context);
+  let currentContext = context;
+  const declarations: string[] = [];
+
+  for (const decl of stmt.declarations) {
+    let varDecl = "";
+
+    // In static contexts, variable declarations become fields with modifiers
+    if (context.isStatic && stmt.isExported) {
+      varDecl = "public static ";
+      if (stmt.declarationKind === "const") {
+        varDecl += "readonly ";
+      }
+    }
+
+    // Determine the C# type
+    // Priority: 1) Explicit/inferred IR type, 2) Arrow function inference, 3) var
+    if (
+      decl.type &&
+      !(decl.type.kind === "functionType" && !context.isStatic)
+    ) {
+      // Emit explicit type UNLESS it's a function type in a non-static context
+      // (let C# infer lambda types in local contexts)
+      // Note: For module-level exports, type is always set (from annotation or inference)
+      const [typeName, newContext] = emitType(decl.type, currentContext);
+      currentContext = newContext;
+      varDecl += `${typeName} `;
+    } else if (
+      decl.initializer &&
+      decl.initializer.kind === "arrowFunction" &&
+      context.isStatic
+    ) {
+      // For arrow functions in static context without explicit type, infer Func<> type
+      const arrowFunc = decl.initializer;
+      const paramTypes: string[] = [];
+
+      for (const param of arrowFunc.parameters) {
+        if (param.type) {
+          const [paramType, newCtx] = emitType(param.type, currentContext);
+          paramTypes.push(paramType);
+          currentContext = newCtx;
+        } else {
+          // ICE: Frontend validation (TSN7405) should have caught this.
+          const paramName =
+            param.pattern.kind === "identifierPattern"
+              ? param.pattern.name
+              : "unknown";
+          throw new Error(
+            `ICE: Untyped parameter '${paramName}' reached emitter - validation missed TSN7405`
+          );
+        }
+      }
+
+      // Get return type: explicit annotation, or infer from TS checker
+      const arrowReturnType =
+        arrowFunc.returnType ??
+        (arrowFunc.inferredType?.kind === "functionType"
+          ? arrowFunc.inferredType.returnType
+          : undefined);
+
+      if (!arrowReturnType) {
+        // ICE: Neither explicit nor inferred return type available
+        throw new Error(
+          "ICE: Arrow function without return type reached emitter - neither explicit nor inferred type available"
+        );
+      }
+
+      const [returnType, retCtx] = emitType(arrowReturnType, currentContext);
+      currentContext = retCtx;
+
+      const allTypes = [...paramTypes, returnType];
+      const funcType = `global::System.Func<${allTypes.join(", ")}>`;
+      varDecl += `${funcType} `;
+    } else {
+      varDecl += "var ";
+    }
+
+    // Handle different pattern types
+    if (decl.name.kind === "identifierPattern") {
+      // Simple identifier pattern
+      varDecl += decl.name.name;
+
+      // Add initializer if present
+      if (decl.initializer) {
+        const [initFrag, newContext] = emitExpression(
+          decl.initializer,
+          currentContext,
+          decl.type // Pass expected type for contextual typing (e.g., array literals)
+        );
+        currentContext = newContext;
+        varDecl += ` = ${initFrag.text}`;
+      }
+
+      declarations.push(`${ind}${varDecl};`);
+    } else if (decl.name.kind === "arrayPattern") {
+      // Array destructuring: const [a, b] = arr; -> var a = arr[0]; var b = arr[1];
+      if (!decl.initializer) {
+        // Array destructuring requires an initializer
+        declarations.push(
+          `${ind}${varDecl}/* array destructuring without initializer */;`
+        );
+        continue;
+      }
+
+      const [initFrag, newContext] = emitExpression(
+        decl.initializer,
+        currentContext,
+        decl.type
+      );
+      currentContext = newContext;
+
+      const arrayPattern = decl.name as IrArrayPattern;
+      // Use global:: prefix for Tsonic.Runtime.Array static helpers
+      for (let i = 0; i < arrayPattern.elements.length; i++) {
+        const element = arrayPattern.elements[i];
+        if (element && element.kind === "identifierPattern") {
+          // Use double literal for index (JavaScript uses doubles for all numbers)
+          const elementVarDecl = `${varDecl}${element.name} = global::Tsonic.Runtime.Array.get(${initFrag.text}, ${i}.0);`;
+          declarations.push(`${ind}${elementVarDecl}`);
+        }
+        // Skip undefined elements (holes in array pattern)
+      }
+    } else {
+      // Object destructuring or other patterns - not yet supported
+      varDecl += "/* destructuring */";
+
+      // Add initializer if present
+      if (decl.initializer) {
+        const [initFrag, newContext] = emitExpression(
+          decl.initializer,
+          currentContext,
+          decl.type
+        );
+        currentContext = newContext;
+        varDecl += ` = ${initFrag.text}`;
+      }
+
+      declarations.push(`${ind}${varDecl};`);
+    }
+  }
+
+  return [declarations.join("\n"), currentContext];
+};

package/src/statements/declarations.ts

@@ -0,0 +1,13 @@
+/**
+ * Declaration emitters (variables, functions, classes, interfaces, enums, type aliases)
+ * Main dispatcher - re-exports from declarations/ subdirectory
+ */
+
+export {
+  emitVariableDeclaration,
+  emitFunctionDeclaration,
+  emitClassDeclaration,
+  emitInterfaceDeclaration,
+  emitEnumDeclaration,
+  emitTypeAliasDeclaration,
+} from "./declarations/index.js";