@tsonic/emitter 0.0.1 → 0.0.2

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;
-};

package/src/emitter-types/formatting.ts

@@ -1,13 +0,0 @@
-/**
- * Formatting helper functions
- */
-
-import { EmitterContext } from "./core.js";
-
-/**
- * Get indentation string for current level
- */
-export const getIndent = (context: EmitterContext): string => {
-  const spaces = context.options.indent ?? 4;
-  return " ".repeat(spaces * context.indentLevel);
-};

package/src/emitter-types/fqn.ts

@@ -1,81 +0,0 @@
-/**
- * Fully Qualified Name (FQN) rendering utilities
- *
- * All types and members are emitted with global:: prefix to eliminate
- * any ambiguity from C# using statements or namespace resolution.
- */
-
-/**
- * Render a fully qualified type name with global:: prefix
- * e.g., "System.Collections.Generic.List" → "global::System.Collections.Generic.List"
- */
-export const renderTypeFQN = (namespace: string, typeName: string): string => {
-  return `global::${namespace}.${typeName}`;
-};
-
-/**
- * Render a fully qualified static member access with global:: prefix
- * e.g., ("System", "Console", "WriteLine") → "global::System.Console.WriteLine"
- */
-export const renderMemberFQN = (
-  namespace: string,
-  typeName: string,
-  member: string
-): string => {
-  return `global::${namespace}.${typeName}.${member}`;
-};
-
-/**
- * Render a simple namespace-qualified name with global:: prefix
- * e.g., "System.Console" → "global::System.Console"
- */
-export const renderFQN = (qualifiedName: string): string => {
-  return `global::${qualifiedName}`;
-};
-
-/**
- * Common fully qualified type names used throughout emission
- */
-export const FQN = {
-  // System types
-  Object: "global::System.Object",
-  String: "global::System.String",
-  Int32: "global::System.Int32",
-  Int64: "global::System.Int64",
-  Double: "global::System.Double",
-  Boolean: "global::System.Boolean",
-  Void: "void",
-
-  // System.Collections.Generic
-  List: (elementType: string) =>
-    `global::System.Collections.Generic.List<${elementType}>`,
-  Dictionary: (keyType: string, valueType: string) =>
-    `global::System.Collections.Generic.Dictionary<${keyType}, ${valueType}>`,
-  IEnumerable: (elementType: string) =>
-    `global::System.Collections.Generic.IEnumerable<${elementType}>`,
-
-  // System.Threading.Tasks
-  Task: "global::System.Threading.Tasks.Task",
-  TaskOf: (resultType: string) =>
-    `global::System.Threading.Tasks.Task<${resultType}>`,
-
-  // Tsonic.Runtime
-  TsonicRuntime: {
-    DynamicObject: "global::Tsonic.Runtime.DynamicObject",
-    Union: (types: string) => `global::Tsonic.Runtime.Union<${types}>`,
-  },
-
-  // Tsonic.JSRuntime
-  TsonicJSRuntime: {
-    Array: "global::Tsonic.JSRuntime.Array",
-    String: "global::Tsonic.JSRuntime.String",
-    Number: "global::Tsonic.JSRuntime.Number",
-    Math: "global::Tsonic.JSRuntime.Math",
-    Console: "global::Tsonic.JSRuntime.Console",
-  },
-
-  // System.Func delegates
-  Func: (typeArgs: string) => `global::System.Func<${typeArgs}>`,
-  Action: "global::System.Action",
-  ActionOf: (typeArgs: string) => `global::System.Action<${typeArgs}>`,
-} as const;

package/src/emitter-types/index.ts

@@ -1,31 +0,0 @@
-/**
- * Emitter types - Public API
- */
-
-export type {
-  EmitterOptions,
-  EmitterContext,
-  EmitResult,
-  CSharpFragment,
-  ImportBinding,
-  ModuleIdentity,
-  ModuleMap,
-  ExportSource,
-  ExportMap,
-} from "./core.js";
-export type {
-  CSharpAccessModifier,
-  CSharpClassModifier,
-  CSharpMethodModifier,
-  CSharpUsing,
-} from "./csharp-types.js";
-export {
-  createContext,
-  indent,
-  dedent,
-  withStatic,
-  withAsync,
-  withClassName,
-} from "./context.js";
-export { getIndent } from "./formatting.js";
-export { renderTypeFQN, renderMemberFQN, renderFQN, FQN } from "./fqn.js";