@tsonic/emitter 0.0.1

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

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

@@ -0,0 +1,154 @@
+/**
+ * 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}"');
+  });
+});

package/src/core/module-emitter.ts

@@ -0,0 +1,6 @@
+/**
+ * Main module emission logic
+ * Main dispatcher - re-exports from module-emitter/ subdirectory
+ */
+
+export { emitModule } from "./module-emitter/index.js";

package/src/core/module-map.ts

@@ -0,0 +1,218 @@
+/**
+ * Module map for resolving cross-file imports
+ */
+
+import { IrModule, Diagnostic } from "@tsonic/frontend";
+import type {
+  ModuleIdentity,
+  ModuleMap,
+  ExportSource,
+  ExportMap,
+} from "../emitter-types/core.js";
+
+// Re-export types for backward compatibility
+export type { ModuleIdentity, ModuleMap, ExportSource, ExportMap };
+
+/**
+ * Normalize a file path for use as module map key
+ * - Convert backslashes to forward slashes
+ * - Remove .ts extension if present
+ * - Normalize . and .. segments
+ */
+export const canonicalizeFilePath = (filePath: string): string => {
+  // Normalize slashes
+  let normalized = filePath.replace(/\\/g, "/");
+
+  // Remove .ts extension
+  if (normalized.endsWith(".ts")) {
+    normalized = normalized.slice(0, -3);
+  }
+
+  // Split into segments and resolve . and ..
+  const segments: string[] = [];
+  for (const segment of normalized.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue; // Skip empty and current directory
+    } else if (segment === "..") {
+      segments.pop(); // Go up one directory
+    } else {
+      segments.push(segment);
+    }
+  }
+
+  return segments.join("/");
+};
+
+/**
+ * Result of building module map
+ */
+export type ModuleMapResult =
+  | {
+      readonly ok: true;
+      readonly value: ModuleMap;
+      readonly exportMap: ExportMap;
+    }
+  | { readonly ok: false; readonly errors: readonly Diagnostic[] };
+
+/**
+ * Build module map from IR modules.
+ * Returns an error if any two files in the same namespace have the same
+ * normalized class name (e.g., api-client.ts and apiclient.ts both map to "apiclient").
+ */
+export const buildModuleMap = (
+  modules: readonly IrModule[]
+): ModuleMapResult => {
+  const map = new Map<string, ModuleIdentity>();
+  const errors: Diagnostic[] = [];
+
+  // Group modules by namespace to detect class name collisions
+  const byNamespace = new Map<string, IrModule[]>();
+  for (const module of modules) {
+    const existing = byNamespace.get(module.namespace) ?? [];
+    byNamespace.set(module.namespace, [...existing, module]);
+  }
+
+  // Check for collisions within each namespace
+  for (const [namespace, nsModules] of byNamespace) {
+    const byClassName = new Map<string, IrModule[]>();
+    for (const module of nsModules) {
+      const existing = byClassName.get(module.className) ?? [];
+      byClassName.set(module.className, [...existing, module]);
+    }
+
+    // Report collisions
+    for (const [className, colliding] of byClassName) {
+      if (colliding.length > 1) {
+        const fileNames = colliding
+          .map((m) => `'${m.filePath.split("/").pop()}'`)
+          .join(" and ");
+        errors.push({
+          code: "TSN9001",
+          message: `File name collision after normalization: ${fileNames} both map to class '${className}' in namespace '${namespace}'. Rename one file.`,
+          severity: "error",
+        });
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+
+  // Build the map
+  for (const module of modules) {
+    const canonicalPath = canonicalizeFilePath(module.filePath);
+    map.set(canonicalPath, {
+      namespace: module.namespace,
+      className: module.className,
+      filePath: canonicalPath,
+    });
+  }
+
+  // Build the export map
+  const exportMap = buildExportMap(modules);
+
+  return { ok: true, value: map, exportMap };
+};
+
+/**
+ * Build export map from IR modules.
+ * Maps (modulePath, exportName) -> actual source for re-exports.
+ */
+const buildExportMap = (modules: readonly IrModule[]): ExportMap => {
+  const exportMap = new Map<string, ExportSource>();
+
+  // First pass: collect all re-exports
+  for (const module of modules) {
+    const modulePath = canonicalizeFilePath(module.filePath);
+
+    for (const exp of module.exports) {
+      if (exp.kind === "reexport") {
+        // Resolve the source module path
+        const sourcePath = resolveImportPath(module.filePath, exp.fromModule);
+        const key = `${modulePath}:${exp.name}`;
+        exportMap.set(key, {
+          sourceFile: sourcePath,
+          sourceName: exp.originalName,
+        });
+      }
+    }
+  }
+
+  // Second pass: resolve transitive re-exports
+  // Keep resolving until no changes (handles chains like A re-exports from B re-exports from C)
+  const resolveTransitive = (): boolean => {
+    let changed = false;
+
+    for (const [key, source] of exportMap) {
+      const transitiveKey = `${source.sourceFile}:${source.sourceName}`;
+      const transitiveSource = exportMap.get(transitiveKey);
+
+      if (transitiveSource) {
+        // This is a transitive re-export - update to point to the actual source
+        exportMap.set(key, transitiveSource);
+        changed = true;
+      }
+    }
+
+    return changed;
+  };
+
+  // Resolve transitive re-exports (max 10 iterations to prevent infinite loops)
+  for (let i = 0; i < 10 && resolveTransitive(); i++) {
+    // Keep resolving
+  }
+
+  return exportMap;
+};
+
+/**
+ * Resolve a relative import path to a canonical file path
+ */
+export const resolveImportPath = (
+  currentFilePath: string,
+  importSource: string
+): string => {
+  // Normalize current file path
+  const currentCanonical = canonicalizeFilePath(currentFilePath);
+
+  // Get directory of current file
+  const lastSlash = currentCanonical.lastIndexOf("/");
+  const currentDir = lastSlash >= 0 ? currentCanonical.slice(0, lastSlash) : "";
+
+  // Normalize import source
+  let source = importSource.replace(/\\/g, "/");
+
+  // Remove .ts extension if present
+  if (source.endsWith(".ts")) {
+    source = source.slice(0, -3);
+  }
+
+  // Resolve relative path
+  let resolvedPath: string;
+  if (source.startsWith("./")) {
+    // Same directory or subdirectory
+    resolvedPath = currentDir
+      ? `${currentDir}/${source.slice(2)}`
+      : source.slice(2);
+  } else if (source.startsWith("../")) {
+    // Parent directory
+    const parts = currentDir.split("/");
+    let remaining = source;
+    while (remaining.startsWith("../")) {
+      parts.pop();
+      remaining = remaining.slice(3);
+    }
+    resolvedPath =
+      parts.length > 0 ? `${parts.join("/")}/${remaining}` : remaining;
+  } else if (source.startsWith("/")) {
+    // Absolute path (remove leading slash)
+    resolvedPath = source.slice(1);
+  } else {
+    // No ./ or ../, treat as same directory
+    resolvedPath = currentDir ? `${currentDir}/${source}` : source;
+  }
+
+  // Canonicalize the result
+  return canonicalizeFilePath(resolvedPath);
+};

package/src/core/options.ts

@@ -0,0 +1,16 @@
+/**
+ * Emitter options and defaults
+ */
+
+import { EmitterOptions } from "../types.js";
+
+/**
+ * Default emitter options
+ */
+export const defaultOptions: EmitterOptions = {
+  rootNamespace: "MyApp",
+  includeSourceMaps: false,
+  indent: 4,
+  maxLineLength: 120,
+  includeTimestamp: true,
+};

package/src/core/type-params.ts

@@ -0,0 +1,34 @@
+/**
+ * Type parameter collection
+ */
+
+import { IrModule, IrTypeParameter } from "@tsonic/frontend";
+
+/**
+ * Collect all type parameters from declarations in a module
+ */
+export const collectTypeParameters = (
+  module: IrModule
+): readonly IrTypeParameter[] => {
+  const typeParams: IrTypeParameter[] = [];
+
+  for (const stmt of module.body) {
+    if (stmt.kind === "functionDeclaration" && stmt.typeParameters) {
+      typeParams.push(...stmt.typeParameters);
+    } else if (stmt.kind === "classDeclaration" && stmt.typeParameters) {
+      typeParams.push(...stmt.typeParameters);
+      // Also collect from class members
+      for (const member of stmt.members) {
+        if (member.kind === "methodDeclaration" && member.typeParameters) {
+          typeParams.push(...member.typeParameters);
+        }
+      }
+    } else if (stmt.kind === "interfaceDeclaration" && stmt.typeParameters) {
+      typeParams.push(...stmt.typeParameters);
+    } else if (stmt.kind === "typeAliasDeclaration" && stmt.typeParameters) {
+      typeParams.push(...stmt.typeParameters);
+    }
+  }
+
+  return typeParams;
+};

package/src/emitter-types/context.ts

@@ -0,0 +1,91 @@
+/**
+ * Context creation and manipulation functions
+ */
+
+import { EmitterOptions, EmitterContext } from "./core.js";
+import {
+  loadLibraries,
+  buildBindingsRegistry,
+} from "@tsonic/frontend/metadata/index.js";
+
+/**
+ * Create a new emitter context with default values
+ */
+export const createContext = (options: EmitterOptions): EmitterContext => {
+  // Load metadata and bindings from library directories
+  let metadata: EmitterContext["metadata"] = undefined;
+  let bindingsRegistry: EmitterContext["bindingsRegistry"] = undefined;
+
+  if (options.libraries && options.libraries.length > 0) {
+    const librariesResult = loadLibraries(options.libraries);
+    if (librariesResult.ok) {
+      metadata = librariesResult.value.metadata;
+      bindingsRegistry = buildBindingsRegistry(librariesResult.value.bindings);
+    } else {
+      // TODO: Report diagnostics from librariesResult.error
+      // Need to integrate diagnostic reporting infrastructure
+      console.warn(
+        "[Tsonic] Failed to load libraries:",
+        librariesResult.error.map((d) => d.message).join(", ")
+      );
+    }
+  }
+
+  return {
+    indentLevel: 0,
+    options,
+    isStatic: false,
+    isAsync: false,
+    metadata,
+    bindingsRegistry,
+  };
+};
+
+/**
+ * Increase indentation level
+ */
+export const indent = (context: EmitterContext): EmitterContext => ({
+  ...context,
+  indentLevel: context.indentLevel + 1,
+});
+
+/**
+ * Decrease indentation level
+ */
+export const dedent = (context: EmitterContext): EmitterContext => ({
+  ...context,
+  indentLevel: Math.max(0, context.indentLevel - 1),
+});
+
+/**
+ * Set static context flag
+ */
+export const withStatic = (
+  context: EmitterContext,
+  isStatic: boolean
+): EmitterContext => ({
+  ...context,
+  isStatic,
+});
+
+/**
+ * Set async context flag
+ */
+export const withAsync = (
+  context: EmitterContext,
+  isAsync: boolean
+): EmitterContext => ({
+  ...context,
+  isAsync,
+});
+
+/**
+ * Set current class name in context
+ */
+export const withClassName = (
+  context: EmitterContext,
+  className: string
+): EmitterContext => ({
+  ...context,
+  className,
+});