@tsonic/emitter 0.0.1

package/src/types/index.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for Type Emission
+ * Tests emission of primitive types and async/Task types
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Type Emission", () => {
+  it("should emit primitive types correctly", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "test",
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "a" },
+              type: { kind: "primitiveType", name: "string" },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "b" },
+              type: { kind: "primitiveType", name: "number" },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "c" },
+              type: { kind: "primitiveType", name: "boolean" },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "voidType" },
+          body: { kind: "blockStatement", statements: [] },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("string a");
+    expect(result).to.include("double b");
+    expect(result).to.include("bool c");
+  });
+
+  it("should emit async functions with Task types", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "fetchData",
+          parameters: [],
+          returnType: {
+            kind: "referenceType",
+            name: "Promise",
+            typeArguments: [{ kind: "primitiveType", name: "string" }],
+          },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "returnStatement",
+                expression: {
+                  kind: "await",
+                  expression: {
+                    kind: "call",
+                    callee: { kind: "identifier", name: "getData" },
+                    arguments: [],
+                    isOptional: false,
+                  },
+                },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: true,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("public static async Task<string> fetchData()");
+    expect(result).to.include("await getData()");
+    expect(result).to.include("using System.Threading.Tasks");
+  });
+});

package/src/types/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Type emitter - Public API
+ */
+
+export { emitType } from "./emitter.js";
+export { emitTypeParameters, emitParameterType } from "./parameters.js";
+export { emitPrimitiveType } from "./primitives.js";
+export { emitReferenceType } from "./references.js";
+export { emitArrayType } from "./arrays.js";
+export { emitFunctionType } from "./functions.js";
+export { emitObjectType } from "./objects.js";
+export { emitUnionType } from "./unions.js";
+export { emitIntersectionType } from "./intersections.js";
+export { emitLiteralType } from "./literals.js";

package/src/types/intersections.ts

@@ -0,0 +1,19 @@
+/**
+ * Intersection type emission
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+
+/**
+ * Emit intersection types as object (C# doesn't have intersection types)
+ */
+export const emitIntersectionType = (
+  _type: Extract<IrType, { kind: "intersectionType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  // C# doesn't have intersection types
+  // For MVP, we'll use object
+  // In a more complete implementation, we might generate an interface
+  return ["object", context];
+};

package/src/types/literals.ts

@@ -0,0 +1,26 @@
+/**
+ * Literal type emission
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+
+/**
+ * Emit literal types (string, number, boolean literals)
+ */
+export const emitLiteralType = (
+  type: Extract<IrType, { kind: "literalType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  // For literal types, we emit the base type
+  if (typeof type.value === "string") {
+    return ["string", context];
+  }
+  if (typeof type.value === "number") {
+    return ["double", context];
+  }
+  if (typeof type.value === "boolean") {
+    return ["bool", context];
+  }
+  return ["object", context];
+};

package/src/types/objects.ts

@@ -0,0 +1,27 @@
+/**
+ * Object type emission
+ *
+ * IrObjectType represents anonymous object types like `{ x: number }`.
+ * These should be caught by frontend validation (TSN7403) and never reach the emitter.
+ *
+ * Named types (interfaces, type aliases, classes) become IrReferenceType instead.
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+
+/**
+ * Emit object types
+ *
+ * ICE: This should never be called. Frontend validation (TSN7403) should
+ * reject anonymous object types. If we reach here, validation has a gap.
+ */
+export const emitObjectType = (
+  _type: Extract<IrType, { kind: "objectType" }>,
+  _context: EmitterContext
+): [string, EmitterContext] => {
+  // ICE: Frontend validation (TSN7403) should have caught this.
+  throw new Error(
+    "ICE: Anonymous object type reached emitter - validation missed TSN7403"
+  );
+};

package/src/types/parameters.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Test ref/out/in parameter emission
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitParameters } from "../statements/classes/parameters.js";
+import type { IrParameter } from "@tsonic/frontend";
+import type { EmitterContext } from "../types.js";
+
+describe("Parameter modifiers (ref/out/in)", () => {
+  const baseContext: EmitterContext = {
+    indentLevel: 0,
+    isStatic: false,
+    isAsync: false,
+    options: { runtime: "dotnet", rootNamespace: "Test" },
+  };
+
+  it("should emit out parameter with out modifier", () => {
+    const params: IrParameter[] = [
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "result" },
+        type: {
+          kind: "referenceType",
+          name: "out",
+          typeArguments: [
+            {
+              kind: "referenceType",
+              name: "int",
+            },
+          ],
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "out",
+      },
+    ];
+
+    const [emitted, _context] = emitParameters(params, baseContext);
+    expect(emitted).to.equal("out int result");
+  });
+
+  it("should emit ref parameter with ref modifier", () => {
+    const params: IrParameter[] = [
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "value" },
+        type: {
+          kind: "referenceType",
+          name: "ref",
+          typeArguments: [
+            {
+              kind: "referenceType",
+              name: "int",
+            },
+          ],
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "ref",
+      },
+    ];
+
+    const [emitted, _context] = emitParameters(params, baseContext);
+    expect(emitted).to.equal("ref int value");
+  });
+
+  it("should emit in parameter with in modifier", () => {
+    const params: IrParameter[] = [
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "value" },
+        type: {
+          kind: "referenceType",
+          name: "In",
+          typeArguments: [
+            {
+              kind: "referenceType",
+              name: "int",
+            },
+          ],
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "in",
+      },
+    ];
+
+    const [emitted, _context] = emitParameters(params, baseContext);
+    expect(emitted).to.equal("in int value");
+  });
+
+  it("should emit multiple parameters with mixed modifiers", () => {
+    const params: IrParameter[] = [
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "input" },
+        type: {
+          kind: "referenceType",
+          name: "int",
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "value",
+      },
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "output" },
+        type: {
+          kind: "referenceType",
+          name: "out",
+          typeArguments: [
+            {
+              kind: "referenceType",
+              name: "int",
+            },
+          ],
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "out",
+      },
+      {
+        kind: "parameter",
+        pattern: { kind: "identifierPattern", name: "counter" },
+        type: {
+          kind: "referenceType",
+          name: "ref",
+          typeArguments: [
+            {
+              kind: "referenceType",
+              name: "int",
+            },
+          ],
+        },
+        isOptional: false,
+        isRest: false,
+        passing: "ref",
+      },
+    ];
+
+    const [emitted, _context] = emitParameters(params, baseContext);
+    expect(emitted).to.equal("int input, out int output, ref int counter");
+  });
+});

package/src/types/parameters.ts

@@ -0,0 +1,95 @@
+/**
+ * Type parameter and parameter type emission
+ */
+
+import { IrType, IrTypeParameter } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitType } from "./emitter.js";
+
+/**
+ * Emit C# type parameters with constraints
+ * Example: <T, U extends Foo> → <T, U> with where clauses
+ */
+export const emitTypeParameters = (
+  typeParams: readonly IrTypeParameter[] | undefined,
+  context: EmitterContext
+): [string, string[], EmitterContext] => {
+  if (!typeParams || typeParams.length === 0) {
+    return ["", [], context];
+  }
+
+  const paramNames = typeParams.map((tp) => tp.name).join(", ");
+  const typeParamsStr = `<${paramNames}>`;
+
+  // Build where clauses for constraints
+  const whereClauses: string[] = [];
+  let currentContext = context;
+
+  for (const tp of typeParams) {
+    if (tp.constraint) {
+      // Handle structural constraints specially - they generate adapter interfaces
+      // Don't call emitType on objectType constraints (would trigger ICE)
+      if (tp.isStructuralConstraint) {
+        // Structural constraints generate interfaces - reference them
+        whereClauses.push(`where ${tp.name} : __Constraint_${tp.name}`);
+      } else {
+        const [constraintStr, newContext] = emitType(
+          tp.constraint,
+          currentContext
+        );
+        currentContext = newContext;
+        whereClauses.push(`where ${tp.name} : ${constraintStr}`);
+      }
+    }
+  }
+
+  return [typeParamsStr, whereClauses, currentContext];
+};
+
+/**
+ * Check if a type is a ref/out/in wrapper type and return the inner type
+ */
+const unwrapParameterModifierType = (type: IrType): IrType | null => {
+  if (type.kind !== "referenceType") {
+    return null;
+  }
+
+  const name = type.name;
+  // Check for wrapper types: out<T>, ref<T>, In<T>
+  if (
+    (name === "out" || name === "ref" || name === "In") &&
+    type.typeArguments &&
+    type.typeArguments.length === 1
+  ) {
+    const innerType = type.typeArguments[0];
+    return innerType ?? null;
+  }
+
+  return null;
+};
+
+/**
+ * Emit a parameter type with optional and default value handling
+ */
+export const emitParameterType = (
+  type: IrType | undefined,
+  isOptional: boolean,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const typeNode = type ?? { kind: "anyType" as const };
+
+  // Unwrap ref/out/in wrapper types - the modifier is handled separately
+  const unwrapped = unwrapParameterModifierType(typeNode);
+  const actualType = unwrapped ?? typeNode;
+
+  const [baseType, newContext] = emitType(actualType, context);
+
+  // For optional parameters, add ? suffix for nullable types
+  // This includes both value types (double?, int?) and reference types (string?)
+  // per spec/04-type-mappings.md:21-78
+  if (isOptional) {
+    return [`${baseType}?`, newContext];
+  }
+
+  return [baseType, newContext];
+};

package/src/types/primitives.ts

@@ -0,0 +1,24 @@
+/**
+ * Primitive type emission
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+
+/**
+ * Emit primitive types (number, string, boolean, null, undefined)
+ */
+export const emitPrimitiveType = (
+  type: Extract<IrType, { kind: "primitiveType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const typeMap: Record<string, string> = {
+    number: "double",
+    string: "string",
+    boolean: "bool",
+    null: "object",
+    undefined: "object",
+  };
+
+  return [typeMap[type.name] ?? "object", context];
+};

package/src/types/references.ts

@@ -0,0 +1,187 @@
+/**
+ * Reference type emission (Array, Promise, Error, etc.)
+ *
+ * All types are emitted with global:: prefix for unambiguous resolution.
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitType } from "./emitter.js";
+import {
+  isNestedType,
+  tsCSharpNestedTypeName,
+} from "@tsonic/frontend/types/nested-types.js";
+
+/**
+ * Check if a type name indicates an unsupported support type.
+ *
+ * TODO: This is a basic check. Full implementation requires:
+ * 1. Access to TypeScript type checker
+ * 2. Integration with support-types.ts helpers
+ * 3. Proper diagnostic reporting
+ *
+ * For now, we check the type name string.
+ */
+const checkUnsupportedSupportType = (typeName: string): string | undefined => {
+  if (
+    typeName === "TSUnsafePointer" ||
+    typeName.startsWith("TSUnsafePointer<")
+  ) {
+    return "Unsafe pointers are not supported in Tsonic. Use IntPtr for opaque handles.";
+  }
+  if (typeName === "TSFixed" || typeName.startsWith("TSFixed<")) {
+    return "Fixed-size buffers (unsafe feature) are not supported. Use arrays or Span<T> instead.";
+  }
+  if (typeName === "TSStackAlloc" || typeName.startsWith("TSStackAlloc<")) {
+    return "stackalloc is not supported in Tsonic. Use heap-allocated arrays instead.";
+  }
+  return undefined;
+};
+
+/**
+ * Emit reference types with type arguments
+ */
+export const emitReferenceType = (
+  type: Extract<IrType, { kind: "referenceType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const { name, typeArguments, resolvedClrType } = type;
+
+  // If the type has a pre-resolved CLR type (from IR), use it
+  if (resolvedClrType) {
+    if (typeArguments && typeArguments.length > 0) {
+      const typeParams: string[] = [];
+      let currentContext = context;
+      for (const typeArg of typeArguments) {
+        const [paramType, newContext] = emitType(typeArg, currentContext);
+        typeParams.push(paramType);
+        currentContext = newContext;
+      }
+      return [`${resolvedClrType}<${typeParams.join(", ")}>`, currentContext];
+    }
+    return [resolvedClrType, context];
+  }
+
+  // Check if this type is imported - use pre-computed CLR name directly
+  const importBinding = context.importBindings?.get(name);
+  if (importBinding) {
+    // Use clrName directly - all resolution was done when building the binding
+    // For type imports: clrName is the type's FQN (e.g., "MultiFileTypes.models.User")
+    // For value imports: clrName is container, member is the export name
+    // Note: Type references should only match type bindings; value bindings
+    // appearing here would be a bug (referencing a function as a type)
+    const qualifiedName =
+      importBinding.kind === "type"
+        ? importBinding.clrName
+        : importBinding.member
+          ? `${importBinding.clrName}.${importBinding.member}`
+          : importBinding.clrName;
+
+    if (typeArguments && typeArguments.length > 0) {
+      const typeParams: string[] = [];
+      let currentContext = context;
+      for (const typeArg of typeArguments) {
+        const [paramType, newContext] = emitType(typeArg, currentContext);
+        typeParams.push(paramType);
+        currentContext = newContext;
+      }
+      return [`${qualifiedName}<${typeParams.join(", ")}>`, currentContext];
+    }
+    return [qualifiedName, context];
+  }
+
+  // Check for unsupported support types
+  const unsupportedError = checkUnsupportedSupportType(name);
+  if (unsupportedError) {
+    // TODO: Report diagnostic error instead of throwing
+    // For now, emit a comment to make the error visible in generated code
+    console.warn(`[Tsonic] ${unsupportedError}`);
+    return [`/* ERROR: ${unsupportedError} */ object`, context];
+  }
+
+  // Handle built-in types
+  if (name === "Array" && typeArguments && typeArguments.length > 0) {
+    const firstArg = typeArguments[0];
+    if (!firstArg) {
+      return [`global::System.Collections.Generic.List<object>`, context];
+    }
+    const [elementType, newContext] = emitType(firstArg, context);
+    return [
+      `global::System.Collections.Generic.List<${elementType}>`,
+      newContext,
+    ];
+  }
+
+  if (name === "Promise" && typeArguments && typeArguments.length > 0) {
+    const firstArg = typeArguments[0];
+    if (!firstArg) {
+      return [`global::System.Threading.Tasks.Task`, context];
+    }
+    const [elementType, newContext] = emitType(firstArg, context);
+    // Promise<void> should map to Task (not Task<void>)
+    if (elementType === "void") {
+      return [`global::System.Threading.Tasks.Task`, newContext];
+    }
+    return [`global::System.Threading.Tasks.Task<${elementType}>`, newContext];
+  }
+
+  if (name === "Promise") {
+    return ["global::System.Threading.Tasks.Task", context];
+  }
+
+  // Map common JS types to .NET equivalents
+  // Note: Date, RegExp, Map, Set are NOT SUPPORTED in MVP
+  // Users should use System.DateTime, System.Text.RegularExpressions.Regex,
+  // Dictionary<K,V>, and HashSet<T> directly
+  const runtimeTypes: Record<string, string> = {
+    Error: "System.Exception",
+  };
+
+  if (name in runtimeTypes) {
+    const csharpType = runtimeTypes[name];
+    if (!csharpType) {
+      return [name, context];
+    }
+
+    // Always emit with global:: prefix for unambiguous resolution
+    const fqnType = `global::${csharpType}`;
+
+    if (typeArguments && typeArguments.length > 0) {
+      const typeParams: string[] = [];
+      let currentContext = context;
+
+      for (const typeArg of typeArguments) {
+        const [paramType, newContext] = emitType(typeArg, currentContext);
+        typeParams.push(paramType);
+        currentContext = newContext;
+      }
+
+      return [`${fqnType}<${typeParams.join(", ")}>`, currentContext];
+    }
+
+    return [fqnType, context];
+  }
+
+  // Handle type arguments for other reference types
+  if (typeArguments && typeArguments.length > 0) {
+    const typeParams: string[] = [];
+    let currentContext = context;
+
+    for (const typeArg of typeArguments) {
+      const [paramType, newContext] = emitType(typeArg, currentContext);
+      typeParams.push(paramType);
+      currentContext = newContext;
+    }
+
+    // Convert nested type names (Outer$Inner → Outer.Inner)
+    const csharpName = isNestedType(name) ? tsCSharpNestedTypeName(name) : name;
+
+    return [`${csharpName}<${typeParams.join(", ")}>`, currentContext];
+  }
+
+  // Convert nested type names (Outer$Inner → Outer.Inner)
+  // before returning the name
+  const csharpName = isNestedType(name) ? tsCSharpNestedTypeName(name) : name;
+
+  return [csharpName, context];
+};