@tsonic/emitter 0.0.1 → 0.0.2

package/src/emitter.ts

@@ -1,107 +0,0 @@
-/**
- * Main C# Emitter - Public API
- * Orchestrates code generation from IR
- */
-
-import { IrModule, Diagnostic } from "@tsonic/frontend";
-import { EmitterOptions } from "./types.js";
-import { emitModule } from "./core/module-emitter.js";
-import { buildModuleMap } from "./core/module-map.js";
-
-/**
- * Result of batch emission
- */
-export type EmitResult =
-  | { readonly ok: true; readonly files: Map<string, string> }
-  | { readonly ok: false; readonly errors: readonly Diagnostic[] };
-
-/**
- * Emit a complete C# file from an IR module
- */
-export const emitCSharpFile = (
-  module: IrModule,
-  options: Partial<EmitterOptions> = {}
-): string => {
-  return emitModule(module, options);
-};
-
-/**
- * Batch emit multiple IR modules.
- * Returns an error if there are file name collisions after normalization.
- */
-export const emitCSharpFiles = (
-  modules: readonly IrModule[],
-  options: Partial<EmitterOptions> = {}
-): EmitResult => {
-  // Build module map for cross-file import resolution
-  const moduleMapResult = buildModuleMap(modules);
-
-  if (!moduleMapResult.ok) {
-    return { ok: false, errors: moduleMapResult.errors };
-  }
-
-  const moduleMap = moduleMapResult.value;
-  const exportMap = moduleMapResult.exportMap;
-  const results = new Map<string, string>();
-
-  // Find common root directory for all modules
-  const commonRoot = findCommonRoot(modules.map((m) => m.filePath));
-
-  for (const module of modules) {
-    // Create relative path from common root
-    const relativePath = module.filePath.startsWith(commonRoot)
-      ? module.filePath.slice(commonRoot.length).replace(/^\//, "")
-      : module.filePath;
-    const outputPath = relativePath.replace(/\.ts$/, ".cs");
-
-    // Mark this module as entry point if it matches the entry point path
-    const isEntryPoint = !!(
-      options.entryPointPath && module.filePath === options.entryPointPath
-    );
-    const moduleOptions = {
-      ...options,
-      isEntryPoint,
-      moduleMap, // Pass module map to each module emission
-      exportMap, // Pass export map for re-export resolution
-    };
-    const code = emitModule(module, moduleOptions);
-    results.set(outputPath, code);
-  }
-
-  return { ok: true, files: results };
-};
-
-/**
- * Find the common root directory for a set of file paths
- */
-const findCommonRoot = (paths: readonly string[]): string => {
-  if (paths.length === 0) return "";
-  if (paths.length === 1) {
-    const firstPath = paths[0];
-    if (!firstPath) return "";
-    const lastSlash = firstPath.lastIndexOf("/");
-    return lastSlash >= 0 ? firstPath.slice(0, lastSlash + 1) : "";
-  }
-
-  // Split all paths into segments
-  const segments = paths.map((p) => p.split("/"));
-  const firstSegments = segments[0];
-  if (!firstSegments) return "";
-
-  const minLength = Math.min(...segments.map((s) => s.length));
-
-  let commonLength = 0;
-  for (let i = 0; i < minLength; i++) {
-    const segment = firstSegments[i];
-    if (segment && segments.every((s) => s[i] === segment)) {
-      commonLength = i + 1;
-    } else {
-      break;
-    }
-  }
-
-  return firstSegments.slice(0, commonLength).join("/") + "/";
-};
-
-// Re-export emitModule for backward compatibility
-export { emitModule } from "./core/module-emitter.js";

package/src/expression-emitter.ts

@@ -1,112 +0,0 @@
-/**
- * Expression Emitter - IR expressions to C# code
- * Main dispatcher - delegates to specialized modules
- */
-
-import { IrExpression, IrType } from "@tsonic/frontend";
-import { EmitterContext, CSharpFragment } from "./types.js";
-
-// Import expression emitters from specialized modules
-import { emitLiteral } from "./expressions/literals.js";
-import { emitIdentifier } from "./expressions/identifiers.js";
-import { emitArray, emitObject } from "./expressions/collections.js";
-import { emitMemberAccess } from "./expressions/access.js";
-import { emitCall, emitNew } from "./expressions/calls.js";
-import {
-  emitBinary,
-  emitLogical,
-  emitUnary,
-  emitUpdate,
-  emitAssignment,
-  emitConditional,
-} from "./expressions/operators.js";
-import {
-  emitFunctionExpression,
-  emitArrowFunction,
-} from "./expressions/functions.js";
-import {
-  emitTemplateLiteral,
-  emitSpread,
-  emitAwait,
-} from "./expressions/other.js";
-
-/**
- * Emit a C# expression from an IR expression
- * @param expr The IR expression to emit
- * @param context The emitter context
- * @param expectedType Optional expected type for contextual typing (e.g., array element type inference)
- */
-export const emitExpression = (
-  expr: IrExpression,
-  context: EmitterContext,
-  expectedType?: IrType
-): [CSharpFragment, EmitterContext] => {
-  switch (expr.kind) {
-    case "literal":
-      return emitLiteral(expr, context);
-
-    case "identifier":
-      return emitIdentifier(expr, context);
-
-    case "array":
-      return emitArray(expr, context, expectedType);
-
-    case "object":
-      return emitObject(expr, context);
-
-    case "memberAccess":
-      return emitMemberAccess(expr, context);
-
-    case "call":
-      return emitCall(expr, context);
-
-    case "new":
-      return emitNew(expr, context);
-
-    case "binary":
-      return emitBinary(expr, context);
-
-    case "logical":
-      return emitLogical(expr, context);
-
-    case "unary":
-      return emitUnary(expr, context);
-
-    case "update":
-      return emitUpdate(expr, context);
-
-    case "assignment":
-      return emitAssignment(expr, context);
-
-    case "conditional":
-      return emitConditional(expr, context);
-
-    case "functionExpression":
-      return emitFunctionExpression(expr, context);
-
-    case "arrowFunction":
-      return emitArrowFunction(expr, context);
-
-    case "templateLiteral":
-      return emitTemplateLiteral(expr, context);
-
-    case "spread":
-      return emitSpread(expr, context);
-
-    case "await":
-      return emitAwait(expr, context);
-
-    case "this":
-      return [{ text: "this" }, context];
-
-    default:
-      // Fallback for unhandled expressions
-      return [{ text: "/* TODO: unhandled expression */" }, context];
-  }
-};
-
-// Re-export commonly used functions for backward compatibility
-export {
-  emitTypeArguments,
-  generateSpecializedName,
-} from "./expressions/identifiers.js";

package/src/expressions/access.ts

@@ -1,104 +0,0 @@
-/**
- * Member access expression emitters
- */
-
-import { IrExpression } from "@tsonic/frontend";
-import { EmitterContext, CSharpFragment } from "../types.js";
-import { emitExpression } from "../expression-emitter.js";
-import {
-  isExplicitViewProperty,
-  extractInterfaceNameFromView,
-} from "@tsonic/frontend/types/explicit-views.js";
-
-/**
- * Emit a member access expression (dot notation or bracket notation)
- */
-export const emitMemberAccess = (
-  expr: Extract<IrExpression, { kind: "memberAccess" }>,
-  context: EmitterContext
-): [CSharpFragment, EmitterContext] => {
-  // Check if this is a hierarchical member binding
-  if (expr.memberBinding) {
-    // Emit the full CLR type and member with global:: prefix
-    const { assembly, type, member } = expr.memberBinding;
-    const text = `global::${assembly}.${type}.${member}`;
-    return [{ text }, context];
-  }
-
-  const [objectFrag, newContext] = emitExpression(expr.object, context);
-
-  // Default runtime to "js" when not specified
-  const runtime = context.options.runtime ?? "js";
-
-  if (expr.isComputed) {
-    // Check if this is array index access - rewrite to static helper
-    const objectType = expr.object.inferredType;
-    const isArrayType = objectType?.kind === "arrayType";
-
-    // For TS arrays, use Tsonic.Runtime.Array.get() in BOTH modes
-    // This provides TS array semantics (auto-grow, sparse arrays, etc.)
-    // Note: Tsonic.Runtime is compiler support for lowered TS constructs (both modes)
-    //       Tsonic.JSRuntime is JS built-ins like .map/.filter (js mode only)
-    if (isArrayType) {
-      const indexContext = { ...newContext, isArrayIndex: true };
-      const [propFrag, contextWithIndex] = emitExpression(
-        expr.property as IrExpression,
-        indexContext
-      );
-      const finalContext = { ...contextWithIndex, isArrayIndex: false };
-      const text = `global::Tsonic.Runtime.Array.get(${objectFrag.text}, ${propFrag.text})`;
-      return [{ text }, finalContext];
-    }
-
-    // CLR indexer access (non-TS-array types like List<T>, string, etc.)
-    // CLR indexers require integral indices.
-    // This applies in BOTH js and dotnet modes - CLR type requirements are mode-independent.
-    const indexContext = { ...newContext, isArrayIndex: true };
-    const [propFrag, contextWithIndex] = emitExpression(
-      expr.property as IrExpression,
-      indexContext
-    );
-    const finalContext = { ...contextWithIndex, isArrayIndex: false };
-    const accessor = expr.isOptional ? "?[" : "[";
-
-    // Check if the index is already known to be int (e.g., canonical loop counter)
-    const indexExpr = expr.property as IrExpression;
-    const isKnownInt =
-      indexExpr.kind === "identifier" &&
-      context.intLoopVars?.has(indexExpr.name);
-
-    // Skip cast if index is known int, otherwise cast for safety
-    const indexText = isKnownInt ? propFrag.text : `(int)(${propFrag.text})`;
-    const text = `${objectFrag.text}${accessor}${indexText}]`;
-    return [{ text }, finalContext];
-  }
-
-  // Property access
-  const prop = expr.property as string;
-  const objectType = expr.object.inferredType;
-  const isArrayType = objectType?.kind === "arrayType";
-
-  // In JS runtime mode, rewrite array.length → global::Tsonic.Runtime.Array.length(array)
-  // In dotnet mode, there is no JS emulation - users access .Count directly on List<T>
-  if (isArrayType && prop === "length" && runtime === "js") {
-    const text = `global::Tsonic.Runtime.Array.length(${objectFrag.text})`;
-    return [{ text }, newContext];
-  }
-
-  // Handle explicit interface view properties (As_IInterface)
-  if (isExplicitViewProperty(prop)) {
-    const interfaceName = extractInterfaceNameFromView(prop);
-    if (interfaceName) {
-      // Emit as C# interface cast: ((IInterface)obj)
-      // TODO: Need to look up full interface name from metadata
-      // For now, use the extracted short name
-      const text = `((${interfaceName})${objectFrag.text})`;
-      return [{ text }, newContext];
-    }
-  }
-
-  // Regular property access
-  const accessor = expr.isOptional ? "?." : ".";
-  const text = `${objectFrag.text}${accessor}${prop}`;
-  return [{ text }, newContext];
-};

package/src/expressions/calls.ts

@@ -1,264 +0,0 @@
-/**
- * Call and new expression emitters
- */
-
-import { IrExpression } from "@tsonic/frontend";
-import { EmitterContext, CSharpFragment } from "../types.js";
-import { emitExpression } from "../expression-emitter.js";
-import { emitTypeArguments, generateSpecializedName } from "./identifiers.js";
-
-/**
- * Ref/out/in parameter handling:
- * The frontend extracts parameter passing modes from resolved signatures
- * and attaches them to IrCallExpression.argumentPassing array.
- * The emitter reads this array and prefixes arguments with ref/out/in keywords.
- */
-
-/**
- * Check if an expression is an lvalue (can be passed by reference)
- * Only identifiers and member accesses are lvalues in C#
- */
-const isLValue = (expr: IrExpression): boolean => {
-  return expr.kind === "identifier" || expr.kind === "memberAccess";
-};
-
-/**
- * Check if a call expression needs an explicit cast because the inferred type
- * differs from the C# return type. This handles cases like Math.floor() which
- * returns double in C# but is cast to int in TypeScript via `as int`.
- */
-const needsIntCast = (
-  expr: Extract<IrExpression, { kind: "call" }>,
-  calleeName: string
-): boolean => {
-  // Check if the inferred type is int (a reference type from @tsonic/types)
-  const inferredType = expr.inferredType;
-  if (
-    !inferredType ||
-    inferredType.kind !== "referenceType" ||
-    inferredType.name !== "int"
-  ) {
-    return false;
-  }
-
-  // Check if this is a Math method that returns double
-  const mathMethodsReturningDouble = [
-    "Math.floor",
-    "Math.ceil",
-    "Math.round",
-    "Math.abs",
-    "Math.pow",
-    "Math.sqrt",
-    "Math.min",
-    "Math.max",
-    "Tsonic.JSRuntime.Math.floor",
-    "Tsonic.JSRuntime.Math.ceil",
-    "Tsonic.JSRuntime.Math.round",
-  ];
-
-  return mathMethodsReturningDouble.some(
-    (m) => calleeName === m || calleeName.endsWith(`.${m.split(".").pop()}`)
-  );
-};
-
-/**
- * Emit a function call expression
- */
-export const emitCall = (
-  expr: Extract<IrExpression, { kind: "call" }>,
-  context: EmitterContext
-): [CSharpFragment, EmitterContext] => {
-  // Type-aware method call rewriting
-  // Use inferredType to determine if we need to rewrite as static helper
-  if (
-    expr.callee.kind === "memberAccess" &&
-    typeof expr.callee.property === "string"
-  ) {
-    const methodName = expr.callee.property;
-    const objectType = expr.callee.object.inferredType;
-
-    // Rewrite based on type:
-    // - string → Tsonic.JSRuntime.String.method()
-    // - number → Tsonic.JSRuntime.Number.method()
-    // - Array<T> → Tsonic.JSRuntime.Array.method() (extension methods on List<T>)
-    // - Other custom types → Keep as instance method
-
-    const isStringType =
-      objectType?.kind === "primitiveType" && objectType.name === "string";
-    const isNumberType =
-      objectType?.kind === "primitiveType" && objectType.name === "number";
-    const isArrayType = objectType?.kind === "arrayType";
-
-    const shouldRewriteAsStatic = isStringType || isNumberType || isArrayType;
-
-    // Only rewrite to JSRuntime in "js" mode
-    // In "dotnet" mode, there is no JS emulation - use .NET APIs directly
-    const runtime = context.options.runtime ?? "js";
-    if (shouldRewriteAsStatic && runtime === "js") {
-      // Runtime mode "js": Use Tsonic.JSRuntime
-      // Determine which runtime class based on type
-      let runtimeClass: string;
-      if (isStringType) {
-        runtimeClass = "String";
-      } else if (isNumberType) {
-        runtimeClass = "Number";
-      } else {
-        runtimeClass = "Array";
-      }
-
-      // Rewrite: obj.method(args) → global::Tsonic.JSRuntime.{Class}.method(obj, args)
-      const [objectFrag, objContext] = emitExpression(
-        expr.callee.object,
-        context
-      );
-      let currentContext = objContext;
-
-      const args: string[] = [objectFrag.text]; // Object becomes first argument
-      for (let i = 0; i < expr.arguments.length; i++) {
-        const arg = expr.arguments[i];
-        if (!arg) continue; // Skip undefined (shouldn't happen in valid IR)
-        if (arg.kind === "spread") {
-          const [spreadFrag, ctx] = emitExpression(
-            arg.expression,
-            currentContext
-          );
-          args.push(`params ${spreadFrag.text}`);
-          currentContext = ctx;
-        } else {
-          const [argFrag, ctx] = emitExpression(arg, currentContext);
-          // Check if this argument needs ref/out/in prefix
-          // Note: argumentPassing[i] corresponds to method parameter i+1 (first param is the object)
-          // Only add prefix if argument is an lvalue (identifier or member access)
-          const passingMode = expr.argumentPassing?.[i + 1];
-          const prefix =
-            passingMode && passingMode !== "value" && isLValue(arg)
-              ? `${passingMode} `
-              : "";
-          args.push(`${prefix}${argFrag.text}`);
-          currentContext = ctx;
-        }
-      }
-
-      const text = `global::Tsonic.JSRuntime.${runtimeClass}.${methodName}(${args.join(", ")})`;
-      return [{ text }, currentContext];
-    }
-  }
-
-  // Regular function call
-  const [calleeFrag, newContext] = emitExpression(expr.callee, context);
-  let currentContext = newContext;
-
-  // Handle generic type arguments
-  let typeArgsStr = "";
-  let finalCalleeName = calleeFrag.text;
-
-  if (expr.typeArguments && expr.typeArguments.length > 0) {
-    if (expr.requiresSpecialization) {
-      // Monomorphisation: Generate specialized method name
-      // e.g., process<string> → process__string
-      const [specializedName, specContext] = generateSpecializedName(
-        calleeFrag.text,
-        expr.typeArguments,
-        currentContext
-      );
-      finalCalleeName = specializedName;
-      currentContext = specContext;
-    } else {
-      // Emit explicit type arguments for generic call
-      // e.g., identity<string>(value)
-      const [typeArgs, typeContext] = emitTypeArguments(
-        expr.typeArguments,
-        currentContext
-      );
-      typeArgsStr = typeArgs;
-      currentContext = typeContext;
-    }
-  }
-
-  const args: string[] = [];
-  for (let i = 0; i < expr.arguments.length; i++) {
-    const arg = expr.arguments[i];
-    if (!arg) continue; // Skip undefined (shouldn't happen in valid IR)
-    if (arg.kind === "spread") {
-      // Spread in function call
-      const [spreadFrag, ctx] = emitExpression(arg.expression, currentContext);
-      args.push(`params ${spreadFrag.text}`);
-      currentContext = ctx;
-    } else {
-      const [argFrag, ctx] = emitExpression(arg, currentContext);
-      // Check if this argument needs ref/out/in prefix
-      // Only add prefix if argument is an lvalue (identifier or member access)
-      const passingMode = expr.argumentPassing?.[i];
-      const prefix =
-        passingMode && passingMode !== "value" && isLValue(arg)
-          ? `${passingMode} `
-          : "";
-      args.push(`${prefix}${argFrag.text}`);
-      currentContext = ctx;
-    }
-  }
-
-  const callOp = expr.isOptional ? "?." : "";
-  const callText = `${finalCalleeName}${typeArgsStr}${callOp}(${args.join(", ")})`;
-
-  // Add cast if needed (e.g., Math.floor returning double but asserted as int)
-  const text = needsIntCast(expr, finalCalleeName)
-    ? `(int)${callText}`
-    : callText;
-
-  return [{ text }, currentContext];
-};
-
-/**
- * Emit a new expression
- */
-export const emitNew = (
-  expr: Extract<IrExpression, { kind: "new" }>,
-  context: EmitterContext
-): [CSharpFragment, EmitterContext] => {
-  const [calleeFrag, newContext] = emitExpression(expr.callee, context);
-  let currentContext = newContext;
-
-  // Handle generic type arguments
-  let typeArgsStr = "";
-  let finalClassName = calleeFrag.text;
-
-  if (expr.typeArguments && expr.typeArguments.length > 0) {
-    if (expr.requiresSpecialization) {
-      // Monomorphisation: Generate specialized class name
-      // e.g., new Box<string>() → new Box__string()
-      const [specializedName, specContext] = generateSpecializedName(
-        calleeFrag.text,
-        expr.typeArguments,
-        currentContext
-      );
-      finalClassName = specializedName;
-      currentContext = specContext;
-    } else {
-      // Emit explicit type arguments for generic constructor
-      // e.g., new Box<string>(value)
-      const [typeArgs, typeContext] = emitTypeArguments(
-        expr.typeArguments,
-        currentContext
-      );
-      typeArgsStr = typeArgs;
-      currentContext = typeContext;
-    }
-  }
-
-  const args: string[] = [];
-  for (const arg of expr.arguments) {
-    if (arg.kind === "spread") {
-      const [spreadFrag, ctx] = emitExpression(arg.expression, currentContext);
-      args.push(`params ${spreadFrag.text}`);
-      currentContext = ctx;
-    } else {
-      const [argFrag, ctx] = emitExpression(arg, currentContext);
-      args.push(argFrag.text);
-      currentContext = ctx;
-    }
-  }
-
-  const text = `new ${finalClassName}${typeArgsStr}(${args.join(", ")})`;
-  return [{ text }, currentContext];
-};