@tsonic/emitter 0.0.1

package/src/expressions/identifiers.ts

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

package/src/expressions/index.test.ts

@@ -0,0 +1,515 @@
+/**
+ * Tests for Expression Emission
+ * Tests emission of literals, arrays, and template literals
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { emitModule } from "../emitter.js";
+import { IrModule } from "@tsonic/frontend";
+
+describe("Expression Emission", () => {
+  it("should emit literals correctly", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "str" },
+              initializer: { kind: "literal", value: "hello" },
+            },
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "num" },
+              initializer: { kind: "literal", value: 42 },
+            },
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "bool" },
+              initializer: { kind: "literal", value: true },
+            },
+          ],
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include('"hello"');
+    expect(result).to.include("42"); // C# handles implicit conversion
+    expect(result).to.include("true");
+  });
+
+  it("should emit array expressions", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "arr" },
+              initializer: {
+                kind: "array",
+                elements: [
+                  { kind: "literal", value: 1 },
+                  { kind: "literal", value: 2 },
+                  { kind: "literal", value: 3 },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include("new global::System.Collections.Generic.List<");
+    expect(result).to.include("1, 2, 3"); // C# handles implicit conversion
+    // No using statements - uses global:: FQN
+    expect(result).not.to.include("using System.Collections.Generic");
+  });
+
+  it("should emit template literals", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "greeting" },
+              initializer: {
+                kind: "templateLiteral",
+                quasis: ["Hello ", "!"],
+                expressions: [{ kind: "identifier", name: "name" }],
+              },
+            },
+          ],
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    expect(result).to.include('$"Hello {name}!"');
+  });
+
+  it("should use csharpName for identifiers when provided", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "expressionStatement",
+          expression: {
+            kind: "call",
+            callee: {
+              kind: "memberAccess",
+              object: {
+                kind: "identifier",
+                name: "console",
+                resolvedClrType: "System.Console",
+                resolvedAssembly: "System",
+                csharpName: "Console", // Custom C# name
+              },
+              property: "log",
+              isComputed: false,
+              isOptional: false,
+            },
+            arguments: [{ kind: "literal", value: "Hello with csharpName" }],
+            isOptional: false,
+          },
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should use global:: prefixed assembly + csharpName
+    expect(result).to.include("global::System.Console.log");
+    // No using statements
+    expect(result).not.to.include("using System");
+  });
+
+  it("should use resolvedClrType when csharpName is not provided", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "expressionStatement",
+          expression: {
+            kind: "call",
+            callee: {
+              kind: "memberAccess",
+              object: {
+                kind: "identifier",
+                name: "Math",
+                resolvedClrType: "Tsonic.JSRuntime.Math",
+                resolvedAssembly: "Tsonic.JSRuntime",
+                // No csharpName specified
+              },
+              property: "sqrt",
+              isComputed: false,
+              isOptional: false,
+            },
+            arguments: [{ kind: "literal", value: 16 }],
+            isOptional: false,
+          },
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should use global:: prefixed full type name when no csharpName
+    // resolvedClrType already contains full type name, just add global::
+    expect(result).to.include("global::Tsonic.JSRuntime.Math.sqrt");
+    // No using statements
+    expect(result).not.to.include("using Tsonic.JSRuntime");
+  });
+
+  it("should emit hierarchical member bindings correctly", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "expressionStatement",
+          expression: {
+            kind: "call",
+            callee: {
+              kind: "memberAccess",
+              object: {
+                kind: "memberAccess",
+                object: { kind: "identifier", name: "systemLinq" },
+                property: "enumerable",
+                isComputed: false,
+                isOptional: false,
+              },
+              property: "selectMany",
+              isComputed: false,
+              isOptional: false,
+              // Hierarchical member binding from manifest
+              memberBinding: {
+                assembly: "System.Linq",
+                type: "System.Linq.Enumerable",
+                member: "SelectMany",
+              },
+            },
+            arguments: [
+              { kind: "array", elements: [{ kind: "literal", value: 1 }] },
+            ],
+            isOptional: false,
+          },
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should emit full CLR type and member from binding with global:: prefix
+    expect(result).to.include(
+      "global::System.Linq.System.Linq.Enumerable.SelectMany"
+    );
+    // No using statements
+    expect(result).not.to.include("using System.Linq");
+  });
+
+  it("should emit hierarchical member bindings without emitting intermediate objects", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "result" },
+              initializer: {
+                kind: "call",
+                callee: {
+                  kind: "memberAccess",
+                  object: {
+                    kind: "memberAccess",
+                    object: { kind: "identifier", name: "myLib" },
+                    property: "math",
+                    isComputed: false,
+                    isOptional: false,
+                  },
+                  property: "add",
+                  isComputed: false,
+                  isOptional: false,
+                  memberBinding: {
+                    assembly: "MyLib",
+                    type: "MyLib.Math",
+                    member: "Add",
+                  },
+                },
+                arguments: [
+                  { kind: "literal", value: 1 },
+                  { kind: "literal", value: 2 },
+                ],
+                isOptional: false,
+              },
+            },
+          ],
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should emit global::MyLib.MyLib.Math.Add directly
+    expect(result).to.include("global::MyLib.MyLib.Math.Add");
+    // Should NOT include myLib.math (intermediate objects shouldn't appear)
+    expect(result).not.to.include("myLib.math");
+    // No using statements
+    expect(result).not.to.include("using MyLib");
+  });
+
+  it("should handle member access without binding (regular property access)", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "expressionStatement",
+          expression: {
+            kind: "memberAccess",
+            object: { kind: "identifier", name: "obj" },
+            property: "property",
+            isComputed: false,
+            isOptional: false,
+            // No memberBinding - regular property access
+          },
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should emit regular property access
+    expect(result).to.include("obj.property");
+  });
+
+  it("should escape special characters in dictionary keys", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: false,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "dict" },
+              type: {
+                kind: "dictionaryType",
+                keyType: { kind: "primitiveType", name: "string" },
+                valueType: { kind: "primitiveType", name: "number" },
+              },
+              initializer: {
+                kind: "object",
+                properties: [
+                  {
+                    kind: "property",
+                    key: 'key"with"quotes',
+                    value: { kind: "literal", value: 1 },
+                    shorthand: false,
+                  },
+                  {
+                    kind: "property",
+                    key: "key\\with\\backslashes",
+                    value: { kind: "literal", value: 2 },
+                    shorthand: false,
+                  },
+                  {
+                    kind: "property",
+                    key: "key\nwith\nnewlines",
+                    value: { kind: "literal", value: 3 },
+                    shorthand: false,
+                  },
+                ],
+                contextualType: {
+                  kind: "dictionaryType",
+                  keyType: { kind: "primitiveType", name: "string" },
+                  valueType: { kind: "primitiveType", name: "number" },
+                },
+              },
+            },
+          ],
+        },
+      ],
+      exports: [],
+    };
+
+    const result = emitModule(module);
+
+    // Should escape quotes
+    expect(result).to.include('["key\\"with\\"quotes"]');
+    // Should escape backslashes
+    expect(result).to.include('["key\\\\with\\\\backslashes"]');
+    // Should escape newlines
+    expect(result).to.include('["key\\nwith\\nnewlines"]');
+    // Should be a Dictionary with global:: prefix
+    expect(result).to.include(
+      "new global::System.Collections.Generic.Dictionary<string, double>"
+    );
+  });
+
+  it("should infer arrow function return type from inferredType", () => {
+    const module: IrModule = {
+      kind: "module",
+      filePath: "/src/test.ts",
+      namespace: "MyApp",
+      className: "test",
+      isStaticContainer: true,
+      imports: [],
+      body: [
+        {
+          kind: "variableDeclaration",
+          declarationKind: "const",
+          isExported: true,
+          declarations: [
+            {
+              kind: "variableDeclarator",
+              name: { kind: "identifierPattern", name: "add" },
+              // No explicit type annotation
+              initializer: {
+                kind: "arrowFunction",
+                parameters: [
+                  {
+                    kind: "parameter",
+                    pattern: { kind: "identifierPattern", name: "a" },
+                    type: { kind: "primitiveType", name: "number" },
+                    isOptional: false,
+                    isRest: false,
+                    passing: "value",
+                  },
+                  {
+                    kind: "parameter",
+                    pattern: { kind: "identifierPattern", name: "b" },
+                    type: { kind: "primitiveType", name: "number" },
+                    isOptional: false,
+                    isRest: false,
+                    passing: "value",
+                  },
+                ],
+                // No explicit returnType
+                body: {
+                  kind: "binary",
+                  operator: "+",
+                  left: { kind: "identifier", name: "a" },
+                  right: { kind: "identifier", name: "b" },
+                },
+                isAsync: false,
+                // TypeScript inferred type
+                inferredType: {
+                  kind: "functionType",
+                  parameters: [
+                    {
+                      kind: "parameter",
+                      pattern: { kind: "identifierPattern", name: "a" },
+                      type: { kind: "primitiveType", name: "number" },
+                      isOptional: false,
+                      isRest: false,
+                      passing: "value",
+                    },
+                    {
+                      kind: "parameter",
+                      pattern: { kind: "identifierPattern", name: "b" },
+                      type: { kind: "primitiveType", name: "number" },
+                      isOptional: false,
+                      isRest: false,
+                      passing: "value",
+                    },
+                  ],
+                  returnType: { kind: "primitiveType", name: "number" },
+                },
+              },
+            },
+          ],
+        },
+      ],
+      exports: [
+        {
+          kind: "named",
+          name: "add",
+          localName: "add",
+        },
+      ],
+    };
+
+    const result = emitModule(module);
+
+    // Should infer Func<double, double, double> from inferredType with global:: prefix
+    expect(result).to.include("global::System.Func<double, double, double>");
+    expect(result).to.include("public static");
+  });
+});

package/src/expressions/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Expression emitters barrel exports
+ */
+
+// Literals
+export { emitLiteral } from "./literals.js";
+
+// Identifiers and type helpers
+export {
+  emitIdentifier,
+  emitTypeArguments,
+  generateSpecializedName,
+} from "./identifiers.js";
+
+// Collections
+export { emitArray, emitObject } from "./collections.js";
+
+// Member access
+export { emitMemberAccess } from "./access.js";
+
+// Calls
+export { emitCall, emitNew } from "./calls.js";
+
+// Operators
+export {
+  emitBinary,
+  emitLogical,
+  emitUnary,
+  emitUpdate,
+  emitAssignment,
+  emitConditional,
+} from "./operators.js";
+
+// Functions
+export { emitFunctionExpression, emitArrowFunction } from "./functions.js";
+
+// Other
+export { emitTemplateLiteral, emitSpread, emitAwait } from "./other.js";