@tsonic/frontend 0.0.1

package/src/ir/types/helpers.ts

@@ -0,0 +1,135 @@
+/**
+ * Supporting types (patterns, parameters, operators, accessibility, etc.)
+ */
+
+import { IrType } from "./ir-types.js";
+import { IrExpression } from "./expressions.js";
+
+// ============================================================================
+// Patterns (for destructuring)
+// ============================================================================
+
+export type IrPattern = IrIdentifierPattern | IrArrayPattern | IrObjectPattern;
+
+export type IrIdentifierPattern = {
+  readonly kind: "identifierPattern";
+  readonly name: string;
+  readonly type?: IrType;
+};
+
+export type IrArrayPattern = {
+  readonly kind: "arrayPattern";
+  readonly elements: readonly (IrPattern | undefined)[]; // undefined for holes
+};
+
+export type IrObjectPattern = {
+  readonly kind: "objectPattern";
+  readonly properties: readonly IrObjectPatternProperty[];
+};
+
+export type IrObjectPatternProperty =
+  | {
+      readonly kind: "property";
+      readonly key: string;
+      readonly value: IrPattern;
+      readonly shorthand: boolean;
+    }
+  | { readonly kind: "rest"; readonly pattern: IrPattern };
+
+// ============================================================================
+// Type Parameters
+// ============================================================================
+
+export type IrTypeParameter = {
+  readonly kind: "typeParameter";
+  readonly name: string;
+  readonly constraint?: IrType; // Can reference other type parameters (enables recursion)
+  readonly default?: IrType;
+  readonly variance?: "in" | "out"; // For covariance/contravariance
+  readonly isStructuralConstraint?: boolean; // Flag for { id: number } style constraints
+  readonly structuralMembers?: readonly IrInterfaceMember[]; // Properties for structural constraints
+};
+
+// ============================================================================
+// Parameters
+// ============================================================================
+
+export type IrParameter = {
+  readonly kind: "parameter";
+  readonly pattern: IrPattern;
+  readonly type?: IrType;
+  readonly initializer?: IrExpression;
+  readonly isOptional: boolean;
+  readonly isRest: boolean;
+  readonly passing: "value" | "ref" | "out" | "in"; // C# parameter passing mode
+};
+
+// ============================================================================
+// Interface Members (used by interfaces and object types)
+// ============================================================================
+
+export type IrInterfaceMember = IrPropertySignature | IrMethodSignature;
+
+export type IrPropertySignature = {
+  readonly kind: "propertySignature";
+  readonly name: string;
+  readonly type: IrType;
+  readonly isOptional: boolean;
+  readonly isReadonly: boolean;
+};
+
+export type IrMethodSignature = {
+  readonly kind: "methodSignature";
+  readonly name: string;
+  readonly typeParameters?: readonly IrTypeParameter[];
+  readonly parameters: readonly IrParameter[];
+  readonly returnType?: IrType;
+};
+
+// ============================================================================
+// Accessibility and Operators
+// ============================================================================
+
+export type IrAccessibility = "public" | "private" | "protected";
+
+export type IrBinaryOperator =
+  | "+"
+  | "-"
+  | "*"
+  | "/"
+  | "%"
+  | "**"
+  | "=="
+  | "!="
+  | "==="
+  | "!=="
+  | "<"
+  | ">"
+  | "<="
+  | ">="
+  | "<<"
+  | ">>"
+  | ">>>"
+  | "&"
+  | "|"
+  | "^"
+  | "in"
+  | "instanceof";
+
+export type IrAssignmentOperator =
+  | "="
+  | "+="
+  | "-="
+  | "*="
+  | "/="
+  | "%="
+  | "**="
+  | "<<="
+  | ">>="
+  | ">>>="
+  | "&="
+  | "|="
+  | "^="
+  | "&&="
+  | "||="
+  | "??=";

package/src/ir/types/index.ts

@@ -0,0 +1,108 @@
+/**
+ * IR types barrel exports
+ * Intermediate Representation (IR) types for Tsonic compiler
+ */
+
+// Module types
+export type {
+  IrModule,
+  IrImport,
+  IrImportSpecifier,
+  IrExport,
+} from "./module.js";
+
+// Statement types
+export type {
+  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,
+} from "./statements.js";
+
+// Expression types
+export type {
+  IrExpression,
+  IrLiteralExpression,
+  IrIdentifierExpression,
+  IrArrayExpression,
+  IrObjectExpression,
+  IrObjectProperty,
+  IrFunctionExpression,
+  IrArrowFunctionExpression,
+  IrMemberExpression,
+  IrCallExpression,
+  IrNewExpression,
+  IrThisExpression,
+  IrUpdateExpression,
+  IrUnaryExpression,
+  IrBinaryExpression,
+  IrLogicalExpression,
+  IrConditionalExpression,
+  IrAssignmentExpression,
+  IrTemplateLiteralExpression,
+  IrSpreadExpression,
+  IrAwaitExpression,
+  IrYieldExpression,
+} from "./expressions.js";
+
+// Type system types
+export type {
+  IrType,
+  IrPrimitiveType,
+  IrReferenceType,
+  IrArrayType,
+  IrFunctionType,
+  IrObjectType,
+  IrDictionaryType,
+  IrUnionType,
+  IrIntersectionType,
+  IrLiteralType,
+  IrAnyType,
+  IrUnknownType,
+  IrVoidType,
+  IrNeverType,
+} from "./ir-types.js";
+
+// Helper types
+export type {
+  IrPattern,
+  IrIdentifierPattern,
+  IrArrayPattern,
+  IrObjectPattern,
+  IrObjectPatternProperty,
+  IrTypeParameter,
+  IrParameter,
+  IrInterfaceMember,
+  IrPropertySignature,
+  IrMethodSignature,
+  IrAccessibility,
+  IrBinaryOperator,
+  IrAssignmentOperator,
+} from "./helpers.js";
+
+// Type guards
+export { isStatement, isExpression } from "./guards.js";

package/src/ir/types/ir-types.ts

@@ -0,0 +1,96 @@
+/**
+ * Type system types for IR (IrType and its variants)
+ */
+
+import { IrParameter, IrInterfaceMember } from "./helpers.js";
+
+export type IrType =
+  | IrPrimitiveType
+  | IrReferenceType
+  | IrArrayType
+  | IrFunctionType
+  | IrObjectType
+  | IrDictionaryType
+  | IrUnionType
+  | IrIntersectionType
+  | IrLiteralType
+  | IrAnyType
+  | IrUnknownType
+  | IrVoidType
+  | IrNeverType;
+
+export type IrPrimitiveType = {
+  readonly kind: "primitiveType";
+  readonly name: "string" | "number" | "boolean" | "null" | "undefined";
+};
+
+export type IrReferenceType = {
+  readonly kind: "referenceType";
+  readonly name: string;
+  readonly typeArguments?: readonly IrType[];
+  /** Fully-qualified CLR type for imported types (e.g., "MyApp.models.User") */
+  readonly resolvedClrType?: string;
+};
+
+export type IrArrayType = {
+  readonly kind: "arrayType";
+  readonly elementType: IrType;
+};
+
+export type IrFunctionType = {
+  readonly kind: "functionType";
+  readonly parameters: readonly IrParameter[];
+  readonly returnType: IrType;
+};
+
+export type IrObjectType = {
+  readonly kind: "objectType";
+  readonly members: readonly IrInterfaceMember[];
+};
+
+/**
+ * Dictionary/map type for index signatures and Record<K, V>
+ *
+ * Examples:
+ * - `{ [k: string]: T }` → IrDictionaryType { keyType: string, valueType: T }
+ * - `Record<string, T>` → IrDictionaryType { keyType: string, valueType: T }
+ *
+ * Emits to C# Dictionary<TKey, TValue>.
+ * Access should be via indexer `d["key"]` (dot property access will fail in C#).
+ */
+export type IrDictionaryType = {
+  readonly kind: "dictionaryType";
+  readonly keyType: IrType;
+  readonly valueType: IrType;
+};
+
+export type IrUnionType = {
+  readonly kind: "unionType";
+  readonly types: readonly IrType[];
+};
+
+export type IrIntersectionType = {
+  readonly kind: "intersectionType";
+  readonly types: readonly IrType[];
+};
+
+export type IrLiteralType = {
+  readonly kind: "literalType";
+  readonly value: string | number | boolean;
+};
+
+export type IrAnyType = {
+  readonly kind: "anyType";
+};
+
+export type IrUnknownType = {
+  readonly kind: "unknownType";
+};
+
+export type IrVoidType = {
+  readonly kind: "voidType";
+};
+
+export type IrNeverType = {
+  readonly kind: "neverType";
+};

package/src/ir/types/module.ts

@@ -0,0 +1,57 @@
+/**
+ * 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

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