@tsonic/emitter 0.0.1

package/src/statements/index.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Tests for Statement Emission
+ * Tests emission of control flow statements (if, for-of)
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Statement Emission", () => {
+  it("should emit if statements", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "check",
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "x" },
+              type: { kind: "primitiveType", name: "number" },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "primitiveType", name: "string" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "ifStatement",
+                condition: {
+                  kind: "binary",
+                  operator: ">",
+                  left: { kind: "identifier", name: "x" },
+                  right: { kind: "literal", value: 0 },
+                },
+                thenStatement: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "returnStatement",
+                      expression: { kind: "literal", value: "positive" },
+                    },
+                  ],
+                },
+                elseStatement: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "returnStatement",
+                      expression: {
+                        kind: "literal",
+                        value: "negative or zero",
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Binary comparison emits with truthiness check
+    expect(result).to.include("if (x > 0");
+    expect(result).to.include('return "positive"');
+    expect(result).to.include("else");
+    expect(result).to.include('return "negative or zero"');
+  });
+
+  it("should emit canonical for loops with int counter and no cast", () => {
+    // Test: for (let i = 0; i < list.Count; i++) { list[i] }
+    // Should emit: for (int i = 0; ...) { list[i] } - NO (int) cast
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "process",
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "items" },
+              type: {
+                kind: "referenceType",
+                name: "List",
+                typeArguments: [{ kind: "primitiveType", name: "number" }],
+              },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "voidType" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "forStatement",
+                initializer: {
+                  kind: "variableDeclaration",
+                  declarationKind: "let",
+                  declarations: [
+                    {
+                      kind: "variableDeclarator",
+                      name: { kind: "identifierPattern", name: "i" },
+                      initializer: { kind: "literal", value: 0 },
+                    },
+                  ],
+                  isExported: false,
+                },
+                condition: {
+                  kind: "binary",
+                  operator: "<",
+                  left: { kind: "identifier", name: "i" },
+                  right: {
+                    kind: "memberAccess",
+                    object: { kind: "identifier", name: "items" },
+                    property: "Count",
+                    isComputed: false,
+                    isOptional: false,
+                  },
+                },
+                update: {
+                  kind: "update",
+                  operator: "++",
+                  prefix: false,
+                  expression: { kind: "identifier", name: "i" },
+                },
+                body: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "call",
+                        callee: {
+                          kind: "memberAccess",
+                          object: { kind: "identifier", name: "console" },
+                          property: "log",
+                          isComputed: false,
+                          isOptional: false,
+                        },
+                        arguments: [
+                          {
+                            kind: "memberAccess",
+                            object: { kind: "identifier", name: "items" },
+                            property: { kind: "identifier", name: "i" },
+                            isComputed: true,
+                            isOptional: false,
+                          },
+                        ],
+                        isOptional: false,
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Canonical loop: int i = 0 (not var i = 0.0)
+    expect(result).to.include("for (int i = 0;");
+    // CLR indexer without cast: items[i] (not items[(int)(i)])
+    expect(result).to.include("items[i]");
+    // Must NOT contain the redundant cast
+    expect(result).to.not.include("[(int)");
+  });
+
+  it("should emit for loops", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "loop",
+          parameters: [],
+          returnType: { kind: "voidType" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "forOfStatement",
+                variable: { kind: "identifierPattern", name: "item" },
+                expression: { kind: "identifier", name: "items" },
+                body: {
+                  kind: "blockStatement",
+                  statements: [
+                    {
+                      kind: "expressionStatement",
+                      expression: {
+                        kind: "call",
+                        callee: {
+                          kind: "memberAccess",
+                          object: { kind: "identifier", name: "console" },
+                          property: "log",
+                          isComputed: false,
+                          isOptional: false,
+                        },
+                        arguments: [{ kind: "identifier", name: "item" }],
+                        isOptional: false,
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+          isExported: true,
+          isAsync: false,
+          isGenerator: false,
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("foreach (var item in items)");
+    expect(result).to.include("Tsonic.JSRuntime.console.log(item)");
+    expect(result).to.include("using Tsonic.JSRuntime");
+  });
+});

package/src/statements/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Statement emitters barrel exports
+ */
+
+// Block and simple statements
+export {
+  emitBlockStatement,
+  emitReturnStatement,
+  emitYieldStatement,
+  emitExpressionStatement,
+} from "./blocks.js";
+
+// Control flow statements
+export {
+  emitIfStatement,
+  emitWhileStatement,
+  emitForStatement,
+  emitForOfStatement,
+  emitSwitchStatement,
+  emitTryStatement,
+  emitThrowStatement,
+} from "./control.js";
+
+// Class-related helpers
+export {
+  emitClassMember,
+  emitParameters,
+  capitalize,
+  extractInlineObjectTypes,
+  emitExtractedType,
+  emitInterfaceMemberAsProperty,
+  type ExtractedType,
+} from "./classes.js";
+
+// Declaration emitters
+export {
+  emitVariableDeclaration,
+  emitFunctionDeclaration,
+  emitClassDeclaration,
+  emitInterfaceDeclaration,
+  emitEnumDeclaration,
+  emitTypeAliasDeclaration,
+} from "./declarations.js";

package/src/type-assertion.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for type assertion handling
+ * Verifies that TypeScript type assertions are stripped during IR conversion
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "./emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Type Assertion Emission", () => {
+  it("should strip 'as' type assertions", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/assertion.ts",
+      namespace: "Test",
+      className: "assertion",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "value" },
+              type: { kind: "primitiveType", name: "string" },
+              // In the IR, type assertions are already stripped
+              // So this is just the underlying expression
+              initializer: { kind: "literal", value: "hello" },
+            },
+          ],
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should emit the value directly without any type assertion
+    expect(code).to.include('string value = "hello"');
+    // Note: "as" might appear in "class" or "namespace" - check for actual cast syntax
+    expect(code).not.to.match(/\sas\s/);
+  });
+
+  it("should handle nested expressions with type assertions", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/nested.ts",
+      namespace: "Test",
+      className: "nested",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "getValue",
+          parameters: [],
+          returnType: { kind: "primitiveType", name: "number" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "returnStatement",
+                // Type assertion is stripped, only the literal remains
+                expression: { kind: "literal", value: 42 },
+              },
+            ],
+          },
+          isAsync: false,
+          isGenerator: false,
+          isExported: true,
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should emit clean C# without type assertions - C# handles implicit conversion
+    expect(code).to.include("return 42");
+    // Note: "as" might appear in "class" or "namespace" - check for actual cast syntax
+    expect(code).not.to.match(/\sas\s/);
+  });
+
+  it("should preserve union types when assertion is stripped", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/test/unionAssert.ts",
+      namespace: "Test",
+      className: "unionAssert",
+      isStaticContainer: true,
+      imports: [],
+      exports: [],
+      body: [
+        {
+          kind: "functionDeclaration",
+          name: "process",
+          parameters: [
+            {
+              kind: "parameter",
+              pattern: { kind: "identifierPattern", name: "input" },
+              type: {
+                kind: "unionType",
+                types: [
+                  { kind: "primitiveType", name: "string" },
+                  { kind: "primitiveType", name: "number" },
+                ],
+              },
+              isOptional: false,
+              isRest: false,
+              passing: "value",
+            },
+          ],
+          returnType: { kind: "primitiveType", name: "string" },
+          body: {
+            kind: "blockStatement",
+            statements: [
+              {
+                kind: "returnStatement",
+                // Even if there was a type assertion in TS, it's stripped
+                // Only the underlying expression remains
+                expression: { kind: "identifier", name: "input" },
+              },
+            ],
+          },
+          isAsync: false,
+          isGenerator: false,
+          isExported: true,
+        },
+      ],
+    };
+
+    const code = emitModule(module);
+
+    // Should preserve union type parameter
+    expect(code).to.include("Union<string, double> input");
+    // Should return the value directly
+    expect(code).to.include("return input");
+  });
+});

package/src/type-emitter.ts

@@ -0,0 +1,18 @@
+/**
+ * Type Emitter - IR types to C# types
+ * Main dispatcher - re-exports from types/ subdirectory
+ */
+
+export {
+  emitType,
+  emitTypeParameters,
+  emitParameterType,
+  emitPrimitiveType,
+  emitReferenceType,
+  emitArrayType,
+  emitFunctionType,
+  emitObjectType,
+  emitUnionType,
+  emitIntersectionType,
+  emitLiteralType,
+} from "./types/index.js";

package/src/types/arrays.ts

@@ -0,0 +1,21 @@
+/**
+ * Array type emission
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitType } from "./emitter.js";
+
+/**
+ * Emit array types as global::System.Collections.Generic.List<T>
+ */
+export const emitArrayType = (
+  type: Extract<IrType, { kind: "arrayType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  const [elementType, newContext] = emitType(type.elementType, context);
+  return [
+    `global::System.Collections.Generic.List<${elementType}>`,
+    newContext,
+  ];
+};

package/src/types/dictionaries.ts

@@ -0,0 +1,52 @@
+/**
+ * Dictionary type emission
+ */
+
+import { IrDictionaryType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitType } from "./emitter.js";
+
+/**
+ * Emit dictionary type as global::System.Collections.Generic.Dictionary<TKey, TValue>
+ *
+ * IrDictionaryType represents:
+ * - `{ [k: string]: T }` → Dictionary<string, T>
+ * - `Record<string, T>` → Dictionary<string, T>
+ *
+ * Note: Only string keys are supported (TSN7413). Number keys are rejected
+ * at validation time because TS number keys have string-ish semantics.
+ */
+export const emitDictionaryType = (
+  type: IrDictionaryType,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  // Emit key type
+  const [keyTypeStr, ctx1] = emitDictionaryKeyType(type.keyType, context);
+
+  // Emit value type
+  const [valueTypeStr, ctx2] = emitType(type.valueType, ctx1);
+
+  return [
+    `global::System.Collections.Generic.Dictionary<${keyTypeStr}, ${valueTypeStr}>`,
+    ctx2,
+  ];
+};
+
+/**
+ * Emit dictionary key type.
+ * Only string keys are supported (enforced by TSN7413).
+ * Non-string keys trigger ICE - validation should have caught them.
+ */
+const emitDictionaryKeyType = (
+  keyType: IrDictionaryType["keyType"],
+  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}`
+  );
+};

package/src/types/emitter.ts

@@ -0,0 +1,76 @@
+/**
+ * Type emission main dispatcher
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitPrimitiveType } from "./primitives.js";
+import { emitReferenceType } from "./references.js";
+import { emitArrayType } from "./arrays.js";
+import { emitFunctionType } from "./functions.js";
+import { emitObjectType } from "./objects.js";
+import { emitDictionaryType } from "./dictionaries.js";
+import { emitUnionType } from "./unions.js";
+import { emitIntersectionType } from "./intersections.js";
+import { emitLiteralType } from "./literals.js";
+
+/**
+ * Emit a C# type from an IR type
+ */
+export const emitType = (
+  type: IrType,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  switch (type.kind) {
+    case "primitiveType":
+      return emitPrimitiveType(type, context);
+
+    case "referenceType":
+      return emitReferenceType(type, context);
+
+    case "arrayType":
+      return emitArrayType(type, context);
+
+    case "functionType":
+      return emitFunctionType(type, context);
+
+    case "objectType":
+      return emitObjectType(type, context);
+
+    case "dictionaryType":
+      return emitDictionaryType(type, context);
+
+    case "unionType":
+      return emitUnionType(type, context);
+
+    case "intersectionType":
+      return emitIntersectionType(type, context);
+
+    case "literalType":
+      return emitLiteralType(type, context);
+
+    case "anyType":
+      // ICE: Frontend validation (TSN7401) should have caught this.
+      throw new Error(
+        "ICE: 'any' type reached emitter - validation missed TSN7401"
+      );
+
+    case "unknownType":
+      // 'unknown' is a legitimate type - emit as nullable object
+      return ["object?", context];
+
+    case "voidType":
+      return ["void", context];
+
+    case "neverType":
+      return ["void", context];
+
+    default: {
+      // ICE: All IR types should be handled explicitly
+      const exhaustiveCheck: never = type;
+      throw new Error(
+        `ICE: Unhandled IR type kind: ${(exhaustiveCheck as IrType).kind}`
+      );
+    }
+  }
+};

package/src/types/functions.ts

@@ -0,0 +1,45 @@
+/**
+ * Function type emission (global::System.Func<>, global::System.Action<>)
+ */
+
+import { IrType } from "@tsonic/frontend";
+import { EmitterContext } from "../types.js";
+import { emitType } from "./emitter.js";
+
+/**
+ * Emit function types as global::System.Func<> or global::System.Action<> delegates
+ */
+export const emitFunctionType = (
+  type: Extract<IrType, { kind: "functionType" }>,
+  context: EmitterContext
+): [string, EmitterContext] => {
+  // For function types, we'll use Func<> or Action<> delegates
+  const paramTypes: string[] = [];
+  let currentContext = context;
+
+  for (const param of type.parameters) {
+    const paramType = param.type ?? { kind: "anyType" as const };
+    const [typeStr, newContext] = emitType(paramType, currentContext);
+    paramTypes.push(typeStr);
+    currentContext = newContext;
+  }
+
+  const returnTypeNode = type.returnType ?? { kind: "voidType" as const };
+  const [returnType, newContext] = emitType(returnTypeNode, currentContext);
+
+  if (returnType === "void") {
+    if (paramTypes.length === 0) {
+      return ["global::System.Action", newContext];
+    }
+    return [`global::System.Action<${paramTypes.join(", ")}>`, newContext];
+  }
+
+  if (paramTypes.length === 0) {
+    return [`global::System.Func<${returnType}>`, newContext];
+  }
+
+  return [
+    `global::System.Func<${paramTypes.join(", ")}, ${returnType}>`,
+    newContext,
+  ];
+};