@tsonic/emitter 0.0.1 → 0.0.3

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

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

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

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

@@ -1,13 +0,0 @@
-/**
- * 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";