@tsonic/emitter 0.0.1 → 0.0.2

package/src/array.test.ts

@@ -1,301 +0,0 @@
-/**
- * Tests for array emission
- * Verifies Tsonic.JSRuntime extension methods usage and JavaScript semantics
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "./emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Array Emission", () => {
-  it("should emit basic array literal with correct type", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/arrays.ts",
-      namespace: "Test",
-      className: "arrays",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "numbers" },
-              type: {
-                kind: "referenceType",
-                name: "Array",
-                typeArguments: [{ kind: "primitiveType", name: "number" }],
-              },
-              initializer: {
-                kind: "array",
-                elements: [
-                  { kind: "literal", value: 1 },
-                  { kind: "literal", value: 2 },
-                  { kind: "literal", value: 3 },
-                ],
-              },
-            },
-          ],
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Integer literals create List<int> - C# infers type from literal values
-    // Uses global:: FQN for unambiguous resolution
-    expect(code).to.include(
-      "new global::System.Collections.Generic.List<int> { 1, 2, 3 }"
-    );
-    // No using statements - all types use global:: FQN
-    expect(code).not.to.include("using System.Collections.Generic");
-  });
-
-  it("should emit sparse array with holes", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/sparse.ts",
-      namespace: "Test",
-      className: "sparse",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "sparse" },
-              type: {
-                kind: "referenceType",
-                name: "Array",
-                typeArguments: [{ kind: "primitiveType", name: "number" }],
-              },
-              initializer: {
-                kind: "array",
-                elements: [
-                  { kind: "literal", value: 1 },
-                  undefined, // hole
-                  { kind: "literal", value: 3 },
-                ],
-              },
-            },
-          ],
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Should handle sparse array with default - integer literals create List<int>
-    expect(code).to.include(
-      "new global::System.Collections.Generic.List<int> { 1, default, 3 }"
-    );
-  });
-
-  it("should emit array with string elements", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/strings.ts",
-      namespace: "Test",
-      className: "strings",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "words" },
-              type: {
-                kind: "referenceType",
-                name: "Array",
-                typeArguments: [{ kind: "primitiveType", name: "string" }],
-              },
-              initializer: {
-                kind: "array",
-                elements: [
-                  { kind: "literal", value: "hello" },
-                  { kind: "literal", value: "world" },
-                ],
-              },
-            },
-          ],
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Should use string type parameter
-    expect(code).to.include(
-      "new global::System.Collections.Generic.List<string>"
-    );
-    expect(code).to.include('"hello", "world"');
-  });
-
-  it("should emit empty array", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/empty.ts",
-      namespace: "Test",
-      className: "empty",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "empty" },
-              type: {
-                kind: "referenceType",
-                name: "Array",
-                typeArguments: [{ kind: "primitiveType", name: "number" }],
-              },
-              initializer: {
-                kind: "array",
-                elements: [],
-              },
-            },
-          ],
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Should create empty array
-    expect(code).to.include(
-      "new global::System.Collections.Generic.List<double>()"
-    );
-  });
-
-  it("should emit array method calls correctly", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/methods.ts",
-      namespace: "Test",
-      className: "methods",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      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: "expressionStatement",
-          expression: {
-            kind: "call",
-            callee: {
-              kind: "memberAccess",
-              object: { kind: "identifier", name: "arr" },
-              property: "push",
-              isComputed: false,
-              isOptional: false,
-            },
-            arguments: [{ kind: "literal", value: 3 }],
-            isOptional: false,
-          },
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Should call push method on array instance - C# implicitly converts int to double
-    expect(code).to.include("arr.push(3)");
-  });
-
-  it("should handle array element access", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/test/access.ts",
-      namespace: "Test",
-      className: "access",
-      isStaticContainer: true,
-      imports: [],
-      exports: [],
-      body: [
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "arr" },
-              initializer: {
-                kind: "array",
-                elements: [{ kind: "literal", value: 10 }],
-              },
-            },
-          ],
-        },
-        {
-          kind: "variableDeclaration",
-          declarationKind: "const",
-          isExported: false,
-          declarations: [
-            {
-              kind: "variableDeclarator",
-              name: { kind: "identifierPattern", name: "first" },
-              initializer: {
-                kind: "memberAccess",
-                object: {
-                  kind: "identifier",
-                  name: "arr",
-                  inferredType: {
-                    kind: "arrayType",
-                    elementType: { kind: "primitiveType", name: "number" },
-                  },
-                },
-                property: { kind: "literal", value: 0 },
-                isComputed: true,
-                isOptional: false,
-              },
-            },
-          ],
-        },
-      ],
-    };
-
-    const code = emitModule(module);
-
-    // Should use static helper for array access with global:: prefix
-    expect(code).to.include("global::Tsonic.Runtime.Array.get(arr, 0)");
-  });
-});

package/src/constants.ts

@@ -1,32 +0,0 @@
-/**
- * Shared constants for the Tsonic emitter
- */
-
-/**
- * Generate standard file header for emitted C# files
- *
- * @param filePath - Source TypeScript file path
- * @param options - Header generation options
- * @returns Multi-line header string with trailing newline
- */
-export const generateFileHeader = (
-  filePath: string,
-  options: {
-    readonly includeTimestamp?: boolean;
-    readonly timestamp?: string;
-  } = {}
-): string => {
-  const lines: string[] = [];
-
-  lines.push(`// Generated from: ${filePath}`);
-
-  if (options.includeTimestamp ?? true) {
-    const timestamp = options.timestamp ?? new Date().toISOString();
-    lines.push(`// Generated at: ${timestamp}`);
-  }
-
-  lines.push("// WARNING: Do not modify this file manually");
-  lines.push("");
-
-  return lines.join("\n");
-};

package/src/core/exports.ts

@@ -1,36 +0,0 @@
-/**
- * Export handling
- */
-
-import { IrExport } from "@tsonic/frontend";
-import { EmitterContext, getIndent } from "../types.js";
-import { emitExpression } from "../expression-emitter.js";
-
-/**
- * Emit an export declaration
- */
-export const emitExport = (
-  exp: IrExport,
-  context: EmitterContext
-): [string | null, EmitterContext] => {
-  switch (exp.kind) {
-    case "named":
-      // Named exports are handled by marking declarations as public
-      return [null, context];
-
-    case "default": {
-      // Default exports need special handling
-      // For MVP, we'll emit a comment
-      const [exprFrag, newContext] = emitExpression(exp.expression, context);
-      const ind = getIndent(context);
-      return [`${ind}// Default export: ${exprFrag.text}`, newContext];
-    }
-
-    case "declaration":
-      // Export declarations are already handled in the body
-      return [null, context];
-
-    default:
-      return [null, context];
-  }
-};

package/src/core/imports.test.ts

@@ -1,83 +0,0 @@
-/**
- * Tests for Import Handling
- * Tests emission of .NET and local imports
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Import Handling", () => {
-  it("should handle .NET imports", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/test.ts",
-      namespace: "MyApp",
-      className: "test",
-      isStaticContainer: true,
-      imports: [
-        {
-          kind: "import",
-          source: "System.IO",
-          isLocal: false,
-          isDotNet: true,
-          specifiers: [],
-          resolvedNamespace: "System.IO",
-        },
-        {
-          kind: "import",
-          source: "System.Text.Json",
-          isLocal: false,
-          isDotNet: true,
-          specifiers: [],
-          resolvedNamespace: "System.Text.Json",
-        },
-      ],
-      body: [],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("using System.IO");
-    expect(result).to.include("using System.Text.Json");
-  });
-
-  it("should NOT emit using directives for local imports", () => {
-    // Local module imports are always emitted as fully-qualified references,
-    // so we don't need using directives for them
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/services/api.ts",
-      namespace: "MyApp.services",
-      className: "api",
-      isStaticContainer: true,
-      imports: [
-        {
-          kind: "import",
-          source: "./auth.ts",
-          isLocal: true,
-          isDotNet: false,
-          specifiers: [],
-        },
-        {
-          kind: "import",
-          source: "../models/User.ts",
-          isLocal: true,
-          isDotNet: false,
-          specifiers: [],
-        },
-      ],
-      body: [],
-      exports: [],
-    };
-
-    const result = emitModule(module, { rootNamespace: "MyApp" });
-
-    // Should NOT include using directives for local modules
-    // (identifiers from local imports are emitted fully-qualified)
-    expect(result).to.not.include("using MyApp.services;");
-    expect(result).to.not.include("using MyApp.models;");
-  });
-});

package/src/core/imports.ts

@@ -1,243 +0,0 @@
-/**
- * Import processing and resolution
- *
- * All imports are resolved to fully-qualified global:: references.
- * No using statements are emitted - everything uses explicit FQN.
- *
- * All CLR name resolution happens here using module map - the emitter
- * just uses the pre-computed clrName directly (no string parsing).
- */
-
-import { IrImport, IrModule, IrImportSpecifier } from "@tsonic/frontend";
-import { EmitterContext, ImportBinding } from "../types.js";
-import { resolveImportPath } from "./module-map.js";
-
-/**
- * Process imports and build ImportBindings for local modules.
- *
- * NOTE: No using statements are collected. All type/member references
- * are emitted as fully-qualified global:: names.
- *
- * - BCL/runtime imports: No action needed (types use global:: FQN)
- * - Local module imports: Build ImportBindings with fully-qualified CLR names
- */
-export const processImports = (
-  imports: readonly IrImport[],
-  context: EmitterContext,
-  module: IrModule
-): EmitterContext => {
-  const importBindings = new Map<string, ImportBinding>();
-
-  const updatedContext = imports.reduce((ctx, imp) => {
-    // BCL/runtime imports: No using needed, types are emitted with global:: FQN
-    // .NET imports: No using needed, types are emitted with global:: FQN
-
-    if (imp.isLocal) {
-      // Local import - build ImportBindings with fully-qualified CLR names
-      // NO using directive for local modules
-      const moduleMap = ctx.options.moduleMap;
-      const exportMap = ctx.options.exportMap;
-      if (moduleMap) {
-        const targetPath = resolveImportPath(module.filePath, imp.source);
-
-        // Process each import specifier - may need to resolve re-exports
-        for (const spec of imp.specifiers) {
-          const exportName =
-            spec.kind === "named"
-              ? spec.name
-              : spec.kind === "default"
-                ? ""
-                : "";
-
-          // Check if this is a re-export - look up in export map
-          const reexportKey = `${targetPath}:${exportName}`;
-          const reexportSource = exportMap?.get(reexportKey);
-
-          // Determine the actual source module
-          const actualSourcePath = reexportSource?.sourceFile ?? targetPath;
-          const actualExportName = reexportSource?.sourceName ?? exportName;
-          const targetModule = moduleMap.get(actualSourcePath);
-
-          if (targetModule) {
-            const binding = createImportBinding(
-              spec,
-              targetModule.namespace,
-              targetModule.className,
-              actualExportName
-            );
-            if (binding) {
-              importBindings.set(binding.localName, binding.importBinding);
-            }
-          }
-        }
-        // If module not found in map, it's a compilation error - will be caught elsewhere
-      }
-      // No module map = single file compilation, no import bindings needed
-    }
-
-    // External packages not supported in MVP
-    return ctx;
-  }, context);
-
-  // Add import bindings to context
-  return {
-    ...updatedContext,
-    importBindings,
-  };
-};
-
-/**
- * Create import binding with fully-qualified global:: CLR names.
- * Uses isType from frontend (set by TS checker) to determine kind.
- *
- * - Type imports: clrName is the type's global:: FQN (global::namespace.TypeName)
- * - Value imports: clrName is the container global:: FQN, member is the export name
- * - Namespace imports: clrName is the container global:: FQN
- */
-const createImportBinding = (
-  spec: IrImportSpecifier,
-  namespace: string,
-  containerClassName: string,
-  resolvedExportName: string
-): { localName: string; importBinding: ImportBinding } | null => {
-  const localName = spec.localName;
-  const containerFqn = `global::${namespace}.${containerClassName}`;
-
-  if (spec.kind === "named") {
-    // Use isType from frontend (determined by TS checker)
-    const isType = spec.isType === true;
-
-    if (isType) {
-      // Type import: clrName is the type's FQN at namespace level
-      // Types are emitted at namespace level, not inside container class
-      return {
-        localName,
-        importBinding: {
-          kind: "type",
-          clrName: `global::${namespace}.${resolvedExportName}`,
-        },
-      };
-    } else {
-      // Value import: clrName is container, member is the export name
-      return {
-        localName,
-        importBinding: {
-          kind: "value",
-          clrName: containerFqn,
-          member: resolvedExportName,
-        },
-      };
-    }
-  }
-
-  if (spec.kind === "default") {
-    // Default export binds to the container class itself
-    // TODO: Consider adding diagnostic for unsupported default exports
-    return {
-      localName,
-      importBinding: {
-        kind: "value",
-        clrName: containerFqn,
-      },
-    };
-  }
-
-  if (spec.kind === "namespace") {
-    // Namespace imports (import * as M) - bind to the container class
-    return {
-      localName,
-      importBinding: {
-        kind: "namespace",
-        clrName: containerFqn,
-      },
-    };
-  }
-
-  return null;
-};
-
-/**
- * Resolve local import to a namespace (legacy fallback for single-file compilation)
- */
-export const resolveLocalImport = (
-  imp: IrImport,
-  currentFilePath: string,
-  rootNamespace: string
-): string | null => {
-  // Normalize paths - handle both Unix and Windows separators
-  const normalize = (p: string) => p.replace(/\\/g, "/");
-  const currentFile = normalize(currentFilePath);
-
-  // Get the directory of the current file
-  const currentDir = currentFile.substring(0, currentFile.lastIndexOf("/"));
-
-  // Resolve the import path relative to current directory
-  const resolvedPath = resolveRelativePath(currentDir, imp.source);
-
-  // Remove .ts extension and get directory path
-  const withoutExtension = resolvedPath.replace(/\.ts$/, "");
-  const dirPath = withoutExtension.substring(
-    0,
-    withoutExtension.lastIndexOf("/")
-  );
-
-  // Convert directory path to namespace - only use path after last "/src/"
-  const relativePath = extractRelativePath(dirPath);
-  const parts = relativePath.split("/").filter((p) => p !== "" && p !== ".");
-
-  return parts.length === 0
-    ? rootNamespace
-    : `${rootNamespace}.${parts.join(".")}`;
-};
-
-/**
- * Resolve a relative import path from a given directory
- */
-const resolveRelativePath = (currentDir: string, source: string): string => {
-  if (source.startsWith("./")) {
-    return `${currentDir}/${source.substring(2)}`;
-  }
-
-  if (source.startsWith("../")) {
-    const parts = currentDir.split("/");
-    const sourceCopy = source;
-    return resolveParentPath(parts, sourceCopy);
-  }
-
-  return `${currentDir}/${source}`;
-};
-
-/**
- * Resolve parent path references (..)
- */
-const resolveParentPath = (parts: string[], source: string): string => {
-  if (!source.startsWith("../")) {
-    return `${parts.join("/")}/${source}`;
-  }
-  return resolveParentPath(parts.slice(0, -1), source.substring(3));
-};
-
-/**
- * Extract relative path from a directory path
- */
-const extractRelativePath = (dirPath: string): string => {
-  const srcIndex = dirPath.lastIndexOf("/src/");
-
-  if (srcIndex >= 0) {
-    return dirPath.substring(srcIndex + 5);
-  }
-
-  if (dirPath.endsWith("/src")) {
-    return "";
-  }
-
-  if (dirPath.startsWith("src/")) {
-    return dirPath.substring(4);
-  }
-
-  if (dirPath === "src") {
-    return "";
-  }
-
-  return "";
-};