@tsonic/emitter 0.0.1 → 0.0.3

package/src/expressions/identifiers.ts

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

@@ -1,515 +0,0 @@
-/**
- * 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");
-  });
-});