@tsonic/emitter 0.0.1 → 0.0.3

package/src/types/index.test.ts

@@ -1,116 +0,0 @@
-/**
- * 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/intersections.ts

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

@@ -1,26 +0,0 @@
-/**
- * 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/parameters.test.ts

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

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

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

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