@tsonic/frontend 0.0.1

package/src/ir/converters/statements/declarations/variables.ts

@@ -0,0 +1,60 @@
+/**
+ * Variable declaration converter
+ */
+
+import * as ts from "typescript";
+import { IrVariableDeclaration } from "../../../types.js";
+import { convertExpression } from "../../../expression-converter.js";
+import {
+  convertType,
+  convertBindingName,
+  inferType,
+} from "../../../type-converter.js";
+import { hasExportModifier } from "../helpers.js";
+
+/**
+ * Get the IR type for a variable declaration.
+ * Uses explicit annotation if present, otherwise infers from TypeChecker.
+ */
+const getDeclarationType = (
+  decl: ts.VariableDeclaration,
+  checker: ts.TypeChecker,
+  needsExplicitType: boolean
+) => {
+  // If there's an explicit type annotation, use it
+  if (decl.type) {
+    return convertType(decl.type, checker);
+  }
+  // If we need an explicit type (for module-level exports), infer it
+  if (needsExplicitType) {
+    return inferType(decl, checker);
+  }
+  return undefined;
+};
+
+/**
+ * Convert variable statement
+ */
+export const convertVariableStatement = (
+  node: ts.VariableStatement,
+  checker: ts.TypeChecker
+): IrVariableDeclaration => {
+  const isConst = !!(node.declarationList.flags & ts.NodeFlags.Const);
+  const isLet = !!(node.declarationList.flags & ts.NodeFlags.Let);
+  const declarationKind = isConst ? "const" : isLet ? "let" : "var";
+  const isExported = hasExportModifier(node);
+
+  return {
+    kind: "variableDeclaration",
+    declarationKind,
+    declarations: node.declarationList.declarations.map((decl) => ({
+      kind: "variableDeclarator",
+      name: convertBindingName(decl.name),
+      type: getDeclarationType(decl, checker, isExported),
+      initializer: decl.initializer
+        ? convertExpression(decl.initializer, checker)
+        : undefined,
+    })),
+    isExported,
+  };
+};

package/src/ir/converters/statements/declarations.ts

@@ -0,0 +1,16 @@
+/**
+ * Declaration converters (variables, functions, classes, interfaces, enums, type aliases)
+ * Main dispatcher - re-exports from declarations/ subdirectory
+ */
+
+export {
+  setMetadataRegistry,
+  setBindingRegistry,
+  convertVariableStatement,
+  convertFunctionDeclaration,
+  convertClassDeclaration,
+  convertInterfaceDeclaration,
+  convertInterfaceMember,
+  convertEnumDeclaration,
+  convertTypeAliasDeclaration,
+} from "./declarations/index.js";

package/src/ir/converters/statements/helpers.ts

@@ -0,0 +1,174 @@
+/**
+ * Helper utilities for statement conversion
+ */
+
+import * as ts from "typescript";
+import {
+  IrParameter,
+  IrAccessibility,
+  IrTypeParameter,
+  IrInterfaceMember,
+  IrVariableDeclaration,
+} from "../../types.js";
+import { convertType, convertBindingName } from "../../type-converter.js";
+import { convertExpression } from "../../expression-converter.js";
+import { convertInterfaceMember } from "./declarations.js";
+
+/**
+ * Convert TypeScript type parameters to IR, detecting structural constraints
+ */
+export const convertTypeParameters = (
+  typeParameters: readonly ts.TypeParameterDeclaration[] | undefined,
+  checker: ts.TypeChecker
+): readonly IrTypeParameter[] | undefined => {
+  if (!typeParameters || typeParameters.length === 0) {
+    return undefined;
+  }
+
+  return typeParameters.map((tp) => {
+    const name = tp.name.text;
+    const constraint = tp.constraint
+      ? convertType(tp.constraint, checker)
+      : undefined;
+    const defaultType = tp.default
+      ? convertType(tp.default, checker)
+      : undefined;
+
+    // Check if constraint is structural (object literal type)
+    const isStructural = tp.constraint && ts.isTypeLiteralNode(tp.constraint);
+
+    // Extract structural members if it's a structural constraint
+    const structuralMembers =
+      isStructural && tp.constraint && ts.isTypeLiteralNode(tp.constraint)
+        ? tp.constraint.members
+            .map((member) => convertInterfaceMember(member, checker))
+            .filter((m): m is IrInterfaceMember => m !== null)
+        : undefined;
+
+    return {
+      kind: "typeParameter" as const,
+      name,
+      constraint,
+      default: defaultType,
+      variance: undefined, // TypeScript doesn't expose variance directly
+      isStructuralConstraint: isStructural,
+      structuralMembers,
+    };
+  });
+};
+
+/**
+ * Convert parameters for functions and methods
+ */
+export const convertParameters = (
+  parameters: ts.NodeArray<ts.ParameterDeclaration>,
+  checker: ts.TypeChecker
+): readonly IrParameter[] => {
+  return parameters.map((param) => {
+    let passing: "value" | "ref" | "out" | "in" = "value";
+    let actualType: ts.TypeNode | undefined = param.type;
+
+    // Detect ref<T>, out<T>, in<T> wrapper types
+    if (
+      param.type &&
+      ts.isTypeReferenceNode(param.type) &&
+      ts.isIdentifier(param.type.typeName)
+    ) {
+      const typeName = param.type.typeName.text;
+      if (
+        (typeName === "ref" || typeName === "out" || typeName === "in") &&
+        param.type.typeArguments &&
+        param.type.typeArguments.length > 0
+      ) {
+        // Set passing mode
+        passing = typeName === "in" ? "in" : typeName;
+        // Extract wrapped type
+        actualType = param.type.typeArguments[0];
+      }
+    }
+
+    return {
+      kind: "parameter",
+      pattern: convertBindingName(param.name),
+      type: actualType ? convertType(actualType, checker) : undefined,
+      initializer: param.initializer
+        ? convertExpression(param.initializer, checker)
+        : undefined,
+      isOptional: !!param.questionToken,
+      isRest: !!param.dotDotDotToken,
+      passing,
+    };
+  });
+};
+
+/**
+ * Convert variable declaration list (used in for loops)
+ */
+export const convertVariableDeclarationList = (
+  node: ts.VariableDeclarationList,
+  checker: ts.TypeChecker
+): IrVariableDeclaration => {
+  const isConst = !!(node.flags & ts.NodeFlags.Const);
+  const isLet = !!(node.flags & ts.NodeFlags.Let);
+  const declarationKind = isConst ? "const" : isLet ? "let" : "var";
+
+  return {
+    kind: "variableDeclaration",
+    declarationKind,
+    declarations: node.declarations.map((decl) => ({
+      kind: "variableDeclarator",
+      name: convertBindingName(decl.name),
+      type: decl.type ? convertType(decl.type, checker) : undefined,
+      initializer: decl.initializer
+        ? convertExpression(decl.initializer, checker)
+        : undefined,
+    })),
+    isExported: false,
+  };
+};
+
+/**
+ * Check if node has export modifier
+ */
+export const hasExportModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false
+  );
+};
+
+/**
+ * Check if node has static modifier
+ */
+export const hasStaticModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) ?? false
+  );
+};
+
+/**
+ * Check if node has readonly modifier
+ */
+export const hasReadonlyModifier = (node: ts.Node): boolean => {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return (
+    modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false
+  );
+};
+
+/**
+ * Get accessibility modifier
+ */
+export const getAccessibility = (node: ts.Node): IrAccessibility => {
+  if (!ts.canHaveModifiers(node)) return "public";
+  const modifiers = ts.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword))
+    return "private";
+  if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword))
+    return "protected";
+  return "public";
+};

package/src/ir/converters/statements/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Statement converters barrel exports
+ */
+
+// Helpers
+export {
+  convertTypeParameters,
+  convertParameters,
+  convertVariableDeclarationList,
+  hasExportModifier,
+  hasStaticModifier,
+  hasReadonlyModifier,
+  getAccessibility,
+} from "./helpers.js";
+
+// Control flow converters
+export {
+  convertIfStatement,
+  convertWhileStatement,
+  convertForStatement,
+  convertForOfStatement,
+  convertForInStatement,
+  convertSwitchStatement,
+  convertSwitchCase,
+  convertTryStatement,
+  convertCatchClause,
+  convertBlockStatement,
+} from "./control.js";
+
+// Declaration converters
+export {
+  setMetadataRegistry,
+  convertVariableStatement,
+  convertFunctionDeclaration,
+  convertClassDeclaration,
+  convertInterfaceDeclaration,
+  convertInterfaceMember,
+  convertEnumDeclaration,
+  convertTypeAliasDeclaration,
+} from "./declarations.js";

package/src/ir/expression-converter.ts

@@ -0,0 +1,207 @@
+/**
+ * Expression converter - TypeScript AST to IR expressions
+ * Main dispatcher - delegates to specialized modules
+ */
+
+import * as ts from "typescript";
+import { IrExpression } from "./types.js";
+import { getBindingRegistry } from "./converters/statements/declarations/registry.js";
+import { convertType } from "./type-converter.js";
+
+// Import expression converters from specialized modules
+import { convertLiteral } from "./converters/expressions/literals.js";
+import {
+  convertArrayLiteral,
+  convertObjectLiteral,
+} from "./converters/expressions/collections.js";
+import { convertMemberExpression } from "./converters/expressions/access.js";
+import {
+  convertCallExpression,
+  convertNewExpression,
+} from "./converters/expressions/calls.js";
+import {
+  convertBinaryExpression,
+  convertUnaryExpression,
+  convertUpdateExpression,
+} from "./converters/expressions/operators.js";
+import {
+  convertFunctionExpression,
+  convertArrowFunction,
+} from "./converters/expressions/functions.js";
+import {
+  convertConditionalExpression,
+  convertTemplateLiteral,
+} from "./converters/expressions/other.js";
+import { getInferredType } from "./converters/expressions/helpers.js";
+
+/**
+ * Main expression conversion dispatcher
+ * Converts TypeScript expression nodes to IR expressions
+ */
+export const convertExpression = (
+  node: ts.Expression,
+  checker: ts.TypeChecker
+): IrExpression => {
+  const inferredType = getInferredType(node, checker);
+
+  if (ts.isStringLiteral(node) || ts.isNumericLiteral(node)) {
+    return convertLiteral(node, checker);
+  }
+  if (
+    node.kind === ts.SyntaxKind.TrueKeyword ||
+    node.kind === ts.SyntaxKind.FalseKeyword
+  ) {
+    return {
+      kind: "literal",
+      value: node.kind === ts.SyntaxKind.TrueKeyword,
+      raw: node.getText(),
+      inferredType,
+    };
+  }
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return { kind: "literal", value: null, raw: "null", inferredType };
+  }
+  if (
+    node.kind === ts.SyntaxKind.UndefinedKeyword ||
+    ts.isVoidExpression(node)
+  ) {
+    return {
+      kind: "literal",
+      value: undefined,
+      raw: "undefined",
+      inferredType,
+    };
+  }
+  if (ts.isIdentifier(node)) {
+    // Check if this identifier is bound to a CLR type (e.g., console, Math, etc.)
+    const binding = getBindingRegistry().getBinding(node.text);
+    if (binding && binding.kind === "global") {
+      return {
+        kind: "identifier",
+        name: node.text,
+        inferredType,
+        resolvedClrType: binding.type,
+        resolvedAssembly: binding.assembly,
+        csharpName: binding.csharpName, // Optional C# name from binding
+      };
+    }
+    return { kind: "identifier", name: node.text, inferredType };
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return convertArrayLiteral(node, checker);
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    return convertObjectLiteral(node, checker);
+  }
+  if (
+    ts.isPropertyAccessExpression(node) ||
+    ts.isElementAccessExpression(node)
+  ) {
+    return convertMemberExpression(node, checker);
+  }
+  if (ts.isCallExpression(node)) {
+    return convertCallExpression(node, checker);
+  }
+  if (ts.isNewExpression(node)) {
+    return convertNewExpression(node, checker);
+  }
+  if (ts.isBinaryExpression(node)) {
+    return convertBinaryExpression(node, checker);
+  }
+  if (ts.isPrefixUnaryExpression(node)) {
+    return convertUnaryExpression(node, checker);
+  }
+  if (ts.isPostfixUnaryExpression(node)) {
+    return convertUpdateExpression(node, checker);
+  }
+  if (ts.isTypeOfExpression(node)) {
+    return {
+      kind: "unary",
+      operator: "typeof",
+      expression: convertExpression(node.expression, checker),
+      inferredType,
+    };
+  }
+  if (ts.isVoidExpression(node)) {
+    return {
+      kind: "unary",
+      operator: "void",
+      expression: convertExpression(node.expression, checker),
+      inferredType,
+    };
+  }
+  if (ts.isDeleteExpression(node)) {
+    return {
+      kind: "unary",
+      operator: "delete",
+      expression: convertExpression(node.expression, checker),
+      inferredType,
+    };
+  }
+  if (ts.isConditionalExpression(node)) {
+    return convertConditionalExpression(node, checker);
+  }
+  if (ts.isFunctionExpression(node)) {
+    return convertFunctionExpression(node, checker);
+  }
+  if (ts.isArrowFunction(node)) {
+    return convertArrowFunction(node, checker);
+  }
+  if (
+    ts.isTemplateExpression(node) ||
+    ts.isNoSubstitutionTemplateLiteral(node)
+  ) {
+    return convertTemplateLiteral(node, checker);
+  }
+  if (ts.isSpreadElement(node)) {
+    return {
+      kind: "spread",
+      expression: convertExpression(node.expression, checker),
+      inferredType,
+    };
+  }
+  if (node.kind === ts.SyntaxKind.ThisKeyword) {
+    return { kind: "this", inferredType };
+  }
+  if (ts.isAwaitExpression(node)) {
+    return {
+      kind: "await",
+      expression: convertExpression(node.expression, checker),
+      inferredType,
+    };
+  }
+  if (ts.isYieldExpression(node)) {
+    return {
+      kind: "yield",
+      expression: node.expression
+        ? convertExpression(node.expression, checker)
+        : undefined,
+      delegate: !!node.asteriskToken,
+      inferredType,
+    };
+  }
+  if (ts.isParenthesizedExpression(node)) {
+    return convertExpression(node.expression, checker);
+  }
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    // Convert the inner expression
+    const innerExpr = convertExpression(
+      ts.isAsExpression(node) ? node.expression : node.expression,
+      checker
+    );
+    // Preserve the asserted type - this is needed for casts like `x as int`
+    const assertedTypeNode = ts.isAsExpression(node) ? node.type : node.type;
+    const assertedType = convertType(assertedTypeNode, checker);
+    return { ...innerExpr, inferredType: assertedType };
+  }
+
+  // Fallback - treat as identifier
+  return { kind: "identifier", name: node.getText(), inferredType };
+};
+
+// Re-export commonly used functions for backward compatibility
+export {
+  getInferredType,
+  extractTypeArguments,
+  checkIfRequiresSpecialization,
+} from "./converters/expressions/helpers.js";

package/src/ir/generic-validator.ts

@@ -0,0 +1,100 @@
+/**
+ * Generic validation - detect truly unsupported generic patterns
+ *
+ * NOTE: Many previously-blocked constructs are now handled via:
+ * - Monomorphisation for finite specializations
+ * - CRTP pattern for `this` typing
+ * - Tuple specialisations for variadic parameters
+ * - Structural adapters for mapped/conditional types
+ *
+ * Only constructs with NO static mapping remain as errors.
+ */
+
+import * as ts from "typescript";
+import {
+  Diagnostic,
+  createDiagnostic,
+  SourceLocation,
+} from "../types/diagnostic.js";
+
+/**
+ * Get source location from TypeScript node
+ */
+const getLocation = (
+  node: ts.Node,
+  sourceFile: ts.SourceFile
+): SourceLocation => {
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(
+    node.getStart()
+  );
+  return {
+    file: sourceFile.fileName,
+    line: line + 1,
+    column: character + 1,
+    length: node.getWidth(),
+  };
+};
+
+/**
+ * Check for symbol index signatures (TSN7203)
+ *
+ * Symbol keys have no static C# mapping and must be rejected.
+ */
+export const checkForSymbolIndexSignature = (
+  node: ts.IndexSignatureDeclaration,
+  sourceFile: ts.SourceFile
+): Diagnostic | null => {
+  // Check if the parameter type is symbol
+  if (node.parameters.length > 0) {
+    const param = node.parameters[0];
+    if (param && param.type) {
+      // Check for symbol keyword type
+      if (param.type.kind === ts.SyntaxKind.SymbolKeyword) {
+        return createDiagnostic(
+          "TSN7203",
+          "error",
+          "Symbol keys are not supported in C#",
+          getLocation(node, sourceFile),
+          "Use string keys instead of symbol keys"
+        );
+      }
+
+      // Also check for type reference to 'symbol'
+      if (ts.isTypeReferenceNode(param.type)) {
+        if (
+          ts.isIdentifier(param.type.typeName) &&
+          param.type.typeName.text === "symbol"
+        ) {
+          return createDiagnostic(
+            "TSN7203",
+            "error",
+            "Symbol keys are not supported in C#",
+            getLocation(node, sourceFile),
+            "Use string keys instead of symbol keys"
+          );
+        }
+      }
+    }
+  }
+
+  return null;
+};
+
+/**
+ * REMOVED CHECKS (now handled by implementation):
+ *
+ * - checkForInferKeyword (TSN7102)
+ *   Conditional types with infer are handled via monomorphisation
+ *
+ * - checkForRecursiveMappedType (TSN7101)
+ *   Finite mapped types are specialized; unbounded cases get adapters
+ *
+ * - checkForThisType (TSN7103)
+ *   `this` typing is handled via CRTP pattern
+ *
+ * - checkForVariadicTypeParameter (TSN7104)
+ *   Variadic parameters are handled via tuple specialisations
+ *
+ * - checkForRecursiveStructuralAlias (TSN7201)
+ *   Recursive structural aliases emit as C# classes with nullable refs
+ */