@tsonic/emitter 0.0.1 → 0.0.3

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}"');
-  });
-});

package/src/core/module-map.ts

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

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

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

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

package/src/emitter-types/core.ts

@@ -1,138 +0,0 @@
-/**
- * Core emitter types
- */
-
-import type { MetadataFile } from "@tsonic/frontend/types/metadata.js";
-import type { TypeBinding } from "@tsonic/frontend/types/bindings.js";
-
-/**
- * Module identity for import resolution
- */
-export type ModuleIdentity = {
-  readonly namespace: string;
-  readonly className: string;
-  readonly filePath: string;
-};
-
-/**
- * Module map for resolving cross-file imports
- */
-export type ModuleMap = ReadonlyMap<string, ModuleIdentity>;
-
-/**
- * Export source: where an export actually comes from
- * Used to resolve re-exports to their original source
- */
-export type ExportSource = {
-  /** Canonical file path of the actual source */
-  readonly sourceFile: string;
-  /** Name of the export in the source file */
-  readonly sourceName: string;
-};
-
-/**
- * Map from (moduleFilePath, exportName) to actual source
- * Key format: "moduleFilePath:exportName"
- */
-export type ExportMap = ReadonlyMap<string, ExportSource>;
-
-/**
- * Options for C# code generation
- */
-export type EmitterOptions = {
-  /** Root namespace for the application */
-  readonly rootNamespace: string;
-  /** Whether to include source map comments */
-  readonly includeSourceMaps?: boolean;
-  /** Indentation style (spaces) */
-  readonly indent?: number;
-  /** Maximum line length */
-  readonly maxLineLength?: number;
-  /** Include timestamp in generated files */
-  readonly includeTimestamp?: boolean;
-  /** Whether this module is an entry point (needs Main method) */
-  readonly isEntryPoint?: boolean;
-  /** Entry point file path (for batch emit) */
-  readonly entryPointPath?: string;
-  /** External library paths (contain .metadata and .bindings directories) */
-  readonly libraries?: readonly string[];
-  /** Runtime mode: "js" uses Tsonic.JSRuntime extensions, "dotnet" uses pure .NET */
-  readonly runtime?: "js" | "dotnet";
-  /** Module map for resolving cross-file imports (populated during batch emission) */
-  readonly moduleMap?: ModuleMap;
-  /** Export map for resolving re-exports to actual source (populated during batch emission) */
-  readonly exportMap?: ExportMap;
-};
-
-/**
- * Import binding information for qualifying imported identifiers.
- * Local module imports are always emitted as fully-qualified references
- * to avoid C# name ambiguity.
- *
- * All CLR name resolution is done in the frontend - the emitter just uses
- * the pre-computed clrName directly (no string parsing or type lookup).
- */
-export type ImportBinding = {
-  /** Import kind: type (interface/class), value (function/variable), or namespace (import *) */
-  readonly kind: "type" | "value" | "namespace";
-  /**
-   * Fully-qualified CLR name.
-   * - For types: the type's FQN (e.g., "MultiFileTypes.models.User")
-   * - For values/namespaces: the container class FQN (e.g., "MultiFileTypes.models.user")
-   */
-  readonly clrName: string;
-  /** For value imports: the member name inside the container (e.g., "createUser") */
-  readonly member?: string;
-};
-
-/**
- * Context passed through emission process
- */
-export type EmitterContext = {
-  /** Current indentation level */
-  readonly indentLevel: number;
-  /** Options for emission */
-  readonly options: EmitterOptions;
-  /** Whether currently in static context */
-  readonly isStatic: boolean;
-  /** Whether currently in async context */
-  readonly isAsync: boolean;
-  /** Whether currently emitting an array index (omit .0 from integer literals) */
-  readonly isArrayIndex?: boolean;
-  /** Current class name (for constructor emission) */
-  readonly className?: string;
-  /** Whether the current class has a superclass (for virtual/override) */
-  readonly hasSuperClass?: boolean;
-  /** Whether the module has any inheritance (to decide virtual methods) */
-  readonly hasInheritance?: boolean;
-  /** Loaded .NET metadata files (for CLR type information) */
-  readonly metadata?: ReadonlyArray<MetadataFile>;
-  /** Registry mapping TypeScript emit names to type bindings */
-  readonly bindingsRegistry?: ReadonlyMap<string, TypeBinding>;
-  /** Map of local names to import binding info (for qualifying imported identifiers) */
-  readonly importBindings?: ReadonlyMap<string, ImportBinding>;
-  /** Set of variable names known to be int (from canonical for-loop counters) */
-  readonly intLoopVars?: ReadonlySet<string>;
-};
-
-/**
- * Result of emitting C# code
- */
-export type EmitResult = {
-  /** The generated C# code */
-  readonly code: string;
-  /** Updated context after emission */
-  readonly context: EmitterContext;
-};
-
-/**
- * Helper type for C# code fragments
- */
-export type CSharpFragment = {
-  /** The code fragment */
-  readonly text: string;
-  /** Whether this needs parentheses when used in expressions */
-  readonly needsParens?: boolean;
-  /** Precedence level for operator expressions */
-  readonly precedence?: number;
-};

package/src/emitter-types/csharp-types.ts

@@ -1,42 +0,0 @@
-/**
- * C# language-specific types
- */
-
-/**
- * C# access modifiers
- */
-export type CSharpAccessModifier =
-  | "public"
-  | "private"
-  | "protected"
-  | "internal"
-  | "protected internal";
-
-/**
- * C# class modifiers
- */
-export type CSharpClassModifier = "static" | "abstract" | "sealed" | "partial";
-
-/**
- * C# method modifiers
- */
-export type CSharpMethodModifier =
-  | "static"
-  | "virtual"
-  | "override"
-  | "abstract"
-  | "async"
-  | "new"
-  | "sealed";
-
-/**
- * Represents a C# using statement
- */
-export type CSharpUsing = {
-  /** The namespace to import */
-  readonly namespace: string;
-  /** Whether this is a static import */
-  readonly isStatic?: boolean;
-  /** Alias for the import */
-  readonly alias?: string;
-};