@tsonic/emitter 0.0.1 → 0.0.3

package/src/specialization/collection/expressions.ts

@@ -1,184 +0,0 @@
-/**
- * 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/orchestrator.ts

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

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

@@ -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");
-  });
-});