@tsonic/emitter 0.0.1 → 0.0.2

package/src/specialization/collection.ts

@@ -1,10 +0,0 @@
-/**
- * Collect specialization requests from IR
- * Main dispatcher - re-exports from collection/ subdirectory
- */
-
-export {
-  collectSpecializations,
-  collectFromStatement,
-  collectFromExpression,
-} from "./collection/index.js";

package/src/specialization/generation.ts

@@ -1,189 +0,0 @@
-/**
- * Generate specialized declarations from requests
- */
-
-import {
-  IrFunctionDeclaration,
-  IrClassDeclaration,
-  IrBlockStatement,
-  IrType,
-} from "@tsonic/frontend";
-import { EmitterContext } from "../types.js";
-import { emitStatement } from "../statement-emitter.js";
-import { SpecializationRequest } from "./types.js";
-import {
-  generateSpecializedFunctionName,
-  generateSpecializedClassName,
-} from "./naming.js";
-import {
-  substituteType,
-  substituteStatement,
-  substituteExpression,
-} from "./substitution.js";
-
-/**
- * Generate specialized declarations from requests
- * Returns C# code for the specialized declarations
- */
-export const generateSpecializations = (
-  requests: readonly SpecializationRequest[],
-  context: EmitterContext
-): [string, EmitterContext] => {
-  if (requests.length === 0) {
-    return ["", context];
-  }
-
-  const parts: string[] = [];
-  let currentContext = context;
-
-  for (const request of requests) {
-    if (request.kind === "function") {
-      const [code, newContext] = generateSpecializedFunction(
-        request,
-        currentContext
-      );
-      parts.push(code);
-      currentContext = newContext;
-    } else if (request.kind === "class") {
-      const [code, newContext] = generateSpecializedClass(
-        request,
-        currentContext
-      );
-      parts.push(code);
-      currentContext = newContext;
-    }
-  }
-
-  return [parts.join("\n\n"), currentContext];
-};
-
-/**
- * Generate a specialized function by substituting type parameters
- */
-const generateSpecializedFunction = (
-  request: SpecializationRequest,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const funcDecl = request.declaration as IrFunctionDeclaration;
-
-  // Create type substitution map
-  const substitutions = new Map<string, IrType>();
-  if (funcDecl.typeParameters) {
-    funcDecl.typeParameters.forEach((tp, index) => {
-      const typeArg = request.typeArguments[index];
-      if (typeArg) {
-        substitutions.set(tp.name, typeArg);
-      }
-    });
-  }
-
-  // Substitute types in the function declaration
-  const specializedDecl: IrFunctionDeclaration = {
-    ...funcDecl,
-    name: generateSpecializedFunctionName(funcDecl.name, request.typeArguments),
-    typeParameters: undefined, // Remove type parameters
-    parameters: funcDecl.parameters.map((param) => ({
-      ...param,
-      type: param.type ? substituteType(param.type, substitutions) : undefined,
-    })),
-    returnType: funcDecl.returnType
-      ? substituteType(funcDecl.returnType, substitutions)
-      : undefined,
-    body: substituteStatement(funcDecl.body, substitutions) as IrBlockStatement,
-  };
-
-  // Emit the specialized function using the statement emitter
-  return emitStatement(specializedDecl, context);
-};
-
-/**
- * Generate a specialized class by substituting type parameters
- */
-const generateSpecializedClass = (
-  request: SpecializationRequest,
-  context: EmitterContext
-): [string, EmitterContext] => {
-  const classDecl = request.declaration as IrClassDeclaration;
-
-  // Create type substitution map
-  const substitutions = new Map<string, IrType>();
-  if (classDecl.typeParameters) {
-    classDecl.typeParameters.forEach((tp, index) => {
-      const typeArg = request.typeArguments[index];
-      if (typeArg) {
-        substitutions.set(tp.name, typeArg);
-      }
-    });
-  }
-
-  // Generate specialized class name
-  const specializedName = generateSpecializedClassName(
-    classDecl.name,
-    request.typeArguments
-  );
-
-  // Substitute types in class members
-  const specializedMembers = classDecl.members.map((member) => {
-    if (member.kind === "propertyDeclaration") {
-      return {
-        ...member,
-        type: member.type
-          ? substituteType(member.type, substitutions)
-          : undefined,
-      };
-    } else if (member.kind === "methodDeclaration") {
-      return {
-        ...member,
-        parameters: member.parameters.map((param) => ({
-          ...param,
-          type: param.type
-            ? substituteType(param.type, substitutions)
-            : undefined,
-        })),
-        returnType: member.returnType
-          ? substituteType(member.returnType, substitutions)
-          : undefined,
-        body: member.body
-          ? (substituteStatement(
-              member.body,
-              substitutions
-            ) as IrBlockStatement)
-          : undefined,
-      };
-    } else if (member.kind === "constructorDeclaration") {
-      return {
-        ...member,
-        parameters: member.parameters.map((param) => ({
-          ...param,
-          type: param.type
-            ? substituteType(param.type, substitutions)
-            : undefined,
-        })),
-        body: member.body
-          ? (substituteStatement(
-              member.body,
-              substitutions
-            ) as IrBlockStatement)
-          : undefined,
-      };
-    }
-    return member;
-  });
-
-  // Create specialized class declaration
-  const specializedDecl: IrClassDeclaration = {
-    ...classDecl,
-    name: specializedName,
-    typeParameters: undefined, // Remove type parameters
-    members: specializedMembers,
-    superClass: classDecl.superClass
-      ? substituteExpression(classDecl.superClass, substitutions)
-      : undefined,
-    implements: classDecl.implements.map((iface) =>
-      substituteType(iface, substitutions)
-    ),
-  };
-
-  // Emit the specialized class using the statement emitter
-  return emitStatement(specializedDecl, context);
-};

package/src/specialization/generic-classes.test.ts

@@ -1,59 +0,0 @@
-/**
- * Tests for Generic Classes
- * Covers spec/15-generics.md §3-5 - Generic Classes
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Generic Classes (spec/15 §3-5)", () => {
-  it("should emit generic class with type parameter", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/Box.ts",
-      namespace: "MyApp",
-      className: "Box",
-      isStaticContainer: false,
-      imports: [],
-      body: [
-        {
-          kind: "classDeclaration",
-          name: "Box",
-          typeParameters: [
-            {
-              kind: "typeParameter",
-              name: "T",
-              constraint: undefined,
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: false,
-            },
-          ],
-          isStruct: false,
-          members: [
-            {
-              kind: "propertyDeclaration",
-              name: "value",
-              type: { kind: "referenceType", name: "T", typeArguments: [] },
-              initializer: undefined,
-              accessibility: "public",
-              isStatic: false,
-              isReadonly: false,
-            },
-          ],
-          superClass: undefined,
-          implements: [],
-          isExported: true,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public class Box<T>");
-    expect(result).to.include("public T value");
-  });
-});

package/src/specialization/generic-functions.test.ts

@@ -1,292 +0,0 @@
-/**
- * Tests for Generic Functions
- * Covers spec/15-generics.md §3-5 - Generic Functions
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { emitModule } from "../emitter.js";
-import { IrModule } from "@tsonic/frontend";
-
-describe("Generic Functions (spec/15 §3-5)", () => {
-  it("should emit generic function with single type parameter", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/utils.ts",
-      namespace: "MyApp",
-      className: "utils",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "functionDeclaration",
-          name: "identity",
-          typeParameters: [
-            {
-              kind: "typeParameter",
-              name: "T",
-              constraint: undefined,
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: false,
-            },
-          ],
-          parameters: [
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "value" },
-              type: { kind: "referenceType", name: "T", typeArguments: [] },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-          ],
-          returnType: { kind: "referenceType", name: "T", typeArguments: [] },
-          body: {
-            kind: "blockStatement",
-            statements: [
-              {
-                kind: "returnStatement",
-                expression: { kind: "identifier", name: "value" },
-              },
-            ],
-          },
-          isExported: true,
-          isAsync: false,
-          isGenerator: false,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("public static T identity<T>(T value)");
-    expect(result).to.include("return value");
-  });
-
-  it("should emit generic function with multiple type parameters", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/utils.ts",
-      namespace: "MyApp",
-      className: "utils",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "functionDeclaration",
-          name: "pair",
-          typeParameters: [
-            {
-              kind: "typeParameter",
-              name: "T",
-              constraint: undefined,
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: false,
-            },
-            {
-              kind: "typeParameter",
-              name: "U",
-              constraint: undefined,
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: false,
-            },
-          ],
-          parameters: [
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "first" },
-              type: { kind: "referenceType", name: "T", typeArguments: [] },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "second" },
-              type: { kind: "referenceType", name: "U", typeArguments: [] },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-          ],
-          returnType: {
-            kind: "arrayType",
-            elementType: {
-              kind: "unionType",
-              types: [
-                { kind: "referenceType", name: "T", typeArguments: [] },
-                { kind: "referenceType", name: "U", typeArguments: [] },
-              ],
-            },
-          },
-          body: {
-            kind: "blockStatement",
-            statements: [],
-          },
-          isExported: true,
-          isAsync: false,
-          isGenerator: false,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("<T, U>");
-    expect(result).to.include("pair");
-    expect(result).to.include("T first");
-    expect(result).to.include("U second");
-  });
-
-  it("should emit generic function with nominal constraint", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/utils.ts",
-      namespace: "MyApp",
-      className: "utils",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "functionDeclaration",
-          name: "process",
-          typeParameters: [
-            {
-              kind: "typeParameter",
-              name: "T",
-              constraint: {
-                kind: "referenceType",
-                name: "Comparable",
-                typeArguments: [],
-              },
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: false,
-            },
-          ],
-          parameters: [
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "item" },
-              type: { kind: "referenceType", name: "T", typeArguments: [] },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-          ],
-          returnType: { kind: "voidType" },
-          body: {
-            kind: "blockStatement",
-            statements: [],
-          },
-          isExported: true,
-          isAsync: false,
-          isGenerator: false,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    expect(result).to.include("<T>");
-    expect(result).to.include("where T : Comparable");
-  });
-
-  it("should emit generic function with structural constraint and adapter", () => {
-    const module: IrModule = {
-      kind: "module",
-      filePath: "/src/utils.ts",
-      namespace: "MyApp",
-      className: "utils",
-      isStaticContainer: true,
-      imports: [],
-      body: [
-        {
-          kind: "functionDeclaration",
-          name: "getId",
-          typeParameters: [
-            {
-              kind: "typeParameter",
-              name: "T",
-              constraint: {
-                kind: "objectType",
-                members: [
-                  {
-                    kind: "propertySignature",
-                    name: "id",
-                    type: { kind: "primitiveType", name: "number" },
-                    isOptional: false,
-                    isReadonly: false,
-                  },
-                ],
-              },
-              default: undefined,
-              variance: undefined,
-              isStructuralConstraint: true,
-              structuralMembers: [
-                {
-                  kind: "propertySignature",
-                  name: "id",
-                  type: { kind: "primitiveType", name: "number" },
-                  isOptional: false,
-                  isReadonly: false,
-                },
-              ],
-            },
-          ],
-          parameters: [
-            {
-              kind: "parameter",
-              pattern: { kind: "identifierPattern", name: "obj" },
-              type: { kind: "referenceType", name: "T", typeArguments: [] },
-              isOptional: false,
-              isRest: false,
-              passing: "value",
-            },
-          ],
-          returnType: { kind: "primitiveType", name: "number" },
-          body: {
-            kind: "blockStatement",
-            statements: [
-              {
-                kind: "returnStatement",
-                expression: {
-                  kind: "memberAccess",
-                  object: { kind: "identifier", name: "obj" },
-                  property: "id",
-                  isComputed: false,
-                  isOptional: false,
-                },
-              },
-            ],
-          },
-          isExported: true,
-          isAsync: false,
-          isGenerator: false,
-        },
-      ],
-      exports: [],
-    };
-
-    const result = emitModule(module);
-
-    // Should generate adapter interface
-    expect(result).to.include("public interface __Constraint_T");
-    expect(result).to.include("double id { get; }");
-
-    // Should generate adapter wrapper class
-    expect(result).to.include(
-      "public sealed class __Wrapper_T : __Constraint_T"
-    );
-    expect(result).to.include("public double id { get; set; }");
-
-    // Function should reference the constraint
-    expect(result).to.include("where T : __Constraint_T");
-  });
-});

package/src/specialization/helpers.ts

@@ -1,39 +0,0 @@
-/**
- * Helper functions for specialization (key generation, serialization)
- */
-
-import { IrType } from "@tsonic/frontend";
-
-/**
- * Create a unique key for a specialization request
- */
-export const createSpecializationKey = (
-  name: string,
-  typeArgs: readonly IrType[]
-): string => {
-  // Simple serialization of type arguments for deduplication
-  const typeStrs = typeArgs.map((t) => serializeType(t));
-  return `${name}<${typeStrs.join(",")}>`;
-};
-
-/**
- * Simple type serialization for deduplication
- */
-export const serializeType = (type: IrType): string => {
-  switch (type.kind) {
-    case "primitiveType":
-      return type.name;
-    case "referenceType":
-      if (type.typeArguments && type.typeArguments.length > 0) {
-        const args = type.typeArguments.map(serializeType).join(",");
-        return `${type.name}<${args}>`;
-      }
-      return type.name;
-    case "arrayType":
-      return `${serializeType(type.elementType)}[]`;
-    case "literalType":
-      return `literal:${type.value}`;
-    default:
-      return type.kind;
-  }
-};