@tsonic/frontend 0.0.1 → 0.0.2

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

@@ -1,64 +0,0 @@
-/**
- * Reference type conversion
- */
-
-import * as ts from "typescript";
-import { IrType, IrDictionaryType } from "../types.js";
-import { isPrimitiveTypeName, getPrimitiveType } from "./primitives.js";
-import { getParameterModifierRegistry } from "../../types/parameter-modifiers.js";
-
-/**
- * Convert TypeScript type reference to IR type
- * Handles both primitive type names and user-defined types
- */
-export const convertTypeReference = (
-  node: ts.TypeReferenceNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrType => {
-  const typeName = ts.isIdentifier(node.typeName)
-    ? node.typeName.text
-    : node.typeName.getText();
-
-  // Check for primitive type names
-  if (isPrimitiveTypeName(typeName)) {
-    return getPrimitiveType(typeName);
-  }
-
-  // Check for Record<K, V> utility type → convert to IrDictionaryType
-  if (typeName === "Record" && node.typeArguments?.length === 2) {
-    const keyType = convertType(node.typeArguments[0]!, checker);
-    const valueType = convertType(node.typeArguments[1]!, checker);
-
-    return {
-      kind: "dictionaryType",
-      keyType,
-      valueType,
-    } as IrDictionaryType;
-  }
-
-  // Check if this is a parameter modifier type (ref/out/In) from @tsonic/types
-  const registry = getParameterModifierRegistry();
-  const modifierKind = registry.getParameterModifierKind(typeName);
-
-  if (modifierKind && node.typeArguments && node.typeArguments.length > 0) {
-    // This is ref<T>, out<T>, or In<T> from @tsonic/types
-    // Convert it to a special IR type that preserves the modifier
-    const wrappedType = convertType(node.typeArguments[0]!, checker);
-
-    return {
-      kind: "referenceType",
-      name: typeName,
-      typeArguments: [wrappedType],
-      // Add metadata to indicate this is a parameter modifier
-      parameterModifier: modifierKind,
-    } as IrType & { parameterModifier?: "ref" | "out" | "in" };
-  }
-
-  // Reference type (user-defined or library)
-  return {
-    kind: "referenceType",
-    name: typeName,
-    typeArguments: node.typeArguments?.map((t) => convertType(t, checker)),
-  };
-};

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

@@ -1,34 +0,0 @@
-/**
- * Union and intersection type conversion
- */
-
-import * as ts from "typescript";
-import { IrType } from "../types.js";
-
-/**
- * Convert TypeScript union type to IR union type
- */
-export const convertUnionType = (
-  node: ts.UnionTypeNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrType => {
-  return {
-    kind: "unionType",
-    types: node.types.map((t) => convertType(t, checker)),
-  };
-};
-
-/**
- * Convert TypeScript intersection type to IR intersection type
- */
-export const convertIntersectionType = (
-  node: ts.IntersectionTypeNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrType => {
-  return {
-    kind: "intersectionType",
-    types: node.types.map((t) => convertType(t, checker)),
-  };
-};

package/src/ir/type-converter.ts

@@ -1,13 +0,0 @@
-/**
- * Type converter - TypeScript types to IR types
- * Main dispatcher - re-exports from type-converter/ subdirectory
- */
-
-export {
-  convertType,
-  convertFunctionType,
-  convertObjectType,
-  convertBindingName,
-  inferType,
-  convertTsTypeToIr,
-} from "./type-converter/index.js";

package/src/ir/types/expressions.ts

@@ -1,215 +0,0 @@
-/**
- * Expression types for IR
- */
-
-import { IrType } from "./ir-types.js";
-import {
-  IrParameter,
-  IrPattern,
-  IrBinaryOperator,
-  IrAssignmentOperator,
-} from "./helpers.js";
-import { IrBlockStatement } from "./statements.js";
-
-export type IrExpression =
-  | IrLiteralExpression
-  | IrIdentifierExpression
-  | IrArrayExpression
-  | IrObjectExpression
-  | IrFunctionExpression
-  | IrArrowFunctionExpression
-  | IrMemberExpression
-  | IrCallExpression
-  | IrNewExpression
-  | IrThisExpression
-  | IrUpdateExpression
-  | IrUnaryExpression
-  | IrBinaryExpression
-  | IrLogicalExpression
-  | IrConditionalExpression
-  | IrAssignmentExpression
-  | IrTemplateLiteralExpression
-  | IrSpreadExpression
-  | IrAwaitExpression
-  | IrYieldExpression;
-
-export type IrLiteralExpression = {
-  readonly kind: "literal";
-  readonly value: string | number | boolean | null | undefined;
-  readonly raw?: string;
-  readonly inferredType?: IrType;
-};
-
-export type IrIdentifierExpression = {
-  readonly kind: "identifier";
-  readonly name: string;
-  readonly inferredType?: IrType;
-  // Resolved binding for globals (console, Math, etc.)
-  readonly resolvedClrType?: string; // e.g., "Tsonic.Runtime.console"
-  readonly resolvedAssembly?: string; // e.g., "Tsonic.Runtime"
-  readonly csharpName?: string; // Optional: renamed identifier in C# (from binding)
-  // For imported symbols from local modules
-  readonly importedFrom?: {
-    readonly containerName: string; // e.g., "Math"
-    readonly exportName: string; // e.g., "add" (may differ from local name if aliased)
-    readonly namespace: string; // e.g., "MultiFileCheck.utils"
-  };
-};
-
-export type IrArrayExpression = {
-  readonly kind: "array";
-  readonly elements: readonly (IrExpression | IrSpreadExpression | undefined)[]; // undefined for holes
-  readonly inferredType?: IrType;
-};
-
-export type IrObjectExpression = {
-  readonly kind: "object";
-  readonly properties: readonly IrObjectProperty[];
-  readonly inferredType?: IrType;
-  /** Contextual type for object literals in typed positions (return, assignment, etc.) */
-  readonly contextualType?: IrType;
-};
-
-export type IrObjectProperty =
-  | {
-      readonly kind: "property";
-      readonly key: string | IrExpression;
-      readonly value: IrExpression;
-      readonly shorthand: boolean;
-    }
-  | { readonly kind: "spread"; readonly expression: IrExpression };
-
-export type IrFunctionExpression = {
-  readonly kind: "functionExpression";
-  readonly name?: string;
-  readonly parameters: readonly IrParameter[];
-  readonly returnType?: IrType;
-  readonly body: IrBlockStatement;
-  readonly isAsync: boolean;
-  readonly isGenerator: boolean;
-  readonly inferredType?: IrType;
-};
-
-export type IrArrowFunctionExpression = {
-  readonly kind: "arrowFunction";
-  readonly parameters: readonly IrParameter[];
-  readonly returnType?: IrType;
-  readonly body: IrBlockStatement | IrExpression;
-  readonly isAsync: boolean;
-  readonly inferredType?: IrType;
-};
-
-export type IrMemberExpression = {
-  readonly kind: "memberAccess";
-  readonly object: IrExpression;
-  readonly property: IrExpression | string;
-  readonly isComputed: boolean; // true for obj[prop], false for obj.prop
-  readonly isOptional: boolean; // true for obj?.prop
-  readonly inferredType?: IrType;
-  // Hierarchical member binding (from bindings manifest)
-  // When a member access like systemLinq.enumerable.selectMany is resolved,
-  // this contains the full CLR binding info
-  readonly memberBinding?: {
-    readonly assembly: string; // e.g., "System.Linq"
-    readonly type: string; // Full CLR type e.g., "System.Linq.Enumerable"
-    readonly member: string; // CLR member name e.g., "SelectMany"
-  };
-};
-
-export type IrCallExpression = {
-  readonly kind: "call";
-  readonly callee: IrExpression;
-  readonly arguments: readonly (IrExpression | IrSpreadExpression)[];
-  readonly isOptional: boolean; // true for func?.()
-  readonly inferredType?: IrType;
-  readonly typeArguments?: readonly IrType[]; // Explicit or inferred type arguments
-  readonly requiresSpecialization?: boolean; // Flag for conditional/unsupported patterns
-  readonly argumentPassing?: readonly ("value" | "ref" | "out" | "in")[]; // Passing mode for each argument
-};
-
-export type IrNewExpression = {
-  readonly kind: "new";
-  readonly callee: IrExpression;
-  readonly arguments: readonly (IrExpression | IrSpreadExpression)[];
-  readonly inferredType?: IrType;
-  readonly typeArguments?: readonly IrType[]; // Explicit or inferred type arguments
-  readonly requiresSpecialization?: boolean; // Flag for conditional/unsupported patterns
-};
-
-export type IrThisExpression = {
-  readonly kind: "this";
-  readonly inferredType?: IrType;
-};
-
-export type IrUpdateExpression = {
-  readonly kind: "update";
-  readonly operator: "++" | "--";
-  readonly prefix: boolean;
-  readonly expression: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrUnaryExpression = {
-  readonly kind: "unary";
-  readonly operator: "+" | "-" | "!" | "~" | "typeof" | "void" | "delete";
-  readonly expression: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrBinaryExpression = {
-  readonly kind: "binary";
-  readonly operator: IrBinaryOperator;
-  readonly left: IrExpression;
-  readonly right: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrLogicalExpression = {
-  readonly kind: "logical";
-  readonly operator: "&&" | "||" | "??";
-  readonly left: IrExpression;
-  readonly right: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrConditionalExpression = {
-  readonly kind: "conditional";
-  readonly condition: IrExpression;
-  readonly whenTrue: IrExpression;
-  readonly whenFalse: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrAssignmentExpression = {
-  readonly kind: "assignment";
-  readonly operator: IrAssignmentOperator;
-  readonly left: IrExpression | IrPattern;
-  readonly right: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrTemplateLiteralExpression = {
-  readonly kind: "templateLiteral";
-  readonly quasis: readonly string[];
-  readonly expressions: readonly IrExpression[];
-  readonly inferredType?: IrType;
-};
-
-export type IrSpreadExpression = {
-  readonly kind: "spread";
-  readonly expression: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrAwaitExpression = {
-  readonly kind: "await";
-  readonly expression: IrExpression;
-  readonly inferredType?: IrType;
-};
-
-export type IrYieldExpression = {
-  readonly kind: "yield";
-  readonly expression?: IrExpression; // Optional for bare `yield`
-  readonly delegate: boolean; // true for `yield*`, false for `yield`
-  readonly inferredType?: IrType;
-};

package/src/ir/types/guards.ts

@@ -1,39 +0,0 @@
-/**
- * Type guard helper functions
- */
-
-import { IrStatement } from "./statements.js";
-import { IrExpression } from "./expressions.js";
-
-export const isStatement = (
-  node: IrStatement | IrExpression
-): node is IrStatement => {
-  const statementKinds: string[] = [
-    "variableDeclaration",
-    "functionDeclaration",
-    "classDeclaration",
-    "interfaceDeclaration",
-    "enumDeclaration",
-    "typeAliasDeclaration",
-    "expressionStatement",
-    "returnStatement",
-    "ifStatement",
-    "whileStatement",
-    "forStatement",
-    "forOfStatement",
-    "switchStatement",
-    "throwStatement",
-    "tryStatement",
-    "blockStatement",
-    "breakStatement",
-    "continueStatement",
-    "emptyStatement",
-  ];
-  return statementKinds.includes(node.kind);
-};
-
-export const isExpression = (
-  node: IrStatement | IrExpression
-): node is IrExpression => {
-  return !isStatement(node);
-};

package/src/ir/types/helpers.ts

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

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

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