@tsonic/emitter 0.0.1 → 0.0.2

package/src/core/module-emitter/assembly.ts

@@ -1,83 +0,0 @@
-/**
- * Final output assembly
- *
- * NOTE: No using statements are emitted. All type and member references
- * use fully-qualified global:: names to eliminate any ambiguity.
- */
-
-import { IrModule } from "@tsonic/frontend";
-import { EmitterContext } from "../../types.js";
-
-export type AssemblyParts = {
-  readonly header: string;
-  readonly adaptersCode: string;
-  readonly specializationsCode: string;
-  readonly exchangesCode: string;
-  readonly namespaceDeclsCode: string;
-  readonly staticContainerCode: string;
-};
-
-/**
- * Assemble final C# output from all parts
- */
-export const assembleOutput = (
-  module: IrModule,
-  parts: AssemblyParts,
-  _finalContext: EmitterContext
-): string => {
-  const result: string[] = [];
-
-  if (parts.header) {
-    result.push(parts.header);
-  }
-
-  result.push(`namespace ${module.namespace}`);
-  result.push("{");
-
-  // Emit adapters before class code
-  if (parts.adaptersCode) {
-    const indentedAdapters = parts.adaptersCode
-      .split("\n")
-      .map((line) => (line ? "    " + line : line))
-      .join("\n");
-    result.push(indentedAdapters);
-    result.push("");
-  }
-
-  // Emit specializations after adapters
-  if (parts.specializationsCode) {
-    const indentedSpecializations = parts.specializationsCode
-      .split("\n")
-      .map((line) => (line ? "    " + line : line))
-      .join("\n");
-    result.push(indentedSpecializations);
-    result.push("");
-  }
-
-  // Emit generator exchange objects after specializations
-  if (parts.exchangesCode) {
-    const indentedExchanges = parts.exchangesCode
-      .split("\n")
-      .map((line) => (line ? "    " + line : line))
-      .join("\n");
-    result.push(indentedExchanges);
-    result.push("");
-  }
-
-  // Emit namespace-level declarations first
-  if (parts.namespaceDeclsCode) {
-    result.push(parts.namespaceDeclsCode);
-  }
-
-  // Then emit static container if needed
-  if (parts.staticContainerCode) {
-    if (parts.namespaceDeclsCode) {
-      result.push("");
-    }
-    result.push(parts.staticContainerCode);
-  }
-
-  result.push("}");
-
-  return result.join("\n");
-};

package/src/core/module-emitter/header.ts

@@ -1,19 +0,0 @@
-/**
- * File header generation
- */
-
-import { IrModule } from "@tsonic/frontend";
-import { EmitterOptions } from "../../types.js";
-import { generateFileHeader } from "../../constants.js";
-
-/**
- * Generate file header with source info
- */
-export const generateHeader = (
-  module: IrModule,
-  options: EmitterOptions
-): string => {
-  return generateFileHeader(module.filePath, {
-    includeTimestamp: options.includeTimestamp,
-  });
-};

package/src/core/module-emitter/namespace.ts

@@ -1,39 +0,0 @@
-/**
- * Namespace-level declaration emission
- */
-
-import { IrStatement } from "@tsonic/frontend";
-import { EmitterContext, indent } from "../../types.js";
-import { emitStatement } from "../../statement-emitter.js";
-
-export type NamespaceEmissionResult = {
-  readonly code: string;
-  readonly context: EmitterContext;
-};
-
-/**
- * Emit namespace-level declarations (classes, interfaces)
- */
-export const emitNamespaceDeclarations = (
-  declarations: readonly IrStatement[],
-  baseContext: EmitterContext,
-  hasInheritance: boolean
-): NamespaceEmissionResult => {
-  const namespaceParts: string[] = [];
-  const namespaceContext = { ...indent(baseContext), hasInheritance };
-  let currentContext = namespaceContext;
-
-  for (const decl of declarations) {
-    // Use the same base context for each declaration to maintain consistent indentation
-    const [code, newContext] = emitStatement(decl, namespaceContext);
-    namespaceParts.push(code);
-    // Track context for using statements, but don't let indentation accumulate
-    // Preserve the hasInheritance flag
-    currentContext = { ...newContext, hasInheritance };
-  }
-
-  return {
-    code: namespaceParts.join("\n"),
-    context: currentContext,
-  };
-};

package/src/core/module-emitter/orchestrator.ts

@@ -1,98 +0,0 @@
-/**
- * Module emission orchestrator
- */
-
-import { IrModule } from "@tsonic/frontend";
-import { EmitterOptions, createContext } from "../../types.js";
-import { generateStructuralAdapters } from "../../adapter-generator.js";
-import {
-  collectSpecializations,
-  generateSpecializations,
-} from "../../specialization-generator.js";
-import { generateGeneratorExchanges } from "../../generator-exchange.js";
-import { defaultOptions } from "../options.js";
-import { collectTypeParameters } from "../type-params.js";
-import { processImports } from "../imports.js";
-import { generateHeader } from "./header.js";
-import { separateStatements } from "./separation.js";
-import { emitNamespaceDeclarations } from "./namespace.js";
-import {
-  emitStaticContainer,
-  hasMatchingClassName,
-} from "./static-container.js";
-import { assembleOutput, type AssemblyParts } from "./assembly.js";
-
-/**
- * Emit C# code from an IR module
- */
-export const emitModule = (
-  module: IrModule,
-  options: Partial<EmitterOptions> = {}
-): string => {
-  const finalOptions: EmitterOptions = { ...defaultOptions, ...options };
-  const context = createContext(finalOptions);
-
-  // Generate file header
-  const header = generateHeader(module, finalOptions);
-
-  // Process imports to collect using statements
-  const processedContext = processImports(module.imports, context, module);
-
-  // Collect type parameters and generate adapters
-  const typeParams = collectTypeParameters(module);
-  const [adaptersCode, adaptersContext] = generateStructuralAdapters(
-    typeParams,
-    processedContext
-  );
-
-  // Collect specializations and generate monomorphized versions
-  const specializations = collectSpecializations(module);
-  const [specializationsCode, specializationsContext] = generateSpecializations(
-    specializations,
-    adaptersContext
-  );
-
-  // Generate exchange objects for generators
-  const [exchangesCode, exchangesContext] = generateGeneratorExchanges(
-    module,
-    specializationsContext
-  );
-
-  // Separate namespace-level declarations from static container members
-  const { namespaceLevelDecls, staticContainerMembers, hasInheritance } =
-    separateStatements(module);
-
-  // Emit namespace-level declarations (classes, interfaces)
-  const namespaceResult = emitNamespaceDeclarations(
-    namespaceLevelDecls,
-    exchangesContext,
-    hasInheritance
-  );
-
-  // Emit static container class unless there's a namespace-level class with same name
-  let staticContainerCode = "";
-  let finalContext = namespaceResult.context;
-
-  if (!hasMatchingClassName(namespaceLevelDecls, module.className)) {
-    const containerResult = emitStaticContainer(
-      module,
-      staticContainerMembers,
-      namespaceResult.context, // Use context from namespace declarations to preserve usings
-      hasInheritance
-    );
-    staticContainerCode = containerResult.code;
-    finalContext = containerResult.context;
-  }
-
-  // Assemble final output
-  const parts: AssemblyParts = {
-    header,
-    adaptersCode,
-    specializationsCode,
-    exchangesCode,
-    namespaceDeclsCode: namespaceResult.code,
-    staticContainerCode,
-  };
-
-  return assembleOutput(module, parts, finalContext);
-};

package/src/core/module-emitter/separation.ts

@@ -1,41 +0,0 @@
-/**
- * Statement separation logic
- */
-
-import { IrModule, IrStatement } from "@tsonic/frontend";
-
-export type SeparatedStatements = {
-  readonly namespaceLevelDecls: readonly IrStatement[];
-  readonly staticContainerMembers: readonly IrStatement[];
-  readonly hasInheritance: boolean;
-};
-
-/**
- * Separate namespace-level declarations from static container members
- */
-export const separateStatements = (module: IrModule): SeparatedStatements => {
-  const namespaceLevelDecls: IrStatement[] = [];
-  const staticContainerMembers: IrStatement[] = [];
-
-  // Detect if module has any inheritance (for virtual/override keywords)
-  const hasInheritance = module.body.some(
-    (stmt) => stmt.kind === "classDeclaration" && stmt.superClass
-  );
-
-  for (const stmt of module.body) {
-    if (
-      stmt.kind === "classDeclaration" ||
-      stmt.kind === "interfaceDeclaration"
-    ) {
-      namespaceLevelDecls.push(stmt);
-    } else {
-      staticContainerMembers.push(stmt);
-    }
-  }
-
-  return {
-    namespaceLevelDecls,
-    staticContainerMembers,
-    hasInheritance,
-  };
-};

package/src/core/module-emitter/static-container.ts

@@ -1,75 +0,0 @@
-/**
- * Static container class emission
- */
-
-import { IrModule, IrStatement } from "@tsonic/frontend";
-import { EmitterContext, indent, getIndent, withStatic } from "../../types.js";
-import { emitStatement } from "../../statement-emitter.js";
-import { emitExport } from "../exports.js";
-
-export type StaticContainerResult = {
-  readonly code: string;
-  readonly context: EmitterContext;
-};
-
-/**
- * Check if there's a namespace-level class with the same name as the module
- */
-export const hasMatchingClassName = (
-  declarations: readonly IrStatement[],
-  className: string
-): boolean => {
-  return declarations.some(
-    (decl) =>
-      (decl.kind === "classDeclaration" ||
-        decl.kind === "interfaceDeclaration") &&
-      decl.name === className
-  );
-};
-
-/**
- * Emit static container class for module-level members
- */
-export const emitStaticContainer = (
-  module: IrModule,
-  members: readonly IrStatement[],
-  baseContext: EmitterContext,
-  hasInheritance: boolean
-): StaticContainerResult => {
-  const classContext = withStatic(indent(baseContext), true);
-  const bodyContext = indent(classContext);
-  const ind = getIndent(classContext);
-
-  const containerParts: string[] = [];
-  containerParts.push(`${ind}public static class ${module.className}`);
-  containerParts.push(`${ind}{`);
-
-  const bodyParts: string[] = [];
-  let bodyCurrentContext = bodyContext;
-
-  for (const stmt of members) {
-    const [code, newContext] = emitStatement(stmt, bodyCurrentContext);
-    bodyParts.push(code);
-    bodyCurrentContext = newContext;
-  }
-
-  // Handle explicit exports
-  for (const exp of module.exports) {
-    const exportCode = emitExport(exp, bodyCurrentContext);
-    if (exportCode[0]) {
-      bodyParts.push(exportCode[0]);
-      bodyCurrentContext = exportCode[1];
-    }
-  }
-
-  if (bodyParts.length > 0) {
-    containerParts.push(bodyParts.join("\n\n"));
-  }
-
-  containerParts.push(`${ind}}`);
-
-  return {
-    code: containerParts.join("\n"),
-    context: { ...bodyCurrentContext, hasInheritance },
-  };
-};

package/src/core/module-emitter.test.ts

@@ -1,154 +0,0 @@
-/**
- * Tests for Module Generation
- * Tests emission of static containers and regular classes
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Module Generation", () => {
-  it("should emit a static container class", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/math.ts",
-      namespace: "MyApp",
-      className: "math",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "PI" },
-              initializer: { kind: "literal", value: 3.14159 },
-            },
-          ],
-          isExported: true,
-        },
-        {
-          kind: "functionDeclaration",
-          name: "add",
-          parameters: [
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "a" },
-              type: { kind: "primitiveType", name: "number" },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "b" },
-              type: { kind: "primitiveType", name: "number" },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-          ],
-          returnType: { kind: "primitiveType", name: "number" },
-          body: {
-            kind: "blockStatement",
-            statements: [
-              {
-                kind: "returnStatement",
-                expression: {
-                  kind: "binary",
-                  operator: "+",
-                  left: { kind: "identifier", name: "a" },
-                  right: { kind: "identifier", name: "b" },
-                },
-              },
-            ],
-          },
-          isExported: true,
-          isAsync: false,
-          isGenerator: false,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public static class math");
-    expect(result).to.include("var PI = 3.14159");
-    expect(result).to.include("public static double add(double a, double b)");
-    expect(result).to.include("return a + b");
-    expect(result).to.include("namespace MyApp");
-  });
-
-  it("should emit a regular class", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/User.ts",
-      namespace: "MyApp",
-      className: "User",
-      isStaticContainer: false,
-      imports: [],
-      body: [
-        {
-          kind: "classDeclaration",
-          name: "User",
-          members: [
-            {
-              kind: "propertyDeclaration",
-              name: "name",
-              type: { kind: "primitiveType", name: "string" },
-              accessibility: "public",
-              isStatic: false,
-              isReadonly: false,
-            },
-            {
-              kind: "methodDeclaration",
-              name: "greet",
-              parameters: [],
-              returnType: { kind: "primitiveType", name: "string" },
-              body: {
-                kind: "blockStatement",
-                statements: [
-                  {
-                    kind: "returnStatement",
-                    expression: {
-                      kind: "templateLiteral",
-                      quasis: ["Hello, I'm ", ""],
-                      expressions: [
-                        {
-                          kind: "memberAccess",
-                          object: { kind: "this" },
-                          property: "name",
-                          isComputed: false,
-                          isOptional: false,
-                        },
-                      ],
-                    },
-                  },
-                ],
-              },
-              accessibility: "public",
-              isStatic: false,
-              isAsync: false,
-              isGenerator: false,
-            },
-          ],
-          isStruct: false,
-          isExported: true,
-          implements: [],
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public class User");
-    expect(result).to.include("public string name;");
-    expect(result).to.include("public string greet()");
-    expect(result).to.include('$"Hello, I\'m {this.name}"');
-  });
-});