@tsonic/frontend 0.0.1 → 0.0.4

package/src/ir/builder.test.ts

@@ -1,581 +0,0 @@
-/**
- * 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/converters/expressions/access.ts

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