@tsonic/emitter 0.0.1

package/src/expressions/calls.ts

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

package/src/expressions/collections.ts

@@ -0,0 +1,354 @@
+/**
+ * Collection expression emitters (arrays and objects)
+ */
+
+import { IrExpression, IrType } from "@tsonic/frontend";
+import { EmitterContext, CSharpFragment } from "../types.js";
+import { emitType } from "../type-emitter.js";
+import { emitExpression } from "../expression-emitter.js";
+
+/**
+ * Escape a string for use in a C# string literal.
+ * Handles backslashes, quotes, newlines, carriage returns, and tabs.
+ */
+const escapeCSharpString = (str: string): string =>
+  str
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, "\\n")
+    .replace(/\r/g, "\\r")
+    .replace(/\t/g, "\\t");
+
+/**
+ * Emit an array literal
+ */
+export const emitArray = (
+  expr: Extract<IrExpression, { kind: "array" }>,
+  context: EmitterContext,
+  expectedType?: IrType
+): [CSharpFragment, EmitterContext] => {
+  let currentContext = context;
+  const elements: string[] = [];
+
+  // Determine element type from expected type or inferred type
+  let elementType = "object";
+
+  // Check if all elements are literals to infer element type
+  const definedElements = expr.elements.filter(
+    (el): el is IrExpression => el !== undefined
+  );
+
+  if (definedElements.length > 0) {
+    const allLiterals = definedElements.every((el) => el.kind === "literal");
+
+    if (allLiterals) {
+      const literals = definedElements as Extract<
+        IrExpression,
+        { kind: "literal" }
+      >[];
+
+      // Check if all are numbers
+      const allNumbers = literals.every((lit) => typeof lit.value === "number");
+
+      if (allNumbers) {
+        // TypeScript `number` is always `double` in C#
+        // Even if all literals are integers, use double for TS semantics
+        elementType = "double";
+      }
+      // Check if all are strings
+      else if (literals.every((lit) => typeof lit.value === "string")) {
+        elementType = "string";
+      }
+      // Check if all are booleans
+      else if (literals.every((lit) => typeof lit.value === "boolean")) {
+        elementType = "bool";
+      }
+    }
+  }
+
+  // Use expected/inferred type if available (takes precedence over literal inference)
+  if (expectedType) {
+    if (expectedType.kind === "arrayType") {
+      const [elemTypeStr, newContext] = emitType(
+        expectedType.elementType,
+        currentContext
+      );
+      elementType = elemTypeStr;
+      currentContext = newContext;
+    } else if (
+      expectedType.kind === "referenceType" &&
+      expectedType.name === "Array" &&
+      expectedType.typeArguments &&
+      expectedType.typeArguments.length > 0
+    ) {
+      const firstArg = expectedType.typeArguments[0];
+      if (firstArg) {
+        const [elemTypeStr, newContext] = emitType(firstArg, currentContext);
+        elementType = elemTypeStr;
+        currentContext = newContext;
+      }
+    }
+  }
+  // If no expectedType, try to use the inferredType from the expression
+  else if (expr.inferredType && expr.inferredType.kind === "arrayType") {
+    // Only use inferredType if we didn't already determine the type from literals
+    if (elementType === "object") {
+      const [elemTypeStr, newContext] = emitType(
+        expr.inferredType.elementType,
+        currentContext
+      );
+      elementType = elemTypeStr;
+      currentContext = newContext;
+    }
+  }
+
+  // Check if array contains only spread elements (e.g., [...arr1, ...arr2])
+  const allSpreads = expr.elements.every(
+    (el) => el !== undefined && el.kind === "spread"
+  );
+
+  if (allSpreads && expr.elements.length > 0) {
+    // Emit as chained Enumerable.Concat calls using explicit static invocation
+    // Note: Concat returns IEnumerable<T>, so wrap in Enumerable.ToList() at the end
+    const spreadElements = expr.elements.filter(
+      (el): el is Extract<IrExpression, { kind: "spread" }> =>
+        el !== undefined && el.kind === "spread"
+    );
+
+    const firstSpread = spreadElements[0];
+    if (!firstSpread) {
+      // Should never happen due to allSpreads check, but satisfy TypeScript
+      return [
+        { text: "new global::System.Collections.Generic.List<object>()" },
+        currentContext,
+      ];
+    }
+
+    const [firstFrag, firstContext] = emitExpression(
+      firstSpread.expression,
+      currentContext
+    );
+    currentContext = firstContext;
+
+    let result = firstFrag.text;
+    for (let i = 1; i < spreadElements.length; i++) {
+      const spread = spreadElements[i];
+      if (spread) {
+        const [spreadFrag, newContext] = emitExpression(
+          spread.expression,
+          currentContext
+        );
+        // Use explicit static call for extension method
+        result = `global::System.Linq.Enumerable.Concat(${result}, ${spreadFrag.text})`;
+        currentContext = newContext;
+      }
+    }
+
+    // Wrap in Enumerable.ToList() using explicit static call
+    return [
+      { text: `global::System.Linq.Enumerable.ToList(${result})` },
+      currentContext,
+    ];
+  }
+
+  // Regular array or mixed spreads/elements
+  for (const element of expr.elements) {
+    if (element === undefined) {
+      // Sparse array hole - fill with default value
+      elements.push("default");
+    } else if (element.kind === "spread") {
+      // Spread mixed with other elements - not yet supported
+      elements.push("/* ...spread */");
+    } else {
+      const [elemFrag, newContext] = emitExpression(element, currentContext);
+      elements.push(elemFrag.text);
+      currentContext = newContext;
+    }
+  }
+
+  // Use constructor syntax for empty arrays, initializer syntax for non-empty
+  const text =
+    elements.length === 0
+      ? `new global::System.Collections.Generic.List<${elementType}>()`
+      : `new global::System.Collections.Generic.List<${elementType}> { ${elements.join(", ")} }`;
+
+  return [{ text }, currentContext];
+};
+
+/**
+ * Emit an object literal
+ *
+ * Handles two cases based on contextual type:
+ * 1. Dictionary type (Record<K,V> or index signature) → Dictionary<string, T> initializer
+ * 2. Nominal type (interface, class) → new TypeName { prop = value, ... }
+ *
+ * Anonymous object types should be caught by validation (TSN7403) before reaching here.
+ */
+export const emitObject = (
+  expr: Extract<IrExpression, { kind: "object" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  let currentContext = context;
+
+  // Check if contextual type is a dictionary type
+  if (expr.contextualType?.kind === "dictionaryType") {
+    return emitDictionaryLiteral(expr, currentContext);
+  }
+
+  // Regular object literal with nominal type
+  const properties: string[] = [];
+
+  for (const prop of expr.properties) {
+    if (prop.kind === "spread") {
+      // Spread in object literal - needs special handling
+      properties.push("/* ...spread */");
+    } else {
+      const key = typeof prop.key === "string" ? prop.key : "/* computed */";
+      const [valueFrag, newContext] = emitExpression(
+        prop.value,
+        currentContext
+      );
+      properties.push(`${key} = ${valueFrag.text}`);
+      currentContext = newContext;
+    }
+  }
+
+  // Check for contextual type (from return type, variable annotation, etc.)
+  // If present, emit `new TypeName { ... }` instead of anonymous `new { ... }`
+  const [typeName, finalContext] = resolveContextualType(
+    expr.contextualType,
+    currentContext
+  );
+
+  if (!typeName) {
+    // ICE: Validation (TSN7403) should have caught anonymous object literals
+    throw new Error(
+      "ICE: Object literal without contextual type reached emitter - validation missed TSN7403"
+    );
+  }
+
+  const text = `new ${typeName} { ${properties.join(", ")} }`;
+  return [{ text }, finalContext];
+};
+
+/**
+ * Emit a dictionary literal using C# collection initializer syntax.
+ *
+ * Input:  const d: Record<string, number> = { a: 1, b: 2 };
+ * Output: new Dictionary<string, double> { ["a"] = 1.0, ["b"] = 2.0 }
+ */
+const emitDictionaryLiteral = (
+  expr: Extract<IrExpression, { kind: "object" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  let currentContext = context;
+
+  const dictType = expr.contextualType as Extract<
+    IrType,
+    { kind: "dictionaryType" }
+  >;
+
+  // Get key and value type strings
+  const [keyTypeStr, ctx1] = emitDictKeyType(dictType.keyType, currentContext);
+  const [valueTypeStr, ctx2] = emitType(dictType.valueType, ctx1);
+  currentContext = ctx2;
+
+  // Emit dictionary entries
+  const entries: string[] = [];
+
+  for (const prop of expr.properties) {
+    if (prop.kind === "spread") {
+      // Spread in dictionary literal - not supported
+      throw new Error("ICE: Spread in dictionary literal not supported");
+    } else {
+      // Key must be a string literal for dictionary initialization
+      if (typeof prop.key !== "string") {
+        throw new Error(
+          "ICE: Computed property key in dictionary literal - validation gap"
+        );
+      }
+
+      const [valueFrag, newContext] = emitExpression(
+        prop.value,
+        currentContext
+      );
+      entries.push(`["${escapeCSharpString(prop.key)}"] = ${valueFrag.text}`);
+      currentContext = newContext;
+    }
+  }
+
+  const text =
+    entries.length === 0
+      ? `new global::System.Collections.Generic.Dictionary<${keyTypeStr}, ${valueTypeStr}>()`
+      : `new global::System.Collections.Generic.Dictionary<${keyTypeStr}, ${valueTypeStr}> { ${entries.join(", ")} }`;
+
+  return [{ text }, currentContext];
+};
+
+/**
+ * Emit dictionary key type.
+ * TS dictionaries only support string keys (enforced by TSN7413).
+ */
+const emitDictKeyType = (
+  keyType: IrType,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  if (keyType.kind === "primitiveType" && keyType.name === "string") {
+    return ["string", context];
+  }
+
+  // ICE: Only string keys allowed (enforced by TSN7413)
+  throw new Error(
+    `ICE: Non-string dictionary key type reached emitter - validation missed TSN7413. Got: ${keyType.kind}`
+  );
+};
+
+/**
+ * Resolve contextual type to C# type string.
+ * Uses emitType to properly handle generic type arguments.
+ * For imported types, qualifies using importBindings.
+ */
+const resolveContextualType = (
+  contextualType: IrType | undefined,
+  context: EmitterContext
+): [string | undefined, EmitterContext] => {
+  if (!contextualType) {
+    return [undefined, context];
+  }
+
+  // For reference types, check if imported and qualify if needed
+  if (contextualType.kind === "referenceType") {
+    const typeName = contextualType.name;
+    const importBinding = context.importBindings?.get(typeName);
+
+    if (importBinding && importBinding.kind === "type") {
+      // Imported type - use qualified name from binding
+      // Emit type arguments if present
+      if (
+        contextualType.typeArguments &&
+        contextualType.typeArguments.length > 0
+      ) {
+        let currentContext = context;
+        const typeArgStrs: string[] = [];
+        for (const typeArg of contextualType.typeArguments) {
+          const [typeArgStr, newContext] = emitType(typeArg, currentContext);
+          typeArgStrs.push(typeArgStr);
+          currentContext = newContext;
+        }
+        return [
+          `${importBinding.clrName}<${typeArgStrs.join(", ")}>`,
+          currentContext,
+        ];
+      }
+      return [importBinding.clrName, context];
+    }
+
+    // Local type - use emitType to handle type arguments
+    const [typeStr, newContext] = emitType(contextualType, context);
+    return [typeStr, newContext];
+  }
+
+  // For other types, use standard emitType
+  const [typeStr, newContext] = emitType(contextualType, context);
+  return [typeStr, newContext];
+};

package/src/expressions/functions.ts

@@ -0,0 +1,71 @@
+/**
+ * Function expression emitters (function expressions and arrow functions)
+ */
+
+import { IrExpression } from "@tsonic/frontend";
+import { EmitterContext, CSharpFragment, indent } from "../types.js";
+import { emitExpression } from "../expression-emitter.js";
+import { emitStatement } from "../statement-emitter.js";
+
+/**
+ * Emit a function expression (placeholder for now)
+ */
+export const emitFunctionExpression = (
+  _expr: Extract<IrExpression, { kind: "functionExpression" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  // Function expressions need to be converted to lambdas or delegates
+  // For MVP, we'll emit a placeholder
+  const text = "/* function expression */";
+  return [{ text }, context];
+};
+
+/**
+ * Emit an arrow function as C# lambda
+ */
+export const emitArrowFunction = (
+  expr: Extract<IrExpression, { kind: "arrowFunction" }>,
+  context: EmitterContext
+): [CSharpFragment, EmitterContext] => {
+  // Convert arrow function to C# lambda
+  let currentContext = context;
+  const paramNames: string[] = [];
+
+  for (const param of expr.parameters) {
+    if (param.pattern.kind === "identifierPattern") {
+      paramNames.push(param.pattern.name);
+    } else {
+      paramNames.push("_");
+    }
+  }
+
+  // Handle body
+  let bodyText: string;
+  if (typeof expr.body === "object" && "kind" in expr.body) {
+    if (expr.body.kind === "blockStatement") {
+      // For block statements in lambdas:
+      // - In static contexts (field initializers), indent the block one level
+      // - In non-static contexts (local variables), keep at same level
+      const blockContext = currentContext.isStatic
+        ? indent(currentContext)
+        : currentContext;
+      const [blockCode, _newContext] = emitStatement(expr.body, blockContext);
+
+      const params = paramNames.join(", ");
+      // The block code has proper indentation, just prepend the lambda signature
+      const text = `(${params}) =>\n${blockCode}`;
+
+      return [{ text }, currentContext];
+    } else {
+      const [bodyFrag, newContext] = emitExpression(expr.body, currentContext);
+      currentContext = newContext;
+      bodyText = bodyFrag.text;
+    }
+  } else {
+    bodyText = "/* unknown body */";
+  }
+
+  const params = paramNames.join(", ");
+  const text = `(${params}) => ${bodyText}`;
+  return [{ text }, currentContext];
+};