@tsonic/frontend 0.0.1

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

@@ -0,0 +1,85 @@
+/**
+ * Type conversion orchestrator
+ */
+
+import * as ts from "typescript";
+import {
+  IrType,
+  IrFunctionType,
+  IrObjectType,
+  IrDictionaryType,
+} from "../types.js";
+import { convertPrimitiveKeyword } from "./primitives.js";
+import { convertTypeReference } from "./references.js";
+import { convertArrayType } from "./arrays.js";
+import { convertFunctionType } from "./functions.js";
+import { convertObjectType } from "./objects.js";
+import {
+  convertUnionType,
+  convertIntersectionType,
+} from "./unions-intersections.js";
+import { convertLiteralType } from "./literals.js";
+
+/**
+ * Convert TypeScript type node to IR type
+ */
+export const convertType = (
+  typeNode: ts.TypeNode,
+  checker: ts.TypeChecker
+): IrType => {
+  // Type references (including primitive type names)
+  if (ts.isTypeReferenceNode(typeNode)) {
+    return convertTypeReference(typeNode, checker, convertType);
+  }
+
+  // Primitive keywords
+  const primitiveType = convertPrimitiveKeyword(typeNode.kind);
+  if (primitiveType) {
+    return primitiveType;
+  }
+
+  // Array types
+  if (ts.isArrayTypeNode(typeNode)) {
+    return convertArrayType(typeNode, checker, convertType);
+  }
+
+  // Function types
+  if (ts.isFunctionTypeNode(typeNode)) {
+    return convertFunctionType(typeNode, checker, convertType);
+  }
+
+  // Object/interface types
+  if (ts.isTypeLiteralNode(typeNode)) {
+    return convertObjectType(typeNode, checker, convertType);
+  }
+
+  // Union types
+  if (ts.isUnionTypeNode(typeNode)) {
+    return convertUnionType(typeNode, checker, convertType);
+  }
+
+  // Intersection types
+  if (ts.isIntersectionTypeNode(typeNode)) {
+    return convertIntersectionType(typeNode, checker, convertType);
+  }
+
+  // Literal types
+  if (ts.isLiteralTypeNode(typeNode)) {
+    return convertLiteralType(typeNode);
+  }
+
+  // Parenthesized types
+  if (ts.isParenthesizedTypeNode(typeNode)) {
+    return convertType(typeNode.type, checker);
+  }
+
+  // Default to any type for unsupported types
+  return { kind: "anyType" };
+};
+
+// Re-export specialized converters for backward compatibility
+export { convertFunctionType } from "./functions.js";
+export { convertObjectType } from "./objects.js";
+
+// Export types
+export type { IrFunctionType, IrObjectType, IrDictionaryType };

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

@@ -0,0 +1,73 @@
+/**
+ * Binding pattern converter - TypeScript patterns to IR patterns
+ */
+
+import * as ts from "typescript";
+import { IrPattern, IrObjectPatternProperty } from "../types.js";
+
+/**
+ * Convert TypeScript binding name to IR pattern
+ */
+export const convertBindingName = (name: ts.BindingName): IrPattern => {
+  if (ts.isIdentifier(name)) {
+    return {
+      kind: "identifierPattern",
+      name: name.text,
+    };
+  }
+
+  if (ts.isArrayBindingPattern(name)) {
+    return {
+      kind: "arrayPattern",
+      elements: name.elements.map((elem) => {
+        if (ts.isOmittedExpression(elem)) {
+          return undefined; // Hole in array pattern
+        }
+        if (ts.isBindingElement(elem)) {
+          return convertBindingName(elem.name);
+        }
+        return undefined;
+      }),
+    };
+  }
+
+  if (ts.isObjectBindingPattern(name)) {
+    const properties: IrObjectPatternProperty[] = [];
+
+    name.elements.forEach((elem) => {
+      if (elem.dotDotDotToken) {
+        // Rest property
+        properties.push({
+          kind: "rest",
+          pattern: convertBindingName(elem.name),
+        });
+      } else {
+        const key = elem.propertyName
+          ? ts.isIdentifier(elem.propertyName)
+            ? elem.propertyName.text
+            : elem.propertyName.getText()
+          : ts.isIdentifier(elem.name)
+            ? elem.name.text
+            : "[computed]";
+
+        properties.push({
+          kind: "property",
+          key,
+          value: convertBindingName(elem.name),
+          shorthand: !elem.propertyName,
+        });
+      }
+    });
+
+    return {
+      kind: "objectPattern",
+      properties,
+    };
+  }
+
+  // Default to identifier pattern (should not reach here normally)
+  return {
+    kind: "identifierPattern",
+    name: "_unknown",
+  };
+};

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

@@ -0,0 +1,57 @@
+/**
+ * Primitive type conversion
+ */
+
+import * as ts from "typescript";
+import { IrType } from "../types.js";
+
+/**
+ * Convert TypeScript primitive keyword to IR type
+ */
+export const convertPrimitiveKeyword = (kind: ts.SyntaxKind): IrType | null => {
+  switch (kind) {
+    case ts.SyntaxKind.StringKeyword:
+      return { kind: "primitiveType", name: "string" };
+    case ts.SyntaxKind.NumberKeyword:
+      return { kind: "primitiveType", name: "number" };
+    case ts.SyntaxKind.BooleanKeyword:
+      return { kind: "primitiveType", name: "boolean" };
+    case ts.SyntaxKind.NullKeyword:
+      return { kind: "primitiveType", name: "null" };
+    case ts.SyntaxKind.UndefinedKeyword:
+      return { kind: "primitiveType", name: "undefined" };
+    case ts.SyntaxKind.VoidKeyword:
+      return { kind: "voidType" };
+    case ts.SyntaxKind.AnyKeyword:
+      return { kind: "anyType" };
+    case ts.SyntaxKind.UnknownKeyword:
+      return { kind: "unknownType" };
+    case ts.SyntaxKind.NeverKeyword:
+      return { kind: "neverType" };
+    default:
+      return null;
+  }
+};
+
+/**
+ * Check if a type name is a primitive type
+ */
+export const isPrimitiveTypeName = (
+  typeName: string
+): typeName is "string" | "number" | "boolean" | "null" | "undefined" => {
+  return ["string", "number", "boolean", "null", "undefined"].includes(
+    typeName
+  );
+};
+
+/**
+ * Get primitive type IR representation for a type name
+ */
+export const getPrimitiveType = (
+  typeName: "string" | "number" | "boolean" | "null" | "undefined"
+): IrType => {
+  return {
+    kind: "primitiveType",
+    name: typeName,
+  };
+};

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

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

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

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

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

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