@tsonic/emitter 0.0.1 → 0.0.2

package/src/statements/declarations.ts

@@ -1,13 +0,0 @@
-/**
- * Declaration emitters (variables, functions, classes, interfaces, enums, type aliases)
- * Main dispatcher - re-exports from declarations/ subdirectory
- */
-
-export {
-  emitVariableDeclaration,
-  emitFunctionDeclaration,
-  emitClassDeclaration,
-  emitInterfaceDeclaration,
-  emitEnumDeclaration,
-  emitTypeAliasDeclaration,
-} from "./declarations/index.js";

package/src/statements/index.test.ts

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

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

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

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

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

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

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

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