@tsonic/emitter 0.0.1 → 0.0.2

package/src/expressions/collections.ts

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

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

package/src/expressions/identifiers.ts

@@ -1,125 +0,0 @@
-/**
- * Identifier and type argument emitters
- */
-
-import { IrExpression, IrType } from "@tsonic/frontend";
-import { EmitterContext, CSharpFragment } from "../types.js";
-import { emitType } from "../type-emitter.js";
-
-/**
- * Fallback mappings for well-known runtime globals
- * Used when binding manifests are not available (e.g., in tests)
- * All use global:: prefix for unambiguous resolution.
- */
-const RUNTIME_FALLBACKS: Record<string, string> = {
-  console: "global::Tsonic.JSRuntime.console",
-  Math: "global::Tsonic.JSRuntime.Math",
-  JSON: "global::Tsonic.JSRuntime.JSON",
-  parseInt: "global::Tsonic.JSRuntime.Globals.parseInt",
-  parseFloat: "global::Tsonic.JSRuntime.Globals.parseFloat",
-  isNaN: "global::Tsonic.JSRuntime.Globals.isNaN",
-  isFinite: "global::Tsonic.JSRuntime.Globals.isFinite",
-};
-
-/**
- * Emit an identifier, using resolved binding info if available
- */
-export const emitIdentifier = (
-  expr: Extract<IrExpression, { kind: "identifier" }>,
-  context: EmitterContext
-): [CSharpFragment, EmitterContext] => {
-  // Special case for undefined -> default
-  if (expr.name === "undefined") {
-    return [{ text: "default" }, context];
-  }
-
-  // Check if this identifier is from an import
-  if (context.importBindings) {
-    const binding = context.importBindings.get(expr.name);
-    if (binding) {
-      // Imported identifier - always use fully-qualified reference
-      // Use pre-computed clrName directly (all resolution done when building binding)
-      if (binding.member) {
-        // Value import with member - Container.member
-        return [{ text: `${binding.clrName}.${binding.member}` }, context];
-      }
-      // Type, namespace, or default import - use clrName directly
-      return [{ text: binding.clrName }, context];
-    }
-  }
-
-  // Use custom C# name from binding if specified (with global:: prefix)
-  if (expr.csharpName && expr.resolvedAssembly) {
-    const fqn = `global::${expr.resolvedAssembly}.${expr.csharpName}`;
-    return [{ text: fqn }, context];
-  }
-
-  // Use resolved binding if available (from binding manifest) with global:: prefix
-  // resolvedClrType is already the full CLR type name, just add global::
-  if (expr.resolvedClrType) {
-    const fqn = `global::${expr.resolvedClrType}`;
-    return [{ text: fqn }, context];
-  }
-
-  // Fallback for well-known runtime globals (only in js mode)
-  // In dotnet mode, there is no JS emulation - these globals don't exist
-  const runtime = context.options.runtime ?? "js";
-  if (runtime === "js") {
-    const fallback = RUNTIME_FALLBACKS[expr.name];
-    if (fallback) {
-      // RUNTIME_FALLBACKS already have global:: prefix
-      return [{ text: fallback }, context];
-    }
-  }
-
-  // Fallback: use identifier as-is
-  return [{ text: expr.name }, context];
-};
-
-/**
- * Emit type arguments as C# generic type parameters
- * Example: [string, number] → <string, double>
- */
-export const emitTypeArguments = (
-  typeArgs: readonly IrType[],
-  context: EmitterContext
-): [string, EmitterContext] => {
-  if (!typeArgs || typeArgs.length === 0) {
-    return ["", context];
-  }
-
-  let currentContext = context;
-  const typeStrings: string[] = [];
-
-  for (const typeArg of typeArgs) {
-    const [typeStr, newContext] = emitType(typeArg, currentContext);
-    currentContext = newContext;
-    typeStrings.push(typeStr);
-  }
-
-  return [`<${typeStrings.join(", ")}>`, currentContext];
-};
-
-/**
- * Generate specialized method/class name from type arguments
- * Example: process with [string, number] → process__string__double
- */
-export const generateSpecializedName = (
-  baseName: string,
-  typeArgs: readonly IrType[],
-  context: EmitterContext
-): [string, EmitterContext] => {
-  let currentContext = context;
-  const typeNames: string[] = [];
-
-  for (const typeArg of typeArgs) {
-    const [typeName, newContext] = emitType(typeArg, currentContext);
-    currentContext = newContext;
-    // Sanitize type name for use in identifier (remove <>, ?, etc.)
-    const sanitized = typeName.replace(/[<>?,\s]/g, "_").replace(/\./g, "_");
-    typeNames.push(sanitized);
-  }
-
-  const specializedName = `${baseName}__${typeNames.join("__")}`;
-  return [specializedName, currentContext];
-};