@tsonic/frontend 0.0.1

package/src/ir/builder.test.ts

@@ -0,0 +1,581 @@
+/**
+ * Tests for IR Builder
+ */
+
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import * as ts from "typescript";
+import { buildIrModule } from "./builder.js";
+import {
+  IrFunctionDeclaration,
+  IrVariableDeclaration,
+  IrClassDeclaration,
+} from "./types.js";
+import { DotnetMetadataRegistry } from "../dotnet-metadata.js";
+import { BindingRegistry } from "../program/bindings.js";
+import { createDotNetImportResolver } from "../resolver/dotnet-import-resolver.js";
+
+describe("IR Builder", () => {
+  const createTestProgram = (source: string, fileName = "/test/test.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",
+      }
+    );
+
+    return {
+      program,
+      checker: program.getTypeChecker(),
+      options: { sourceRoot: "/test", rootNamespace: "TestApp", strict: true },
+      sourceFiles: [sourceFile],
+      metadata: new DotnetMetadataRegistry(),
+      bindings: new BindingRegistry(),
+      dotnetResolver: createDotNetImportResolver("/test"),
+    };
+  };
+
+  describe("Module Structure", () => {
+    it("should create IR module with correct namespace and class name", () => {
+      const source = `
+        export function greet(name: string): string {
+          return \`Hello \${name}\`;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const module = result.value;
+        expect(module.kind).to.equal("module");
+        expect(module.namespace).to.equal("TestApp");
+        expect(module.className).to.equal("test");
+        expect(module.isStaticContainer).to.equal(true);
+      }
+    });
+
+    it("should detect top-level code", () => {
+      const source = `
+        console.log("Hello");
+        export const x = 42;
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        expect(result.value.isStaticContainer).to.equal(false);
+      }
+    });
+  });
+
+  describe("Import Extraction", () => {
+    it("should extract local imports", () => {
+      const source = `
+        import { User } from "./models/User.ts";
+        import * as utils from "./utils.ts";
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const imports = result.value.imports;
+        expect(imports).to.have.length(2);
+
+        const firstImport = imports[0];
+        const secondImport = imports[1];
+        if (!firstImport || !secondImport) throw new Error("Missing imports");
+
+        expect(firstImport.source).to.equal("./models/User.ts");
+        expect(firstImport.isLocal).to.equal(true);
+        expect(firstImport.isDotNet).to.equal(false);
+
+        expect(secondImport.source).to.equal("./utils.ts");
+        const firstSpec = secondImport.specifiers[0];
+        if (!firstSpec) throw new Error("Missing specifier");
+        expect(firstSpec.kind).to.equal("namespace");
+      }
+    });
+
+    it("should not detect bare imports as .NET without package bindings", () => {
+      // Import-driven resolution: bare imports like "System.IO" are only detected as .NET
+      // if they come from a package with bindings.json. Without an actual package,
+      // the import is not recognized as .NET.
+      const source = `
+        import { File } from "System.IO";
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const imports = result.value.imports;
+        const firstImport = imports[0];
+        if (!firstImport) throw new Error("Missing import");
+        // Without an actual package with bindings.json, this is NOT detected as .NET
+        expect(firstImport.isDotNet).to.equal(false);
+        expect(firstImport.resolvedNamespace).to.equal(undefined);
+      }
+    });
+  });
+
+  describe("Statement Conversion", () => {
+    it("should convert function declarations", () => {
+      const source = `
+        export function add(a: number, b: number): number {
+          return a + b;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        expect(body).to.have.length(1);
+
+        const firstItem = body[0];
+        if (!firstItem) throw new Error("Missing body item");
+        expect(firstItem.kind).to.equal("functionDeclaration");
+
+        const func = firstItem as IrFunctionDeclaration;
+        expect(func.name).to.equal("add");
+        expect(func.parameters).to.have.length(2);
+        expect(func.isExported).to.equal(true);
+      }
+    });
+
+    it("should convert variable declarations", () => {
+      const source = `
+        const x = 10;
+        let y: string = "hello";
+        export const z = { name: "test" };
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        expect(body).to.have.length(3);
+
+        const firstVar = body[0] as IrVariableDeclaration;
+        expect(firstVar.kind).to.equal("variableDeclaration");
+        expect(firstVar.declarationKind).to.equal("const");
+
+        const secondVar = body[1] as IrVariableDeclaration;
+        expect(secondVar.declarationKind).to.equal("let");
+
+        const thirdVar = body[2] as IrVariableDeclaration;
+        expect(thirdVar.isExported).to.equal(true);
+      }
+    });
+
+    it("should convert class declarations", () => {
+      const source = `
+        export class User {
+          private name: string;
+          constructor(name: string) {
+            this.name = name;
+          }
+          getName(): string {
+            return this.name;
+          }
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        expect(body).to.have.length(1);
+
+        const cls = body[0] as IrClassDeclaration;
+        expect(cls.kind).to.equal("classDeclaration");
+        expect(cls.name).to.equal("User");
+        expect(cls.isExported).to.equal(true);
+        expect(cls.members).to.have.length.greaterThan(0);
+      }
+    });
+  });
+
+  describe("Expression Conversion", () => {
+    it("should convert template literals", () => {
+      const source = `
+        const greeting = \`Hello \${name}\`;
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const varDecl = result.value.body[0] as IrVariableDeclaration;
+        const init = varDecl.declarations[0]?.initializer;
+        if (init && init.kind === "templateLiteral") {
+          expect(init.kind).to.equal("templateLiteral");
+          expect(init.quasis).to.have.length(2);
+          expect(init.expressions).to.have.length(1);
+        }
+      }
+    });
+
+    it("should convert arrow functions", () => {
+      const source = `
+        const double = (x: number) => x * 2;
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const varDecl = result.value.body[0] as IrVariableDeclaration;
+        const init = varDecl.declarations[0]?.initializer;
+        if (init && init.kind === "arrowFunction") {
+          expect(init.kind).to.equal("arrowFunction");
+          expect(init.parameters).to.have.length(1);
+        }
+      }
+    });
+  });
+
+  describe("Export Handling", () => {
+    it("should handle named exports", () => {
+      const source = `
+        const a = 1;
+        const b = 2;
+        export { a, b as c };
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const exports = result.value.exports;
+        expect(exports).to.have.length(2);
+
+        const firstExport = exports[0];
+        if (!firstExport) throw new Error("Missing export");
+        expect(firstExport.kind).to.equal("named");
+        if (firstExport.kind === "named") {
+          expect(firstExport.name).to.equal("a");
+          expect(firstExport.localName).to.equal("a");
+        }
+
+        const second = exports[1];
+        if (second && second.kind === "named") {
+          expect(second.name).to.equal("c");
+          expect(second.localName).to.equal("b");
+        }
+      }
+    });
+
+    it("should handle default export", () => {
+      const source = `
+        export default function main() {
+          console.log("Hello");
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const exports = result.value.exports;
+        expect(exports.some((e) => e.kind === "default")).to.equal(true);
+      }
+    });
+  });
+
+  describe("Struct Detection", () => {
+    it("should detect struct marker in interface", () => {
+      const source = `
+        interface struct {
+          readonly __brand: "struct";
+        }
+
+        export interface Point extends struct {
+          x: number;
+          y: number;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        const pointInterface = body.find(
+          (stmt) =>
+            stmt.kind === "interfaceDeclaration" && stmt.name === "Point"
+        );
+        expect(pointInterface).not.to.equal(undefined);
+        if (pointInterface && pointInterface.kind === "interfaceDeclaration") {
+          expect(pointInterface.isStruct).to.equal(true);
+          // Verify __brand property is filtered out
+          expect(
+            pointInterface.members.some(
+              (m) => m.kind === "propertySignature" && m.name === "__brand"
+            )
+          ).to.equal(false);
+        }
+      }
+    });
+
+    it("should detect struct marker in class", () => {
+      const source = `
+        interface struct {
+          readonly __brand: "struct";
+        }
+
+        export class Vector3D implements struct {
+          x: number;
+          y: number;
+          z: number;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        const vectorClass = body.find(
+          (stmt) => stmt.kind === "classDeclaration" && stmt.name === "Vector3D"
+        );
+        expect(vectorClass).not.to.equal(undefined);
+        if (vectorClass && vectorClass.kind === "classDeclaration") {
+          expect(vectorClass.isStruct).to.equal(true);
+          // Verify __brand property is filtered out
+          expect(
+            vectorClass.members.some(
+              (m) => m.kind === "propertyDeclaration" && m.name === "__brand"
+            )
+          ).to.equal(false);
+        }
+      }
+    });
+
+    it("should not mark regular class as struct", () => {
+      const source = `
+        export class RegularClass {
+          value: number;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+      if (result.ok) {
+        const body = result.value.body;
+        const regularClass = body[0];
+        expect(regularClass).not.to.equal(undefined);
+        if (regularClass && regularClass.kind === "classDeclaration") {
+          expect(regularClass.isStruct).to.equal(false);
+        }
+      }
+    });
+  });
+
+  describe("Interface Implements Validation (TSN7301)", () => {
+    it("should report error when class implements a nominalized interface", () => {
+      const source = `
+        interface Printable {
+          print(): void;
+        }
+
+        export class Document implements Printable {
+          print(): void {}
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(false);
+      if (!result.ok) {
+        expect(result.error.code).to.equal("TSN7301");
+        expect(result.error.message).to.include("Printable");
+        expect(result.error.message).to.include("nominalized");
+      }
+    });
+
+    it("should allow struct marker in implements clause", () => {
+      const source = `
+        interface struct {
+          readonly __brand: "struct";
+        }
+
+        export class Point implements struct {
+          x: number;
+          y: number;
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(true);
+    });
+
+    it("should report error when class implements a type alias", () => {
+      const source = `
+        type Serializable = {
+          serialize(): string;
+        };
+
+        export class Config implements Serializable {
+          serialize(): string { return "{}"; }
+        }
+      `;
+
+      const testProgram = createTestProgram(source);
+      const sourceFile = testProgram.sourceFiles[0];
+      if (!sourceFile) throw new Error("Failed to create source file");
+
+      const result = buildIrModule(sourceFile, testProgram, {
+        sourceRoot: "/test",
+        rootNamespace: "TestApp",
+      });
+
+      expect(result.ok).to.equal(false);
+      if (!result.ok) {
+        expect(result.error.code).to.equal("TSN7301");
+        expect(result.error.message).to.include("Serializable");
+      }
+    });
+  });
+});

package/src/ir/builder.ts

@@ -0,0 +1,14 @@
+/**
+ * IR Builder - Main module for converting TypeScript AST to IR
+ * Main dispatcher - re-exports from builder/ subdirectory
+ */
+
+export type { IrBuildOptions } from "./builder/types.js";
+export { buildIrModule, buildIr } from "./builder/orchestrator.js";
+export { extractImports, extractImportSpecifiers } from "./builder/imports.js";
+export { extractExports } from "./builder/exports.js";
+export {
+  extractStatements,
+  isExecutableStatement,
+} from "./builder/statements.js";
+export { hasExportModifier, hasDefaultModifier } from "./builder/helpers.js";

package/src/ir/converters/expressions/access.ts

@@ -0,0 +1,99 @@
+/**
+ * Member access expression converters
+ */
+
+import * as ts from "typescript";
+import { IrMemberExpression } from "../../types.js";
+import { getInferredType } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+import { getBindingRegistry } from "../statements/declarations/registry.js";
+
+/**
+ * Resolve hierarchical binding for a member access
+ * Handles namespace.type and type.member patterns
+ */
+const resolveHierarchicalBinding = (
+  object: ReturnType<typeof convertExpression>,
+  propertyName: string
+): IrMemberExpression["memberBinding"] => {
+  const registry = getBindingRegistry();
+
+  // Case 1: object is identifier → check if it's a namespace, then check if property is a type
+  if (object.kind === "identifier") {
+    const namespace = registry.getNamespace(object.name);
+    if (namespace) {
+      // Found namespace binding, check if property is a type within this namespace
+      // Note: After schema swap, we look up by alias (TS identifier)
+      const type = namespace.types.find((t) => t.alias === propertyName);
+      if (type) {
+        // This member access is namespace.type - we don't emit a member binding here
+        // because we're just accessing a type, not calling a member
+        return undefined;
+      }
+    }
+  }
+
+  // Case 2: object is member expression with a type reference → check if property is a member
+  if (object.kind === "memberAccess" && !object.isComputed) {
+    // Walk up the chain to find if this is a type reference
+    // For systemLinq.enumerable, the object is "systemLinq" and property is "enumerable"
+    if (object.object.kind === "identifier") {
+      const namespace = registry.getNamespace(object.object.name);
+      if (namespace && typeof object.property === "string") {
+        const type = namespace.types.find((t) => t.alias === object.property);
+        if (type) {
+          // The object is a type reference (namespace.type), now check if property is a member
+          const member = type.members.find((m) => m.alias === propertyName);
+          if (member) {
+            // Found a member binding!
+            return {
+              assembly: member.binding.assembly,
+              type: member.binding.type,
+              member: member.binding.member,
+            };
+          }
+        }
+      }
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Convert property access or element access expression
+ */
+export const convertMemberExpression = (
+  node: ts.PropertyAccessExpression | ts.ElementAccessExpression,
+  checker: ts.TypeChecker
+): IrMemberExpression => {
+  const isOptional = node.questionDotToken !== undefined;
+  const inferredType = getInferredType(node, checker);
+
+  if (ts.isPropertyAccessExpression(node)) {
+    const object = convertExpression(node.expression, checker);
+    const propertyName = node.name.text;
+
+    // Try to resolve hierarchical binding
+    const memberBinding = resolveHierarchicalBinding(object, propertyName);
+
+    return {
+      kind: "memberAccess",
+      object,
+      property: propertyName,
+      isComputed: false,
+      isOptional,
+      inferredType,
+      memberBinding,
+    };
+  } else {
+    return {
+      kind: "memberAccess",
+      object: convertExpression(node.expression, checker),
+      property: convertExpression(node.argumentExpression, checker),
+      isComputed: true,
+      isOptional,
+      inferredType,
+    };
+  }
+};