@tsonic/frontend 0.0.1 → 0.0.2

package/src/ir/types/module.ts

@@ -1,57 +0,0 @@
-/**
- * Core IR module types (Module, Import, Export)
- */
-
-import { IrStatement } from "./statements.js";
-import { IrExpression } from "./expressions.js";
-
-export type IrModule = {
-  readonly kind: "module";
-  readonly filePath: string;
-  readonly namespace: string;
-  readonly className: string; // File name becomes class name
-  readonly isStaticContainer: boolean; // True if module only has exports, no top-level code
-  readonly imports: readonly IrImport[];
-  readonly body: readonly IrStatement[];
-  readonly exports: readonly IrExport[];
-};
-
-export type IrImport = {
-  readonly kind: "import";
-  readonly source: string; // Import path
-  readonly isLocal: boolean;
-  readonly isDotNet: boolean;
-  readonly specifiers: readonly IrImportSpecifier[];
-  readonly resolvedNamespace?: string; // For .NET imports or local imports (e.g., "MultiFileCheck.utils")
-  // For module bindings (Node.js APIs mapped to CLR types)
-  readonly resolvedClrType?: string; // e.g., "Tsonic.NodeApi.fs"
-  readonly resolvedAssembly?: string; // e.g., "Tsonic.NodeApi"
-  // For local imports: the target module's container class name
-  readonly targetContainerName?: string; // e.g., "Math" for ./utils/Math.ts
-};
-
-export type IrImportSpecifier =
-  | { readonly kind: "default"; readonly localName: string }
-  | { readonly kind: "namespace"; readonly localName: string }
-  | {
-      readonly kind: "named";
-      readonly name: string;
-      readonly localName: string;
-      /** Whether this import is a type (interface/class) - emitted at namespace level in C# */
-      readonly isType?: boolean;
-    };
-
-export type IrExport =
-  | {
-      readonly kind: "named";
-      readonly name: string;
-      readonly localName: string;
-    }
-  | { readonly kind: "default"; readonly expression: IrExpression }
-  | { readonly kind: "declaration"; readonly declaration: IrStatement }
-  | {
-      readonly kind: "reexport";
-      readonly name: string; // Exported name
-      readonly originalName: string; // Name in source module (may differ if aliased)
-      readonly fromModule: string; // Source module path (e.g., "./math.ts")
-    };

package/src/ir/types/statements.ts

@@ -1,238 +0,0 @@
-/**
- * Statement types for IR
- */
-
-import { IrType } from "./ir-types.js";
-import {
-  IrPattern,
-  IrParameter,
-  IrTypeParameter,
-  IrAccessibility,
-  IrInterfaceMember,
-} from "./helpers.js";
-import { IrExpression } from "./expressions.js";
-
-export type IrStatement =
-  | IrVariableDeclaration
-  | IrFunctionDeclaration
-  | IrClassDeclaration
-  | IrInterfaceDeclaration
-  | IrEnumDeclaration
-  | IrTypeAliasDeclaration
-  | IrExpressionStatement
-  | IrReturnStatement
-  | IrIfStatement
-  | IrWhileStatement
-  | IrForStatement
-  | IrForOfStatement
-  | IrSwitchStatement
-  | IrThrowStatement
-  | IrTryStatement
-  | IrBlockStatement
-  | IrBreakStatement
-  | IrContinueStatement
-  | IrEmptyStatement;
-
-export type IrVariableDeclaration = {
-  readonly kind: "variableDeclaration";
-  readonly declarationKind: "const" | "let" | "var";
-  readonly declarations: readonly IrVariableDeclarator[];
-  readonly isExported: boolean;
-};
-
-export type IrVariableDeclarator = {
-  readonly kind: "variableDeclarator";
-  readonly name: IrPattern;
-  /** Type from annotation or inferred. Always set for module-level exports (C# requires explicit type). */
-  readonly type?: IrType;
-  readonly initializer?: IrExpression;
-};
-
-export type IrFunctionDeclaration = {
-  readonly kind: "functionDeclaration";
-  readonly name: string;
-  readonly typeParameters?: readonly IrTypeParameter[];
-  readonly parameters: readonly IrParameter[];
-  readonly returnType?: IrType;
-  readonly body: IrBlockStatement;
-  readonly isAsync: boolean;
-  readonly isGenerator: boolean;
-  readonly isExported: boolean;
-};
-
-export type IrClassDeclaration = {
-  readonly kind: "classDeclaration";
-  readonly name: string;
-  readonly typeParameters?: readonly IrTypeParameter[];
-  readonly superClass?: IrExpression;
-  readonly implements: readonly IrType[];
-  readonly members: readonly IrClassMember[];
-  readonly isExported: boolean;
-  /** True if this class should be emitted as a C# struct instead of a class */
-  readonly isStruct: boolean;
-};
-
-export type IrClassMember =
-  | IrMethodDeclaration
-  | IrPropertyDeclaration
-  | IrConstructorDeclaration;
-
-export type IrMethodDeclaration = {
-  readonly kind: "methodDeclaration";
-  readonly name: string;
-  readonly typeParameters?: readonly IrTypeParameter[];
-  readonly parameters: readonly IrParameter[];
-  readonly returnType?: IrType;
-  readonly body?: IrBlockStatement;
-  readonly isStatic: boolean;
-  readonly isAsync: boolean;
-  readonly isGenerator: boolean;
-  readonly accessibility: IrAccessibility;
-  /** True if this method overrides a virtual base class method (from metadata or TS base class) */
-  readonly isOverride?: boolean;
-  /** True if this method shadows a non-virtual base method (future: emit 'new' keyword) */
-  readonly isShadow?: boolean;
-};
-
-export type IrPropertyDeclaration = {
-  readonly kind: "propertyDeclaration";
-  readonly name: string;
-  /** Type from annotation or inferred. Always set for class fields (C# requires explicit type). */
-  readonly type?: IrType;
-  readonly initializer?: IrExpression;
-  readonly isStatic: boolean;
-  readonly isReadonly: boolean;
-  readonly accessibility: IrAccessibility;
-  /** True if this property overrides a virtual base class property (from metadata or TS base class) */
-  readonly isOverride?: boolean;
-  /** True if this property shadows a non-virtual base property (future: emit 'new' keyword) */
-  readonly isShadow?: boolean;
-};
-
-export type IrConstructorDeclaration = {
-  readonly kind: "constructorDeclaration";
-  readonly parameters: readonly IrParameter[];
-  readonly body?: IrBlockStatement;
-  readonly accessibility: IrAccessibility;
-};
-
-export type IrInterfaceDeclaration = {
-  readonly kind: "interfaceDeclaration";
-  readonly name: string;
-  readonly typeParameters?: readonly IrTypeParameter[];
-  readonly extends: readonly IrType[];
-  readonly members: readonly IrInterfaceMember[];
-  readonly isExported: boolean;
-  /** True if this interface should be emitted as a C# struct instead of a class */
-  readonly isStruct: boolean;
-};
-
-export type IrEnumDeclaration = {
-  readonly kind: "enumDeclaration";
-  readonly name: string;
-  readonly members: readonly IrEnumMember[];
-  readonly isExported: boolean;
-};
-
-export type IrEnumMember = {
-  readonly kind: "enumMember";
-  readonly name: string;
-  readonly initializer?: IrExpression;
-};
-
-export type IrTypeAliasDeclaration = {
-  readonly kind: "typeAliasDeclaration";
-  readonly name: string;
-  readonly typeParameters?: readonly IrTypeParameter[];
-  readonly type: IrType;
-  readonly isExported: boolean;
-  /** True if this type alias should be emitted as a C# struct instead of a class */
-  readonly isStruct: boolean;
-};
-
-export type IrExpressionStatement = {
-  readonly kind: "expressionStatement";
-  readonly expression: IrExpression;
-};
-
-export type IrReturnStatement = {
-  readonly kind: "returnStatement";
-  readonly expression?: IrExpression;
-};
-
-export type IrIfStatement = {
-  readonly kind: "ifStatement";
-  readonly condition: IrExpression;
-  readonly thenStatement: IrStatement;
-  readonly elseStatement?: IrStatement;
-};
-
-export type IrWhileStatement = {
-  readonly kind: "whileStatement";
-  readonly condition: IrExpression;
-  readonly body: IrStatement;
-};
-
-export type IrForStatement = {
-  readonly kind: "forStatement";
-  readonly initializer?: IrVariableDeclaration | IrExpression;
-  readonly condition?: IrExpression;
-  readonly update?: IrExpression;
-  readonly body: IrStatement;
-};
-
-export type IrForOfStatement = {
-  readonly kind: "forOfStatement";
-  readonly variable: IrPattern;
-  readonly expression: IrExpression;
-  readonly body: IrStatement;
-};
-
-export type IrSwitchStatement = {
-  readonly kind: "switchStatement";
-  readonly expression: IrExpression;
-  readonly cases: readonly IrSwitchCase[];
-};
-
-export type IrSwitchCase = {
-  readonly kind: "switchCase";
-  readonly test?: IrExpression; // undefined for default case
-  readonly statements: readonly IrStatement[];
-};
-
-export type IrThrowStatement = {
-  readonly kind: "throwStatement";
-  readonly expression: IrExpression;
-};
-
-export type IrTryStatement = {
-  readonly kind: "tryStatement";
-  readonly tryBlock: IrBlockStatement;
-  readonly catchClause?: IrCatchClause;
-  readonly finallyBlock?: IrBlockStatement;
-};
-
-export type IrCatchClause = {
-  readonly kind: "catchClause";
-  readonly parameter?: IrPattern;
-  readonly body: IrBlockStatement;
-};
-
-export type IrBlockStatement = {
-  readonly kind: "blockStatement";
-  readonly statements: readonly IrStatement[];
-};
-
-export type IrBreakStatement = {
-  readonly kind: "breakStatement";
-  readonly label?: string;
-};
-
-export type IrContinueStatement = {
-  readonly kind: "continueStatement";
-  readonly label?: string;
-};
-
-export type IrEmptyStatement = {
-  readonly kind: "emptyStatement";
-};

package/src/ir/types.ts

@@ -1,97 +0,0 @@
-/**
- * Intermediate Representation (IR) types for Tsonic compiler
- * Main dispatcher - re-exports from specialized modules
- */
-
-// Re-export everything from types subdirectory for backward compatibility
-export type {
-  // Module types
-  IrModule,
-  IrImport,
-  IrImportSpecifier,
-  IrExport,
-  // Statement types
-  IrStatement,
-  IrVariableDeclaration,
-  IrVariableDeclarator,
-  IrFunctionDeclaration,
-  IrClassDeclaration,
-  IrClassMember,
-  IrMethodDeclaration,
-  IrPropertyDeclaration,
-  IrConstructorDeclaration,
-  IrInterfaceDeclaration,
-  IrEnumDeclaration,
-  IrEnumMember,
-  IrTypeAliasDeclaration,
-  IrExpressionStatement,
-  IrReturnStatement,
-  IrIfStatement,
-  IrWhileStatement,
-  IrForStatement,
-  IrForOfStatement,
-  IrSwitchStatement,
-  IrSwitchCase,
-  IrThrowStatement,
-  IrTryStatement,
-  IrCatchClause,
-  IrBlockStatement,
-  IrBreakStatement,
-  IrContinueStatement,
-  IrEmptyStatement,
-  // Expression types
-  IrExpression,
-  IrLiteralExpression,
-  IrIdentifierExpression,
-  IrArrayExpression,
-  IrObjectExpression,
-  IrObjectProperty,
-  IrFunctionExpression,
-  IrArrowFunctionExpression,
-  IrMemberExpression,
-  IrCallExpression,
-  IrNewExpression,
-  IrThisExpression,
-  IrUpdateExpression,
-  IrUnaryExpression,
-  IrBinaryExpression,
-  IrLogicalExpression,
-  IrConditionalExpression,
-  IrAssignmentExpression,
-  IrTemplateLiteralExpression,
-  IrSpreadExpression,
-  IrAwaitExpression,
-  IrYieldExpression,
-  // Type system types
-  IrType,
-  IrPrimitiveType,
-  IrReferenceType,
-  IrArrayType,
-  IrFunctionType,
-  IrObjectType,
-  IrDictionaryType,
-  IrUnionType,
-  IrIntersectionType,
-  IrLiteralType,
-  IrAnyType,
-  IrUnknownType,
-  IrVoidType,
-  IrNeverType,
-  // Helper types
-  IrPattern,
-  IrIdentifierPattern,
-  IrArrayPattern,
-  IrObjectPattern,
-  IrObjectPatternProperty,
-  IrTypeParameter,
-  IrParameter,
-  IrInterfaceMember,
-  IrPropertySignature,
-  IrMethodSignature,
-  IrAccessibility,
-  IrBinaryOperator,
-  IrAssignmentOperator,
-} from "./types/index.js";
-
-// Re-export type guards
-export { isStatement, isExpression } from "./types/guards.js";

package/src/metadata/bindings-loader.test.ts

@@ -1,144 +0,0 @@
-/**
- * Tests for bindings JSON loader
- */
-
-import { describe, it } from "mocha";
-import { strict as assert } from "assert";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import {
-  loadBindingsFile,
-  buildBindingsRegistry,
-  lookupTypeBinding,
-} from "./bindings-loader.js";
-import type { BindingsFile } from "../types/bindings.js";
-
-describe("Bindings Loader", () => {
-  describe("loadBindingsFile", () => {
-    it("should load valid bindings file", () => {
-      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-test-"));
-      const bindingsPath = path.join(tmpDir, "test.bindings.json");
-
-      const bindings: BindingsFile = {
-        namespace: "System",
-        types: [
-          {
-            clrName: "System.String",
-            tsEmitName: "String",
-            assemblyName: "System.Runtime",
-            metadataToken: 0x02000001,
-            methods: [],
-            exposedMethods: [],
-          },
-        ],
-      };
-
-      fs.writeFileSync(bindingsPath, JSON.stringify(bindings, null, 2));
-
-      const result = loadBindingsFile(bindingsPath);
-
-      // Cleanup
-      fs.unlinkSync(bindingsPath);
-      fs.rmdirSync(tmpDir);
-
-      assert.ok(result.ok);
-      if (result.ok) {
-        assert.equal(result.value.namespace, "System");
-        assert.equal(result.value.types.length, 1);
-        assert.equal(result.value.types[0]?.tsEmitName, "String");
-      }
-    });
-
-    it("should return error for non-existent file", () => {
-      const result = loadBindingsFile("/nonexistent/file.bindings.json");
-
-      assert.ok(!result.ok);
-      if (!result.ok) {
-        assert.equal(result.error[0]?.code, "TSN9101");
-      }
-    });
-
-    it("should return error for invalid JSON", () => {
-      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-test-"));
-      const bindingsPath = path.join(tmpDir, "invalid.bindings.json");
-
-      fs.writeFileSync(bindingsPath, "{ invalid json }");
-
-      const result = loadBindingsFile(bindingsPath);
-
-      // Cleanup
-      fs.unlinkSync(bindingsPath);
-      fs.rmdirSync(tmpDir);
-
-      assert.ok(!result.ok);
-      if (!result.ok) {
-        assert.equal(result.error[0]?.code, "TSN9103");
-      }
-    });
-  });
-
-  describe("buildBindingsRegistry", () => {
-    it("should build registry from bindings files", () => {
-      const bindings1: BindingsFile = {
-        namespace: "System",
-        types: [
-          {
-            clrName: "System.String",
-            tsEmitName: "String",
-            assemblyName: "System.Runtime",
-            metadataToken: 0x02000001,
-          },
-        ],
-      };
-
-      const bindings2: BindingsFile = {
-        namespace: "System.Collections",
-        types: [
-          {
-            clrName: "System.Collections.ArrayList",
-            tsEmitName: "ArrayList",
-            assemblyName: "System.Collections",
-            metadataToken: 0x02000002,
-          },
-        ],
-      };
-
-      const registry = buildBindingsRegistry([bindings1, bindings2]);
-
-      assert.equal(registry.size, 2);
-      assert.ok(registry.has("System.String"));
-      assert.ok(registry.has("System.Collections.ArrayList"));
-    });
-  });
-
-  describe("lookupTypeBinding", () => {
-    it("should find type binding in registry", () => {
-      const bindings: BindingsFile = {
-        namespace: "System",
-        types: [
-          {
-            clrName: "System.String",
-            tsEmitName: "String",
-            assemblyName: "System.Runtime",
-            metadataToken: 0x02000001,
-          },
-        ],
-      };
-
-      const registry = buildBindingsRegistry([bindings]);
-      const binding = lookupTypeBinding(registry, "System.String");
-
-      assert.ok(binding);
-      assert.equal(binding?.tsEmitName, "String");
-      assert.equal(binding?.metadataToken, 0x02000001);
-    });
-
-    it("should return undefined for non-existent type", () => {
-      const registry = buildBindingsRegistry([]);
-      const binding = lookupTypeBinding(registry, "NonExistent.Type");
-
-      assert.equal(binding, undefined);
-    });
-  });
-});