@tsonic/emitter 0.0.1 → 0.0.3

package/src/core/imports.ts

@@ -1,243 +0,0 @@
-/**
- * Import processing and resolution
- *
- * All imports are resolved to fully-qualified global:: references.
- * No using statements are emitted - everything uses explicit FQN.
- *
- * All CLR name resolution happens here using module map - the emitter
- * just uses the pre-computed clrName directly (no string parsing).
- */
-
-import { IrImport, IrModule, IrImportSpecifier } from "@tsonic/frontend";
-import { EmitterContext, ImportBinding } from "../types.js";
-import { resolveImportPath } from "./module-map.js";
-
-/**
- * Process imports and build ImportBindings for local modules.
- *
- * NOTE: No using statements are collected. All type/member references
- * are emitted as fully-qualified global:: names.
- *
- * - BCL/runtime imports: No action needed (types use global:: FQN)
- * - Local module imports: Build ImportBindings with fully-qualified CLR names
- */
-export const processImports = (
-  imports: readonly IrImport[],
-  context: EmitterContext,
-  module: IrModule
-): EmitterContext => {
-  const importBindings = new Map<string, ImportBinding>();
-
-  const updatedContext = imports.reduce((ctx, imp) => {
-    // BCL/runtime imports: No using needed, types are emitted with global:: FQN
-    // .NET imports: No using needed, types are emitted with global:: FQN
-
-    if (imp.isLocal) {
-      // Local import - build ImportBindings with fully-qualified CLR names
-      // NO using directive for local modules
-      const moduleMap = ctx.options.moduleMap;
-      const exportMap = ctx.options.exportMap;
-      if (moduleMap) {
-        const targetPath = resolveImportPath(module.filePath, imp.source);
-
-        // Process each import specifier - may need to resolve re-exports
-        for (const spec of imp.specifiers) {
-          const exportName =
-            spec.kind === "named"
-              ? spec.name
-              : spec.kind === "default"
-                ? ""
-                : "";
-
-          // Check if this is a re-export - look up in export map
-          const reexportKey = `${targetPath}:${exportName}`;
-          const reexportSource = exportMap?.get(reexportKey);
-
-          // Determine the actual source module
-          const actualSourcePath = reexportSource?.sourceFile ?? targetPath;
-          const actualExportName = reexportSource?.sourceName ?? exportName;
-          const targetModule = moduleMap.get(actualSourcePath);
-
-          if (targetModule) {
-            const binding = createImportBinding(
-              spec,
-              targetModule.namespace,
-              targetModule.className,
-              actualExportName
-            );
-            if (binding) {
-              importBindings.set(binding.localName, binding.importBinding);
-            }
-          }
-        }
-        // If module not found in map, it's a compilation error - will be caught elsewhere
-      }
-      // No module map = single file compilation, no import bindings needed
-    }
-
-    // External packages not supported in MVP
-    return ctx;
-  }, context);
-
-  // Add import bindings to context
-  return {
-    ...updatedContext,
-    importBindings,
-  };
-};
-
-/**
- * Create import binding with fully-qualified global:: CLR names.
- * Uses isType from frontend (set by TS checker) to determine kind.
- *
- * - Type imports: clrName is the type's global:: FQN (global::namespace.TypeName)
- * - Value imports: clrName is the container global:: FQN, member is the export name
- * - Namespace imports: clrName is the container global:: FQN
- */
-const createImportBinding = (
-  spec: IrImportSpecifier,
-  namespace: string,
-  containerClassName: string,
-  resolvedExportName: string
-): { localName: string; importBinding: ImportBinding } | null => {
-  const localName = spec.localName;
-  const containerFqn = `global::${namespace}.${containerClassName}`;
-
-  if (spec.kind === "named") {
-    // Use isType from frontend (determined by TS checker)
-    const isType = spec.isType === true;
-
-    if (isType) {
-      // Type import: clrName is the type's FQN at namespace level
-      // Types are emitted at namespace level, not inside container class
-      return {
-        localName,
-        importBinding: {
-          kind: "type",
-          clrName: `global::${namespace}.${resolvedExportName}`,
-        },
-      };
-    } else {
-      // Value import: clrName is container, member is the export name
-      return {
-        localName,
-        importBinding: {
-          kind: "value",
-          clrName: containerFqn,
-          member: resolvedExportName,
-        },
-      };
-    }
-  }
-
-  if (spec.kind === "default") {
-    // Default export binds to the container class itself
-    // TODO: Consider adding diagnostic for unsupported default exports
-    return {
-      localName,
-      importBinding: {
-        kind: "value",
-        clrName: containerFqn,
-      },
-    };
-  }
-
-  if (spec.kind === "namespace") {
-    // Namespace imports (import * as M) - bind to the container class
-    return {
-      localName,
-      importBinding: {
-        kind: "namespace",
-        clrName: containerFqn,
-      },
-    };
-  }
-
-  return null;
-};
-
-/**
- * Resolve local import to a namespace (legacy fallback for single-file compilation)
- */
-export const resolveLocalImport = (
-  imp: IrImport,
-  currentFilePath: string,
-  rootNamespace: string
-): string | null => {
-  // Normalize paths - handle both Unix and Windows separators
-  const normalize = (p: string) => p.replace(/\\/g, "/");
-  const currentFile = normalize(currentFilePath);
-
-  // Get the directory of the current file
-  const currentDir = currentFile.substring(0, currentFile.lastIndexOf("/"));
-
-  // Resolve the import path relative to current directory
-  const resolvedPath = resolveRelativePath(currentDir, imp.source);
-
-  // Remove .ts extension and get directory path
-  const withoutExtension = resolvedPath.replace(/\.ts$/, "");
-  const dirPath = withoutExtension.substring(
-    0,
-    withoutExtension.lastIndexOf("/")
-  );
-
-  // Convert directory path to namespace - only use path after last "/src/"
-  const relativePath = extractRelativePath(dirPath);
-  const parts = relativePath.split("/").filter((p) => p !== "" && p !== ".");
-
-  return parts.length === 0
-    ? rootNamespace
-    : `${rootNamespace}.${parts.join(".")}`;
-};
-
-/**
- * Resolve a relative import path from a given directory
- */
-const resolveRelativePath = (currentDir: string, source: string): string => {
-  if (source.startsWith("./")) {
-    return `${currentDir}/${source.substring(2)}`;
-  }
-
-  if (source.startsWith("../")) {
-    const parts = currentDir.split("/");
-    const sourceCopy = source;
-    return resolveParentPath(parts, sourceCopy);
-  }
-
-  return `${currentDir}/${source}`;
-};
-
-/**
- * Resolve parent path references (..)
- */
-const resolveParentPath = (parts: string[], source: string): string => {
-  if (!source.startsWith("../")) {
-    return `${parts.join("/")}/${source}`;
-  }
-  return resolveParentPath(parts.slice(0, -1), source.substring(3));
-};
-
-/**
- * Extract relative path from a directory path
- */
-const extractRelativePath = (dirPath: string): string => {
-  const srcIndex = dirPath.lastIndexOf("/src/");
-
-  if (srcIndex >= 0) {
-    return dirPath.substring(srcIndex + 5);
-  }
-
-  if (dirPath.endsWith("/src")) {
-    return "";
-  }
-
-  if (dirPath.startsWith("src/")) {
-    return dirPath.substring(4);
-  }
-
-  if (dirPath === "src") {
-    return "";
-  }
-
-  return "";
-};

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