@tsonic/frontend 0.0.1 → 0.0.4

package/src/ir/converters/statements/helpers.ts

@@ -1,174 +0,0 @@
-/**
- * Helper utilities for statement conversion
- */
-
-import * as ts from "typescript";
-import {
-  IrParameter,
-  IrAccessibility,
-  IrTypeParameter,
-  IrInterfaceMember,
-  IrVariableDeclaration,
-} from "../../types.js";
-import { convertType, convertBindingName } from "../../type-converter.js";
-import { convertExpression } from "../../expression-converter.js";
-import { convertInterfaceMember } from "./declarations.js";
-
-/**
- * Convert TypeScript type parameters to IR, detecting structural constraints
- */
-export const convertTypeParameters = (
-  typeParameters: readonly ts.TypeParameterDeclaration[] | undefined,
-  checker: ts.TypeChecker
-): readonly IrTypeParameter[] | undefined => {
-  if (!typeParameters || typeParameters.length === 0) {
-    return undefined;
-  }
-
-  return typeParameters.map((tp) => {
-    const name = tp.name.text;
-    const constraint = tp.constraint
-      ? convertType(tp.constraint, checker)
-      : undefined;
-    const defaultType = tp.default
-      ? convertType(tp.default, checker)
-      : undefined;
-
-    // Check if constraint is structural (object literal type)
-    const isStructural = tp.constraint && ts.isTypeLiteralNode(tp.constraint);
-
-    // Extract structural members if it's a structural constraint
-    const structuralMembers =
-      isStructural && tp.constraint && ts.isTypeLiteralNode(tp.constraint)
-        ? tp.constraint.members
-            .map((member) => convertInterfaceMember(member, checker))
-            .filter((m): m is IrInterfaceMember => m !== null)
-        : undefined;
-
-    return {
-      kind: "typeParameter" as const,
-      name,
-      constraint,
-      default: defaultType,
-      variance: undefined, // TypeScript doesn't expose variance directly
-      isStructuralConstraint: isStructural,
-      structuralMembers,
-    };
-  });
-};
-
-/**
- * Convert parameters for functions and methods
- */
-export const convertParameters = (
-  parameters: ts.NodeArray<ts.ParameterDeclaration>,
-  checker: ts.TypeChecker
-): readonly IrParameter[] => {
-  return parameters.map((param) => {
-    let passing: "value" | "ref" | "out" | "in" = "value";
-    let actualType: ts.TypeNode | undefined = param.type;
-
-    // Detect ref<T>, out<T>, in<T> wrapper types
-    if (
-      param.type &&
-      ts.isTypeReferenceNode(param.type) &&
-      ts.isIdentifier(param.type.typeName)
-    ) {
-      const typeName = param.type.typeName.text;
-      if (
-        (typeName === "ref" || typeName === "out" || typeName === "in") &&
-        param.type.typeArguments &&
-        param.type.typeArguments.length > 0
-      ) {
-        // Set passing mode
-        passing = typeName === "in" ? "in" : typeName;
-        // Extract wrapped type
-        actualType = param.type.typeArguments[0];
-      }
-    }
-
-    return {
-      kind: "parameter",
-      pattern: convertBindingName(param.name),
-      type: actualType ? convertType(actualType, checker) : undefined,
-      initializer: param.initializer
-        ? convertExpression(param.initializer, checker)
-        : undefined,
-      isOptional: !!param.questionToken,
-      isRest: !!param.dotDotDotToken,
-      passing,
-    };
-  });
-};
-
-/**
- * Convert variable declaration list (used in for loops)
- */
-export const convertVariableDeclarationList = (
-  node: ts.VariableDeclarationList,
-  checker: ts.TypeChecker
-): IrVariableDeclaration => {
-  const isConst = !!(node.flags & ts.NodeFlags.Const);
-  const isLet = !!(node.flags & ts.NodeFlags.Let);
-  const declarationKind = isConst ? "const" : isLet ? "let" : "var";
-
-  return {
-    kind: "variableDeclaration",
-    declarationKind,
-    declarations: node.declarations.map((decl) => ({
-      kind: "variableDeclarator",
-      name: convertBindingName(decl.name),
-      type: decl.type ? convertType(decl.type, checker) : undefined,
-      initializer: decl.initializer
-        ? convertExpression(decl.initializer, checker)
-        : undefined,
-    })),
-    isExported: false,
-  };
-};
-
-/**
- * Check if node has export modifier
- */
-export const hasExportModifier = (node: ts.Node): boolean => {
-  if (!ts.canHaveModifiers(node)) return false;
-  const modifiers = ts.getModifiers(node);
-  return (
-    modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false
-  );
-};
-
-/**
- * Check if node has static modifier
- */
-export const hasStaticModifier = (node: ts.Node): boolean => {
-  if (!ts.canHaveModifiers(node)) return false;
-  const modifiers = ts.getModifiers(node);
-  return (
-    modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false
-  );
-};
-
-/**
- * Check if node has readonly modifier
- */
-export const hasReadonlyModifier = (node: ts.Node): boolean => {
-  if (!ts.canHaveModifiers(node)) return false;
-  const modifiers = ts.getModifiers(node);
-  return (
-    modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false
-  );
-};
-
-/**
- * Get accessibility modifier
- */
-export const getAccessibility = (node: ts.Node): IrAccessibility => {
-  if (!ts.canHaveModifiers(node)) return "public";
-  const modifiers = ts.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword))
-    return "private";
-  if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword))
-    return "protected";
-  return "public";
-};

package/src/ir/converters/statements/index.ts

@@ -1,40 +0,0 @@
-/**
- * Statement converters barrel exports
- */
-
-// Helpers
-export {
-  convertTypeParameters,
-  convertParameters,
-  convertVariableDeclarationList,
-  hasExportModifier,
-  hasStaticModifier,
-  hasReadonlyModifier,
-  getAccessibility,
-} from "./helpers.js";
-
-// Control flow converters
-export {
-  convertIfStatement,
-  convertWhileStatement,
-  convertForStatement,
-  convertForOfStatement,
-  convertForInStatement,
-  convertSwitchStatement,
-  convertSwitchCase,
-  convertTryStatement,
-  convertCatchClause,
-  convertBlockStatement,
-} from "./control.js";
-
-// Declaration converters
-export {
-  setMetadataRegistry,
-  convertVariableStatement,
-  convertFunctionDeclaration,
-  convertClassDeclaration,
-  convertInterfaceDeclaration,
-  convertInterfaceMember,
-  convertEnumDeclaration,
-  convertTypeAliasDeclaration,
-} from "./declarations.js";

package/src/ir/expression-converter.ts

@@ -1,207 +0,0 @@
-/**
- * Expression converter - TypeScript AST to IR expressions
- * Main dispatcher - delegates to specialized modules
- */
-
-import * as ts from "typescript";
-import { IrExpression } from "./types.js";
-import { getBindingRegistry } from "./converters/statements/declarations/registry.js";
-import { convertType } from "./type-converter.js";
-
-// Import expression converters from specialized modules
-import { convertLiteral } from "./converters/expressions/literals.js";
-import {
-  convertArrayLiteral,
-  convertObjectLiteral,
-} from "./converters/expressions/collections.js";
-import { convertMemberExpression } from "./converters/expressions/access.js";
-import {
-  convertCallExpression,
-  convertNewExpression,
-} from "./converters/expressions/calls.js";
-import {
-  convertBinaryExpression,
-  convertUnaryExpression,
-  convertUpdateExpression,
-} from "./converters/expressions/operators.js";
-import {
-  convertFunctionExpression,
-  convertArrowFunction,
-} from "./converters/expressions/functions.js";
-import {
-  convertConditionalExpression,
-  convertTemplateLiteral,
-} from "./converters/expressions/other.js";
-import { getInferredType } from "./converters/expressions/helpers.js";
-
-/**
- * Main expression conversion dispatcher
- * Converts TypeScript expression nodes to IR expressions
- */
-export const convertExpression = (
-  node: ts.Expression,
-  checker: ts.TypeChecker
-): IrExpression => {
-  const inferredType = getInferredType(node, checker);
-
-  if (ts.isStringLiteral(node) || ts.isNumericLiteral(node)) {
-    return convertLiteral(node, checker);
-  }
-  if (
-    node.kind === ts.SyntaxKind.TrueKeyword ||
-    node.kind === ts.SyntaxKind.FalseKeyword
-  ) {
-    return {
-      kind: "literal",
-      value: node.kind === ts.SyntaxKind.TrueKeyword,
-      raw: node.getText(),
-      inferredType,
-    };
-  }
-  if (node.kind === ts.SyntaxKind.NullKeyword) {
-    return { kind: "literal", value: null, raw: "null", inferredType };
-  }
-  if (
-    node.kind === ts.SyntaxKind.UndefinedKeyword ||
-    ts.isVoidExpression(node)
-  ) {
-    return {
-      kind: "literal",
-      value: undefined,
-      raw: "undefined",
-      inferredType,
-    };
-  }
-  if (ts.isIdentifier(node)) {
-    // Check if this identifier is bound to a CLR type (e.g., console, Math, etc.)
-    const binding = getBindingRegistry().getBinding(node.text);
-    if (binding && binding.kind === "global") {
-      return {
-        kind: "identifier",
-        name: node.text,
-        inferredType,
-        resolvedClrType: binding.type,
-        resolvedAssembly: binding.assembly,
-        csharpName: binding.csharpName, // Optional C# name from binding
-      };
-    }
-    return { kind: "identifier", name: node.text, inferredType };
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    return convertArrayLiteral(node, checker);
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    return convertObjectLiteral(node, checker);
-  }
-  if (
-    ts.isPropertyAccessExpression(node) ||
-    ts.isElementAccessExpression(node)
-  ) {
-    return convertMemberExpression(node, checker);
-  }
-  if (ts.isCallExpression(node)) {
-    return convertCallExpression(node, checker);
-  }
-  if (ts.isNewExpression(node)) {
-    return convertNewExpression(node, checker);
-  }
-  if (ts.isBinaryExpression(node)) {
-    return convertBinaryExpression(node, checker);
-  }
-  if (ts.isPrefixUnaryExpression(node)) {
-    return convertUnaryExpression(node, checker);
-  }
-  if (ts.isPostfixUnaryExpression(node)) {
-    return convertUpdateExpression(node, checker);
-  }
-  if (ts.isTypeOfExpression(node)) {
-    return {
-      kind: "unary",
-      operator: "typeof",
-      expression: convertExpression(node.expression, checker),
-      inferredType,
-    };
-  }
-  if (ts.isVoidExpression(node)) {
-    return {
-      kind: "unary",
-      operator: "void",
-      expression: convertExpression(node.expression, checker),
-      inferredType,
-    };
-  }
-  if (ts.isDeleteExpression(node)) {
-    return {
-      kind: "unary",
-      operator: "delete",
-      expression: convertExpression(node.expression, checker),
-      inferredType,
-    };
-  }
-  if (ts.isConditionalExpression(node)) {
-    return convertConditionalExpression(node, checker);
-  }
-  if (ts.isFunctionExpression(node)) {
-    return convertFunctionExpression(node, checker);
-  }
-  if (ts.isArrowFunction(node)) {
-    return convertArrowFunction(node, checker);
-  }
-  if (
-    ts.isTemplateExpression(node) ||
-    ts.isNoSubstitutionTemplateLiteral(node)
-  ) {
-    return convertTemplateLiteral(node, checker);
-  }
-  if (ts.isSpreadElement(node)) {
-    return {
-      kind: "spread",
-      expression: convertExpression(node.expression, checker),
-      inferredType,
-    };
-  }
-  if (node.kind === ts.SyntaxKind.ThisKeyword) {
-    return { kind: "this", inferredType };
-  }
-  if (ts.isAwaitExpression(node)) {
-    return {
-      kind: "await",
-      expression: convertExpression(node.expression, checker),
-      inferredType,
-    };
-  }
-  if (ts.isYieldExpression(node)) {
-    return {
-      kind: "yield",
-      expression: node.expression
-        ? convertExpression(node.expression, checker)
-        : undefined,
-      delegate: !!node.asteriskToken,
-      inferredType,
-    };
-  }
-  if (ts.isParenthesizedExpression(node)) {
-    return convertExpression(node.expression, checker);
-  }
-  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-    // Convert the inner expression
-    const innerExpr = convertExpression(
-      ts.isAsExpression(node) ? node.expression : node.expression,
-      checker
-    );
-    // Preserve the asserted type - this is needed for casts like `x as int`
-    const assertedTypeNode = ts.isAsExpression(node) ? node.type : node.type;
-    const assertedType = convertType(assertedTypeNode, checker);
-    return { ...innerExpr, inferredType: assertedType };
-  }
-
-  // Fallback - treat as identifier
-  return { kind: "identifier", name: node.getText(), inferredType };
-};
-
-// Re-export commonly used functions for backward compatibility
-export {
-  getInferredType,
-  extractTypeArguments,
-  checkIfRequiresSpecialization,
-} from "./converters/expressions/helpers.js";

package/src/ir/generic-validator.ts

@@ -1,100 +0,0 @@
-/**
- * Generic validation - detect truly unsupported generic patterns
- *
- * NOTE: Many previously-blocked constructs are now handled via:
- * - Monomorphisation for finite specializations
- * - CRTP pattern for `this` typing
- * - Tuple specialisations for variadic parameters
- * - Structural adapters for mapped/conditional types
- *
- * Only constructs with NO static mapping remain as errors.
- */
-
-import * as ts from "typescript";
-import {
-  Diagnostic,
-  createDiagnostic,
-  SourceLocation,
-} from "../types/diagnostic.js";
-
-/**
- * Get source location from TypeScript node
- */
-const getLocation = (
-  node: ts.Node,
-  sourceFile: ts.SourceFile
-): SourceLocation => {
-  const { line, character } = sourceFile.getLineAndCharacterOfPosition(
-    node.getStart()
-  );
-  return {
-    file: sourceFile.fileName,
-    line: line + 1,
-    column: character + 1,
-    length: node.getWidth(),
-  };
-};
-
-/**
- * Check for symbol index signatures (TSN7203)
- *
- * Symbol keys have no static C# mapping and must be rejected.
- */
-export const checkForSymbolIndexSignature = (
-  node: ts.IndexSignatureDeclaration,
-  sourceFile: ts.SourceFile
-): Diagnostic | null => {
-  // Check if the parameter type is symbol
-  if (node.parameters.length > 0) {
-    const param = node.parameters[0];
-    if (param && param.type) {
-      // Check for symbol keyword type
-      if (param.type.kind === ts.SyntaxKind.SymbolKeyword) {
-        return createDiagnostic(
-          "TSN7203",
-          "error",
-          "Symbol keys are not supported in C#",
-          getLocation(node, sourceFile),
-          "Use string keys instead of symbol keys"
-        );
-      }
-
-      // Also check for type reference to 'symbol'
-      if (ts.isTypeReferenceNode(param.type)) {
-        if (
-          ts.isIdentifier(param.type.typeName) &&
-          param.type.typeName.text === "symbol"
-        ) {
-          return createDiagnostic(
-            "TSN7203",
-            "error",
-            "Symbol keys are not supported in C#",
-            getLocation(node, sourceFile),
-            "Use string keys instead of symbol keys"
-          );
-        }
-      }
-    }
-  }
-
-  return null;
-};
-
-/**
- * REMOVED CHECKS (now handled by implementation):
- *
- * - checkForInferKeyword (TSN7102)
- *   Conditional types with infer are handled via monomorphisation
- *
- * - checkForRecursiveMappedType (TSN7101)
- *   Finite mapped types are specialized; unbounded cases get adapters
- *
- * - checkForThisType (TSN7103)
- *   `this` typing is handled via CRTP pattern
- *
- * - checkForVariadicTypeParameter (TSN7104)
- *   Variadic parameters are handled via tuple specialisations
- *
- * - checkForRecursiveStructuralAlias (TSN7201)
- *   Recursive structural aliases emit as C# classes with nullable refs
- */

package/src/ir/hierarchical-bindings-e2e.test.ts

@@ -1,163 +0,0 @@
-/**
- * End-to-end test for hierarchical bindings
- * Verifies the full pipeline: TypeScript -> IR -> C# with hierarchical bindings
- */
-
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import * as ts from "typescript";
-import { buildIrModule } from "./builder.js";
-import { DotnetMetadataRegistry } from "../dotnet-metadata.js";
-import { BindingRegistry } from "../program/bindings.js";
-import { createDotNetImportResolver } from "../resolver/dotnet-import-resolver.js";
-
-describe("Hierarchical Bindings End-to-End", () => {
-  it("should resolve hierarchical bindings in IR for member access chain", () => {
-    // TypeScript source with systemLinq.enumerable.selectMany
-    const source = `
-      export function processData() {
-        const arr = [1, 2, 3];
-        // systemLinq.enumerable.selectMany should resolve to System.Linq.Enumerable.SelectMany
-        const result = systemLinq.enumerable.selectMany(arr, x => [x, x * 2]);
-        return result;
-      }
-    `;
-
-    // Create hierarchical binding manifest
-    const bindings = new BindingRegistry();
-    bindings.addBindings("/test/system-linq.json", {
-      assembly: "System.Linq",
-      namespaces: [
-        {
-          name: "System.Linq",
-          alias: "systemLinq",
-          types: [
-            {
-              name: "Enumerable",
-              alias: "enumerable",
-              kind: "class",
-              members: [
-                {
-                  kind: "method",
-                  name: "SelectMany",
-                  alias: "selectMany",
-                  binding: {
-                    assembly: "System.Linq",
-                    type: "System.Linq.Enumerable",
-                    member: "SelectMany",
-                  },
-                },
-              ],
-            },
-          ],
-        },
-      ],
-    });
-
-    // Create TypeScript program
-    const fileName = "/test/sample.ts";
-    const sourceFile = ts.createSourceFile(
-      fileName,
-      source,
-      ts.ScriptTarget.ES2022,
-      true,
-      ts.ScriptKind.TS
-    );
-
-    const program = ts.createProgram(
-      [fileName],
-      {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.ES2022,
-      },
-      {
-        getSourceFile: (name) => (name === fileName ? sourceFile : undefined),
-        writeFile: () => {},
-        getCurrentDirectory: () => "/test",
-        getDirectories: () => [],
-        fileExists: () => true,
-        readFile: () => source,
-        getCanonicalFileName: (f) => f,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n",
-        getDefaultLibFileName: (_options) => "lib.d.ts",
-      }
-    );
-
-    const testProgram = {
-      program,
-      checker: program.getTypeChecker(),
-      options: { sourceRoot: "/test", rootNamespace: "TestApp", strict: true },
-      sourceFiles: [sourceFile],
-      metadata: new DotnetMetadataRegistry(),
-      bindings,
-      dotnetResolver: createDotNetImportResolver("/test"),
-    };
-
-    // Build IR
-    const irResult = buildIrModule(sourceFile, testProgram, {
-      sourceRoot: "/test",
-      rootNamespace: "TestApp",
-    });
-
-    // MUST succeed - this is a strict test
-    if (!irResult.ok) {
-      console.error("IR build failed:", irResult.error);
-      throw new Error(
-        `IR build MUST succeed for e2e test, got error: ${JSON.stringify(irResult.error)}`
-      );
-    }
-
-    const irModule = irResult.value;
-
-    // Navigate to the selectMany call in IR
-    const funcDecl = irModule.body[0];
-    expect(funcDecl?.kind).to.equal(
-      "functionDeclaration",
-      "First body item should be function declaration"
-    );
-    if (funcDecl?.kind !== "functionDeclaration") return;
-
-    // First statement: const arr = [1, 2, 3];
-    // Second statement: const result = systemLinq.enumerable.selectMany(...)
-    const resultDecl = funcDecl.body.statements[1];
-    expect(resultDecl?.kind).to.equal(
-      "variableDeclaration",
-      "Second statement should be variable declaration for result"
-    );
-    if (resultDecl?.kind !== "variableDeclaration") return;
-
-    const declarator = resultDecl.declarations[0];
-    if (!declarator?.initializer) {
-      throw new Error("Expected initializer for result variable");
-    }
-
-    // The initializer is the systemLinq.enumerable.selectMany(...) call
-    const callExpr = declarator.initializer;
-    expect(callExpr.kind).to.equal(
-      "call",
-      "Initializer should be call expression"
-    );
-    if (callExpr.kind !== "call") return;
-
-    // The callee is systemLinq.enumerable.selectMany (member access)
-    const memberExpr = callExpr.callee;
-    expect(memberExpr.kind).to.equal(
-      "memberAccess",
-      "Callee should be member access"
-    );
-    if (memberExpr.kind !== "memberAccess") return;
-
-    // CRITICAL: Verify memberBinding was resolved by the hierarchical binding system
-    expect(
-      memberExpr.memberBinding,
-      "Member binding MUST be resolved for systemLinq.enumerable.selectMany"
-    ).to.not.equal(undefined);
-
-    expect(memberExpr.memberBinding?.assembly).to.equal("System.Linq");
-    expect(memberExpr.memberBinding?.type).to.equal("System.Linq.Enumerable");
-    expect(memberExpr.memberBinding?.member).to.equal("SelectMany");
-
-    console.log("✅ End-to-end test passed: Hierarchical bindings work!");
-  });
-});