@tsonic/frontend 0.0.1

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

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

package/src/ir/index.ts

@@ -0,0 +1,6 @@
+/**
+ * IR module exports
+ */
+
+export * from "./types.js";
+export { buildIr, buildIrModule, type IrBuildOptions } from "./builder.js";

package/src/ir/statement-converter.ts

@@ -0,0 +1,128 @@
+/**
+ * Statement converter - TypeScript AST to IR statements
+ * Main dispatcher - delegates to specialized modules
+ */
+
+import * as ts from "typescript";
+import { IrStatement } from "./types.js";
+import { convertExpression } from "./expression-converter.js";
+
+// Import converters from specialized modules
+import {
+  convertVariableStatement,
+  convertFunctionDeclaration,
+  convertClassDeclaration,
+  convertInterfaceDeclaration,
+  convertEnumDeclaration,
+  convertTypeAliasDeclaration,
+} from "./converters/statements/declarations.js";
+
+import {
+  convertIfStatement,
+  convertWhileStatement,
+  convertForStatement,
+  convertForOfStatement,
+  convertForInStatement,
+  convertSwitchStatement,
+  convertTryStatement,
+  convertBlockStatement,
+} from "./converters/statements/control.js";
+
+/**
+ * Main statement converter dispatcher
+ */
+export const convertStatement = (
+  node: ts.Node,
+  checker: ts.TypeChecker
+): IrStatement | null => {
+  if (ts.isVariableStatement(node)) {
+    return convertVariableStatement(node, checker);
+  }
+  if (ts.isFunctionDeclaration(node)) {
+    return convertFunctionDeclaration(node, checker);
+  }
+  if (ts.isClassDeclaration(node)) {
+    return convertClassDeclaration(node, checker);
+  }
+  if (ts.isInterfaceDeclaration(node)) {
+    return convertInterfaceDeclaration(node, checker);
+  }
+  if (ts.isEnumDeclaration(node)) {
+    return convertEnumDeclaration(node, checker);
+  }
+  if (ts.isTypeAliasDeclaration(node)) {
+    return convertTypeAliasDeclaration(node, checker);
+  }
+  if (ts.isExpressionStatement(node)) {
+    return {
+      kind: "expressionStatement",
+      expression: convertExpression(node.expression, checker),
+    };
+  }
+  if (ts.isReturnStatement(node)) {
+    return {
+      kind: "returnStatement",
+      expression: node.expression
+        ? convertExpression(node.expression, checker)
+        : undefined,
+    };
+  }
+  if (ts.isIfStatement(node)) {
+    return convertIfStatement(node, checker);
+  }
+  if (ts.isWhileStatement(node)) {
+    return convertWhileStatement(node, checker);
+  }
+  if (ts.isForStatement(node)) {
+    return convertForStatement(node, checker);
+  }
+  if (ts.isForOfStatement(node)) {
+    return convertForOfStatement(node, checker);
+  }
+  if (ts.isForInStatement(node)) {
+    return convertForInStatement(node, checker);
+  }
+  if (ts.isSwitchStatement(node)) {
+    return convertSwitchStatement(node, checker);
+  }
+  if (ts.isThrowStatement(node)) {
+    if (!node.expression) {
+      return null;
+    }
+    return {
+      kind: "throwStatement",
+      expression: convertExpression(node.expression, checker),
+    };
+  }
+  if (ts.isTryStatement(node)) {
+    return convertTryStatement(node, checker);
+  }
+  if (ts.isBlock(node)) {
+    return convertBlockStatement(node, checker);
+  }
+  if (ts.isBreakStatement(node)) {
+    return {
+      kind: "breakStatement",
+      label: node.label?.text,
+    };
+  }
+  if (ts.isContinueStatement(node)) {
+    return {
+      kind: "continueStatement",
+      label: node.label?.text,
+    };
+  }
+  if (ts.isEmptyStatement(node)) {
+    return { kind: "emptyStatement" };
+  }
+
+  return null;
+};
+
+// Re-export commonly used functions for backward compatibility
+export { convertBlockStatement } from "./converters/statements/control.js";
+export { convertParameters } from "./converters/statements/helpers.js";
+export {
+  setMetadataRegistry,
+  setBindingRegistry,
+} from "./converters/statements/declarations.js";

package/src/ir/type-converter/arrays.ts

@@ -0,0 +1,20 @@
+/**
+ * Array type conversion
+ */
+
+import * as ts from "typescript";
+import { IrType } from "../types.js";
+
+/**
+ * Convert TypeScript array type to IR array type
+ */
+export const convertArrayType = (
+  node: ts.ArrayTypeNode,
+  checker: ts.TypeChecker,
+  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
+): IrType => {
+  return {
+    kind: "arrayType",
+    elementType: convertType(node.elementType, checker),
+  };
+};

package/src/ir/type-converter/converter.ts

@@ -0,0 +1,10 @@
+/**
+ * Type converter - TypeScript types to IR types
+ * Main dispatcher - re-exports from orchestrator
+ */
+
+export {
+  convertType,
+  convertFunctionType,
+  convertObjectType,
+} from "./orchestrator.js";

package/src/ir/type-converter/functions.ts

@@ -0,0 +1,22 @@
+/**
+ * Function type conversion
+ */
+
+import * as ts from "typescript";
+import { IrType, IrFunctionType } from "../types.js";
+import { convertParameters as convertParametersFromStatement } from "../statement-converter.js";
+
+/**
+ * Convert TypeScript function type to IR function type
+ */
+export const convertFunctionType = (
+  node: ts.FunctionTypeNode,
+  checker: ts.TypeChecker,
+  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
+): IrFunctionType => {
+  return {
+    kind: "functionType",
+    parameters: convertParametersFromStatement(node.parameters, checker),
+    returnType: convertType(node.type, checker),
+  };
+};

package/src/ir/type-converter/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Type converter - Public API
+ */
+
+export {
+  convertType,
+  convertFunctionType,
+  convertObjectType,
+} from "./converter.js";
+export { convertBindingName } from "./patterns.js";
+export { inferType, convertTsTypeToIr } from "./inference.js";

package/src/ir/type-converter/inference.ts

@@ -0,0 +1,122 @@
+/**
+ * Type inference - Converts TypeScript inferred types to IR types
+ *
+ * This uses the TypeChecker to get the inferred type and converts it to IR.
+ * Used for declarations without explicit type annotations where the type
+ * must be inferred from the initializer.
+ */
+
+import * as ts from "typescript";
+import type { IrType } from "../types.js";
+
+/**
+ * Infer IR type from a declaration node using the TypeChecker.
+ * Returns undefined for complex types that cannot be easily represented.
+ */
+export const inferType = (
+  node: ts.VariableDeclaration | ts.PropertyDeclaration,
+  checker: ts.TypeChecker
+): IrType | undefined => {
+  const type = checker.getTypeAtLocation(node);
+  return convertTsTypeToIr(type, checker);
+};
+
+/**
+ * Convert a TypeScript Type (from checker) to IR type.
+ * This is different from convertType which takes a TypeNode (syntax).
+ */
+export const convertTsTypeToIr = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): IrType | undefined => {
+  const flags = type.flags;
+
+  // Primitives
+  if (flags & ts.TypeFlags.Number || flags & ts.TypeFlags.NumberLiteral) {
+    return { kind: "primitiveType", name: "number" };
+  }
+  if (flags & ts.TypeFlags.String || flags & ts.TypeFlags.StringLiteral) {
+    return { kind: "primitiveType", name: "string" };
+  }
+  if (flags & ts.TypeFlags.Boolean || flags & ts.TypeFlags.BooleanLiteral) {
+    return { kind: "primitiveType", name: "boolean" };
+  }
+  if (flags & ts.TypeFlags.Void) {
+    return { kind: "voidType" };
+  }
+  if (flags & ts.TypeFlags.Null) {
+    return { kind: "primitiveType", name: "null" };
+  }
+  if (flags & ts.TypeFlags.Undefined) {
+    return { kind: "primitiveType", name: "undefined" };
+  }
+
+  // Object type - check if it's an array
+  if (flags & ts.TypeFlags.Object) {
+    // Check for array type
+    if (checker.isArrayType(type)) {
+      const typeArgs = checker.getTypeArguments(type as ts.TypeReference);
+      if (typeArgs.length > 0) {
+        const elementType = convertTsTypeToIr(typeArgs[0]!, checker);
+        if (elementType) {
+          return { kind: "arrayType", elementType };
+        }
+      }
+      return { kind: "arrayType", elementType: { kind: "anyType" } };
+    }
+
+    // Check for callable signatures (function types)
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0) {
+      // Function types need complex handling - return undefined for now
+      return undefined;
+    }
+
+    // Check for symbol with name (class, interface, etc.)
+    const objectType = type as ts.ObjectType;
+    if (objectType.symbol) {
+      const name = objectType.symbol.name;
+      // Skip internal TypeScript symbol names
+      if (name.startsWith("__")) {
+        return undefined;
+      }
+      // For named types, return as reference type with type arguments if generic
+      if (name && name !== "Object" && name !== "Array") {
+        // Extract type arguments for generic types
+        const typeRef = type as ts.TypeReference;
+        const typeArgs = checker.getTypeArguments(typeRef);
+        if (typeArgs && typeArgs.length > 0) {
+          const irTypeArgs = typeArgs
+            .map((arg) => convertTsTypeToIr(arg, checker))
+            .filter((t): t is IrType => t !== undefined);
+          if (irTypeArgs.length === typeArgs.length) {
+            return { kind: "referenceType", name, typeArguments: irTypeArgs };
+          }
+        }
+        return { kind: "referenceType", name };
+      }
+    }
+
+    // Anonymous object type
+    return undefined;
+  }
+
+  // Type parameters (e.g., T in Container<T>)
+  if (flags & ts.TypeFlags.TypeParameter) {
+    const typeParam = type as ts.TypeParameter;
+    const name = typeParam.symbol?.name ?? "T";
+    return { kind: "referenceType", name };
+  }
+
+  // Any and unknown
+  if (flags & ts.TypeFlags.Any || flags & ts.TypeFlags.Unknown) {
+    return { kind: "anyType" };
+  }
+
+  // Union and intersection types - too complex for simple inference
+  if (flags & ts.TypeFlags.Union || flags & ts.TypeFlags.Intersection) {
+    return undefined;
+  }
+
+  return undefined;
+};

package/src/ir/type-converter/literals.ts

@@ -0,0 +1,40 @@
+/**
+ * Literal type conversion
+ */
+
+import * as ts from "typescript";
+import { IrType } from "../types.js";
+
+/**
+ * Convert TypeScript literal type to IR literal type
+ */
+export const convertLiteralType = (node: ts.LiteralTypeNode): IrType => {
+  const literal = node.literal;
+
+  if (ts.isStringLiteral(literal)) {
+    return { kind: "literalType", value: literal.text };
+  }
+
+  if (ts.isNumericLiteral(literal)) {
+    return { kind: "literalType", value: Number(literal.text) };
+  }
+
+  if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+    return { kind: "literalType", value: true };
+  }
+
+  if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+    return { kind: "literalType", value: false };
+  }
+
+  if (literal.kind === ts.SyntaxKind.NullKeyword) {
+    return { kind: "primitiveType", name: "null" };
+  }
+
+  if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {
+    return { kind: "primitiveType", name: "undefined" };
+  }
+
+  // Fallback
+  return { kind: "anyType" };
+};

package/src/ir/type-converter/objects.ts

@@ -0,0 +1,107 @@
+/**
+ * Object/interface type conversion
+ */
+
+import * as ts from "typescript";
+import {
+  IrType,
+  IrObjectType,
+  IrDictionaryType,
+  IrInterfaceMember,
+  IrPropertySignature,
+  IrMethodSignature,
+} from "../types.js";
+import { convertParameters as convertParametersFromStatement } from "../statement-converter.js";
+
+/**
+ * Convert TypeScript object literal type to IR type.
+ *
+ * Returns IrDictionaryType for pure index signature types like:
+ * - `{ [k: string]: T }`
+ * - `{ [k: number]: T }`
+ *
+ * Returns IrObjectType for regular object types with named members.
+ */
+export const convertObjectType = (
+  node: ts.TypeLiteralNode,
+  checker: ts.TypeChecker,
+  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
+): IrObjectType | IrDictionaryType => {
+  // Check for pure index signature type (no other members)
+  const indexSignatures = node.members.filter(ts.isIndexSignatureDeclaration);
+  const otherMembers = node.members.filter(
+    (m) => !ts.isIndexSignatureDeclaration(m)
+  );
+
+  // If ONLY index signature(s) exist, convert to dictionary type
+  if (indexSignatures.length > 0 && otherMembers.length === 0) {
+    // Use the first index signature (TypeScript allows multiple, but we take first)
+    const indexSig = indexSignatures[0]!;
+    const keyParam = indexSig.parameters[0];
+
+    // Determine key type from parameter type
+    const keyType: IrType = keyParam?.type
+      ? convertKeyType(keyParam.type)
+      : { kind: "primitiveType", name: "string" };
+
+    // Determine value type
+    const valueType: IrType = indexSig.type
+      ? convertType(indexSig.type, checker)
+      : { kind: "anyType" };
+
+    return {
+      kind: "dictionaryType",
+      keyType,
+      valueType,
+    };
+  }
+
+  // Regular object type with named members
+  const members: IrInterfaceMember[] = [];
+
+  node.members.forEach((member) => {
+    if (ts.isPropertySignature(member) && member.type) {
+      const propSig: IrPropertySignature = {
+        kind: "propertySignature",
+        name:
+          member.name && ts.isIdentifier(member.name)
+            ? member.name.text
+            : "[computed]",
+        type: convertType(member.type, checker),
+        isOptional: !!member.questionToken,
+        isReadonly: !!member.modifiers?.some(
+          (m) => m.kind === ts.SyntaxKind.ReadonlyKeyword
+        ),
+      };
+      members.push(propSig);
+    } else if (ts.isMethodSignature(member)) {
+      const methSig: IrMethodSignature = {
+        kind: "methodSignature",
+        name:
+          member.name && ts.isIdentifier(member.name)
+            ? member.name.text
+            : "[computed]",
+        parameters: convertParametersFromStatement(member.parameters, checker),
+        returnType: member.type ? convertType(member.type, checker) : undefined,
+      };
+      members.push(methSig);
+    }
+  });
+
+  return { kind: "objectType", members };
+};
+
+/**
+ * Convert index signature key type to IR type.
+ * Only string and number are valid as index signature keys.
+ */
+const convertKeyType = (typeNode: ts.TypeNode): IrType => {
+  if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
+    return { kind: "primitiveType", name: "string" };
+  }
+  if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
+    return { kind: "primitiveType", name: "number" };
+  }
+  // Fallback to string for other cases
+  return { kind: "primitiveType", name: "string" };
+};