@tsonic/emitter 0.0.1

package/src/specialization/collection/expressions.ts

@@ -0,0 +1,184 @@
+/**
+ * Specialization collection from expressions
+ */
+
+import {
+  IrModule,
+  IrExpression,
+  IrFunctionDeclaration,
+  IrClassDeclaration,
+} from "@tsonic/frontend";
+import { SpecializationRequest } from "../types.js";
+import { createSpecializationKey } from "../helpers.js";
+import { collectFromStatement } from "./statements.js";
+
+/**
+ * Collect specializations from an expression
+ */
+export const collectFromExpression = (
+  expr: IrExpression,
+  requests: SpecializationRequest[],
+  seen: Set<string>,
+  module: IrModule
+): void => {
+  switch (expr.kind) {
+    case "call":
+      // Check if this call requires specialization
+      if (
+        expr.requiresSpecialization &&
+        expr.typeArguments &&
+        expr.typeArguments.length > 0
+      ) {
+        // Get function name from callee
+        if (expr.callee.kind === "identifier") {
+          const funcName = expr.callee.name;
+          const key = createSpecializationKey(funcName, expr.typeArguments);
+
+          if (!seen.has(key)) {
+            seen.add(key);
+
+            // Find the function declaration in the module
+            const funcDecl = module.body.find(
+              (stmt) =>
+                stmt.kind === "functionDeclaration" && stmt.name === funcName
+            ) as IrFunctionDeclaration | undefined;
+
+            if (funcDecl) {
+              requests.push({
+                kind: "function",
+                name: funcName,
+                typeArguments: expr.typeArguments,
+                declaration: funcDecl,
+              });
+            }
+          }
+        }
+      }
+
+      // Recurse into callee and arguments
+      collectFromExpression(expr.callee, requests, seen, module);
+      for (const arg of expr.arguments) {
+        if (arg.kind !== "spread") {
+          collectFromExpression(arg, requests, seen, module);
+        }
+      }
+      break;
+
+    case "new":
+      // Check if this constructor call requires specialization
+      if (
+        expr.requiresSpecialization &&
+        expr.typeArguments &&
+        expr.typeArguments.length > 0
+      ) {
+        if (expr.callee.kind === "identifier") {
+          const className = expr.callee.name;
+          const key = createSpecializationKey(className, expr.typeArguments);
+
+          if (!seen.has(key)) {
+            seen.add(key);
+
+            // Find the class declaration in the module
+            const classDecl = module.body.find(
+              (stmt) =>
+                stmt.kind === "classDeclaration" && stmt.name === className
+            ) as IrClassDeclaration | undefined;
+
+            if (classDecl) {
+              requests.push({
+                kind: "class",
+                name: className,
+                typeArguments: expr.typeArguments,
+                declaration: classDecl,
+              });
+            }
+          }
+        }
+      }
+
+      // Recurse into callee and arguments
+      collectFromExpression(expr.callee, requests, seen, module);
+      for (const arg of expr.arguments) {
+        if (arg.kind !== "spread") {
+          collectFromExpression(arg, requests, seen, module);
+        }
+      }
+      break;
+
+    case "binary":
+    case "logical":
+      collectFromExpression(expr.left, requests, seen, module);
+      collectFromExpression(expr.right, requests, seen, module);
+      break;
+
+    case "unary":
+    case "update":
+    case "await":
+      collectFromExpression(expr.expression, requests, seen, module);
+      break;
+
+    case "assignment":
+      if ("kind" in expr.left) {
+        collectFromExpression(
+          expr.left as IrExpression,
+          requests,
+          seen,
+          module
+        );
+      }
+      collectFromExpression(expr.right, requests, seen, module);
+      break;
+
+    case "conditional":
+      collectFromExpression(expr.condition, requests, seen, module);
+      collectFromExpression(expr.whenTrue, requests, seen, module);
+      collectFromExpression(expr.whenFalse, requests, seen, module);
+      break;
+
+    case "memberAccess":
+      collectFromExpression(expr.object, requests, seen, module);
+      if (typeof expr.property !== "string") {
+        collectFromExpression(expr.property, requests, seen, module);
+      }
+      break;
+
+    case "array":
+      for (const elem of expr.elements) {
+        if (elem === undefined) continue;
+        if ("kind" in elem && elem.kind === "spread") {
+          collectFromExpression(elem.expression, requests, seen, module);
+        } else {
+          collectFromExpression(elem, requests, seen, module);
+        }
+      }
+      break;
+
+    case "object":
+      for (const prop of expr.properties) {
+        if (prop.kind === "property") {
+          if (typeof prop.key !== "string") {
+            collectFromExpression(prop.key, requests, seen, module);
+          }
+          collectFromExpression(prop.value, requests, seen, module);
+        } else if (prop.kind === "spread") {
+          collectFromExpression(prop.expression, requests, seen, module);
+        }
+      }
+      break;
+
+    case "arrowFunction":
+    case "functionExpression":
+      if (typeof expr.body === "object" && "kind" in expr.body) {
+        if (expr.body.kind === "blockStatement") {
+          collectFromStatement(expr.body, requests, seen, module);
+        } else {
+          collectFromExpression(expr.body, requests, seen, module);
+        }
+      }
+      break;
+
+    // Literals, identifiers, etc. don't contain expressions
+    default:
+      break;
+  }
+};

package/src/specialization/collection/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Specialization collection - Public API
+ */
+
+export { collectSpecializations } from "./orchestrator.js";
+export { collectFromStatement } from "./statements.js";
+export { collectFromExpression } from "./expressions.js";

package/src/specialization/collection/orchestrator.ts

@@ -0,0 +1,25 @@
+/**
+ * Main specialization collection orchestration
+ */
+
+import { IrModule } from "@tsonic/frontend";
+import { SpecializationRequest } from "../types.js";
+import { collectFromStatement } from "./statements.js";
+
+/**
+ * Collect all specialization requests from a module
+ * Walks the IR tree looking for calls/news with requiresSpecialization flag
+ */
+export const collectSpecializations = (
+  module: IrModule
+): readonly SpecializationRequest[] => {
+  const requests: SpecializationRequest[] = [];
+  const seen = new Set<string>(); // Avoid duplicates
+
+  // Walk through all statements and expressions to find specialization needs
+  for (const stmt of module.body) {
+    collectFromStatement(stmt, requests, seen, module);
+  }
+
+  return requests;
+};

package/src/specialization/collection/statements.ts

@@ -0,0 +1,91 @@
+/**
+ * Specialization collection from statements
+ */
+
+import { IrModule, IrStatement } from "@tsonic/frontend";
+import { SpecializationRequest } from "../types.js";
+import { collectFromExpression } from "./expressions.js";
+
+/**
+ * Collect specializations from a statement
+ */
+export const collectFromStatement = (
+  stmt: IrStatement,
+  requests: SpecializationRequest[],
+  seen: Set<string>,
+  module: IrModule
+): void => {
+  switch (stmt.kind) {
+    case "expressionStatement":
+      collectFromExpression(stmt.expression, requests, seen, module);
+      break;
+
+    case "variableDeclaration":
+      for (const decl of stmt.declarations) {
+        if (decl.initializer) {
+          collectFromExpression(decl.initializer, requests, seen, module);
+        }
+      }
+      break;
+
+    case "returnStatement":
+      if (stmt.expression) {
+        collectFromExpression(stmt.expression, requests, seen, module);
+      }
+      break;
+
+    case "ifStatement":
+      collectFromExpression(stmt.condition, requests, seen, module);
+      collectFromStatement(stmt.thenStatement, requests, seen, module);
+      if (stmt.elseStatement) {
+        collectFromStatement(stmt.elseStatement, requests, seen, module);
+      }
+      break;
+
+    case "blockStatement":
+      for (const s of stmt.statements) {
+        collectFromStatement(s, requests, seen, module);
+      }
+      break;
+
+    case "whileStatement":
+      collectFromExpression(stmt.condition, requests, seen, module);
+      collectFromStatement(stmt.body, requests, seen, module);
+      break;
+
+    case "forStatement":
+      if (stmt.initializer) {
+        if (stmt.initializer.kind === "variableDeclaration") {
+          collectFromStatement(stmt.initializer, requests, seen, module);
+        } else {
+          collectFromExpression(stmt.initializer, requests, seen, module);
+        }
+      }
+      if (stmt.condition) {
+        collectFromExpression(stmt.condition, requests, seen, module);
+      }
+      if (stmt.update) {
+        collectFromExpression(stmt.update, requests, seen, module);
+      }
+      collectFromStatement(stmt.body, requests, seen, module);
+      break;
+
+    case "functionDeclaration":
+      if (stmt.body) {
+        collectFromStatement(stmt.body, requests, seen, module);
+      }
+      break;
+
+    case "classDeclaration":
+      for (const member of stmt.members) {
+        if (member.kind === "methodDeclaration" && member.body) {
+          collectFromStatement(member.body, requests, seen, module);
+        }
+      }
+      break;
+
+    // Other statement types don't contain expressions
+    default:
+      break;
+  }
+};

package/src/specialization/collection.ts

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

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

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