@tsonic/frontend 0.0.1

package/src/ir/converters/expressions/operators.ts

@@ -0,0 +1,147 @@
+/**
+ * Operator expression converters (binary, unary, update, assignment)
+ */
+
+import * as ts from "typescript";
+import {
+  IrExpression,
+  IrUnaryExpression,
+  IrUpdateExpression,
+  IrBinaryOperator,
+  IrAssignmentOperator,
+} from "../../types.js";
+import {
+  getInferredType,
+  convertBinaryOperator,
+  isAssignmentOperator,
+} from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+
+/**
+ * Convert binary expression (including logical and assignment)
+ */
+export const convertBinaryExpression = (
+  node: ts.BinaryExpression,
+  checker: ts.TypeChecker
+): IrExpression => {
+  const operator = convertBinaryOperator(node.operatorToken);
+  const inferredType = getInferredType(node, checker);
+
+  // Handle assignment separately
+  if (isAssignmentOperator(node.operatorToken)) {
+    return {
+      kind: "assignment",
+      operator: operator as IrAssignmentOperator,
+      left: ts.isIdentifier(node.left)
+        ? { kind: "identifier", name: node.left.text }
+        : convertExpression(node.left, checker),
+      right: convertExpression(node.right, checker),
+      inferredType,
+    };
+  }
+
+  // Handle logical operators
+  if (operator === "&&" || operator === "||" || operator === "??") {
+    return {
+      kind: "logical",
+      operator,
+      left: convertExpression(node.left, checker),
+      right: convertExpression(node.right, checker),
+      inferredType,
+    };
+  }
+
+  // Regular binary expression
+  return {
+    kind: "binary",
+    operator: operator as IrBinaryOperator,
+    left: convertExpression(node.left, checker),
+    right: convertExpression(node.right, checker),
+    inferredType,
+  };
+};
+
+/**
+ * Convert prefix unary expression
+ */
+export const convertUnaryExpression = (
+  node: ts.PrefixUnaryExpression,
+  checker: ts.TypeChecker
+): IrUnaryExpression | IrUpdateExpression => {
+  const inferredType = getInferredType(node, checker);
+
+  // Check if it's an increment/decrement (++ or --)
+  if (
+    node.operator === ts.SyntaxKind.PlusPlusToken ||
+    node.operator === ts.SyntaxKind.MinusMinusToken
+  ) {
+    return {
+      kind: "update",
+      operator: node.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+      prefix: true,
+      expression: convertExpression(node.operand, checker),
+      inferredType,
+    };
+  }
+
+  // Handle regular unary operators
+  let operator: IrUnaryExpression["operator"] = "+";
+
+  switch (node.operator) {
+    case ts.SyntaxKind.PlusToken:
+      operator = "+";
+      break;
+    case ts.SyntaxKind.MinusToken:
+      operator = "-";
+      break;
+    case ts.SyntaxKind.ExclamationToken:
+      operator = "!";
+      break;
+    case ts.SyntaxKind.TildeToken:
+      operator = "~";
+      break;
+  }
+
+  return {
+    kind: "unary",
+    operator,
+    expression: convertExpression(node.operand, checker),
+    inferredType,
+  };
+};
+
+/**
+ * Convert postfix unary expression (++ or --)
+ */
+export const convertUpdateExpression = (
+  node: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression,
+  checker: ts.TypeChecker
+): IrUpdateExpression => {
+  const inferredType = getInferredType(node, checker);
+
+  if (ts.isPrefixUnaryExpression(node)) {
+    // Check if it's an increment or decrement
+    if (
+      node.operator === ts.SyntaxKind.PlusPlusToken ||
+      node.operator === ts.SyntaxKind.MinusMinusToken
+    ) {
+      return {
+        kind: "update",
+        operator: node.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+        prefix: true,
+        expression: convertExpression(node.operand, checker),
+        inferredType,
+      };
+    }
+  }
+
+  // Handle postfix unary expression
+  const postfix = node as ts.PostfixUnaryExpression;
+  return {
+    kind: "update",
+    operator: postfix.operator === ts.SyntaxKind.PlusPlusToken ? "++" : "--",
+    prefix: false,
+    expression: convertExpression(postfix.operand, checker),
+    inferredType,
+  };
+};

package/src/ir/converters/expressions/other.ts

@@ -0,0 +1,60 @@
+/**
+ * Miscellaneous expression converters (conditional, template literals)
+ */
+
+import * as ts from "typescript";
+import {
+  IrConditionalExpression,
+  IrTemplateLiteralExpression,
+  IrExpression,
+} from "../../types.js";
+import { getInferredType } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+
+/**
+ * Convert conditional (ternary) expression
+ */
+export const convertConditionalExpression = (
+  node: ts.ConditionalExpression,
+  checker: ts.TypeChecker
+): IrConditionalExpression => {
+  return {
+    kind: "conditional",
+    condition: convertExpression(node.condition, checker),
+    whenTrue: convertExpression(node.whenTrue, checker),
+    whenFalse: convertExpression(node.whenFalse, checker),
+    inferredType: getInferredType(node, checker),
+  };
+};
+
+/**
+ * Convert template literal expression
+ */
+export const convertTemplateLiteral = (
+  node: ts.TemplateExpression | ts.NoSubstitutionTemplateLiteral,
+  checker: ts.TypeChecker
+): IrTemplateLiteralExpression => {
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    return {
+      kind: "templateLiteral",
+      quasis: [node.text],
+      expressions: [],
+      inferredType: getInferredType(node, checker),
+    };
+  }
+
+  const quasis: string[] = [node.head.text];
+  const expressions: IrExpression[] = [];
+
+  node.templateSpans.forEach((span) => {
+    expressions.push(convertExpression(span.expression, checker));
+    quasis.push(span.literal.text);
+  });
+
+  return {
+    kind: "templateLiteral",
+    quasis,
+    expressions,
+    inferredType: getInferredType(node, checker),
+  };
+};

package/src/ir/converters/statements/control/blocks.ts

@@ -0,0 +1,22 @@
+/**
+ * Block statement converter
+ */
+
+import * as ts from "typescript";
+import { IrStatement, IrBlockStatement } from "../../../types.js";
+import { convertStatement } from "../../../statement-converter.js";
+
+/**
+ * Convert block statement
+ */
+export const convertBlockStatement = (
+  node: ts.Block,
+  checker: ts.TypeChecker
+): IrBlockStatement => {
+  return {
+    kind: "blockStatement",
+    statements: node.statements
+      .map((s) => convertStatement(s, checker))
+      .filter((s): s is IrStatement => s !== null),
+  };
+};

package/src/ir/converters/statements/control/conditionals.ts

@@ -0,0 +1,67 @@
+/**
+ * Conditional statement converters (if, switch)
+ */
+
+import * as ts from "typescript";
+import {
+  IrStatement,
+  IrIfStatement,
+  IrSwitchStatement,
+  IrSwitchCase,
+} from "../../../types.js";
+import { convertExpression } from "../../../expression-converter.js";
+import { convertStatement } from "../../../statement-converter.js";
+
+/**
+ * Convert if statement
+ */
+export const convertIfStatement = (
+  node: ts.IfStatement,
+  checker: ts.TypeChecker
+): IrIfStatement => {
+  const thenStmt = convertStatement(node.thenStatement, checker);
+  const elseStmt = node.elseStatement
+    ? convertStatement(node.elseStatement, checker)
+    : undefined;
+
+  return {
+    kind: "ifStatement",
+    condition: convertExpression(node.expression, checker),
+    thenStatement: thenStmt ?? { kind: "emptyStatement" },
+    elseStatement: elseStmt ?? undefined,
+  };
+};
+
+/**
+ * Convert switch statement
+ */
+export const convertSwitchStatement = (
+  node: ts.SwitchStatement,
+  checker: ts.TypeChecker
+): IrSwitchStatement => {
+  return {
+    kind: "switchStatement",
+    expression: convertExpression(node.expression, checker),
+    cases: node.caseBlock.clauses.map((clause) =>
+      convertSwitchCase(clause, checker)
+    ),
+  };
+};
+
+/**
+ * Convert switch case
+ */
+export const convertSwitchCase = (
+  node: ts.CaseOrDefaultClause,
+  checker: ts.TypeChecker
+): IrSwitchCase => {
+  return {
+    kind: "switchCase",
+    test: ts.isCaseClause(node)
+      ? convertExpression(node.expression, checker)
+      : undefined,
+    statements: node.statements
+      .map((s) => convertStatement(s, checker))
+      .filter((s): s is IrStatement => s !== null),
+  };
+};

package/src/ir/converters/statements/control/exceptions.ts

@@ -0,0 +1,43 @@
+/**
+ * Exception handling converters (try, catch)
+ */
+
+import * as ts from "typescript";
+import { IrTryStatement, IrCatchClause } from "../../../types.js";
+import { convertBindingName } from "../../../type-converter.js";
+import { convertBlockStatement } from "./blocks.js";
+
+/**
+ * Convert try statement
+ */
+export const convertTryStatement = (
+  node: ts.TryStatement,
+  checker: ts.TypeChecker
+): IrTryStatement => {
+  return {
+    kind: "tryStatement",
+    tryBlock: convertBlockStatement(node.tryBlock, checker),
+    catchClause: node.catchClause
+      ? convertCatchClause(node.catchClause, checker)
+      : undefined,
+    finallyBlock: node.finallyBlock
+      ? convertBlockStatement(node.finallyBlock, checker)
+      : undefined,
+  };
+};
+
+/**
+ * Convert catch clause
+ */
+export const convertCatchClause = (
+  node: ts.CatchClause,
+  checker: ts.TypeChecker
+): IrCatchClause => {
+  return {
+    kind: "catchClause",
+    parameter: node.variableDeclaration
+      ? convertBindingName(node.variableDeclaration.name)
+      : undefined,
+    body: convertBlockStatement(node.block, checker),
+  };
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Control flow statement converters - Public API
+ */
+
+export {
+  convertIfStatement,
+  convertSwitchStatement,
+  convertSwitchCase,
+} from "./conditionals.js";
+export {
+  convertWhileStatement,
+  convertForStatement,
+  convertForOfStatement,
+  convertForInStatement,
+} from "./loops.js";
+export { convertTryStatement, convertCatchClause } from "./exceptions.js";
+export { convertBlockStatement } from "./blocks.js";

package/src/ir/converters/statements/control/loops.ts

@@ -0,0 +1,99 @@
+/**
+ * Loop statement converters (while, for, for-of, for-in)
+ */
+
+import * as ts from "typescript";
+import {
+  IrWhileStatement,
+  IrForStatement,
+  IrForOfStatement,
+} from "../../../types.js";
+import { convertExpression } from "../../../expression-converter.js";
+import { convertBindingName } from "../../../type-converter.js";
+import { convertStatement } from "../../../statement-converter.js";
+import { convertVariableDeclarationList } from "../helpers.js";
+
+/**
+ * Convert while statement
+ */
+export const convertWhileStatement = (
+  node: ts.WhileStatement,
+  checker: ts.TypeChecker
+): IrWhileStatement => {
+  const body = convertStatement(node.statement, checker);
+  return {
+    kind: "whileStatement",
+    condition: convertExpression(node.expression, checker),
+    body: body ?? { kind: "emptyStatement" },
+  };
+};
+
+/**
+ * Convert for statement
+ */
+export const convertForStatement = (
+  node: ts.ForStatement,
+  checker: ts.TypeChecker
+): IrForStatement => {
+  const body = convertStatement(node.statement, checker);
+  return {
+    kind: "forStatement",
+    initializer: node.initializer
+      ? ts.isVariableDeclarationList(node.initializer)
+        ? convertVariableDeclarationList(node.initializer, checker)
+        : convertExpression(node.initializer, checker)
+      : undefined,
+    condition: node.condition
+      ? convertExpression(node.condition, checker)
+      : undefined,
+    update: node.incrementor
+      ? convertExpression(node.incrementor, checker)
+      : undefined,
+    body: body ?? { kind: "emptyStatement" },
+  };
+};
+
+/**
+ * Convert for-of statement
+ */
+export const convertForOfStatement = (
+  node: ts.ForOfStatement,
+  checker: ts.TypeChecker
+): IrForOfStatement => {
+  const firstDecl = ts.isVariableDeclarationList(node.initializer)
+    ? node.initializer.declarations[0]
+    : undefined;
+
+  const variable = ts.isVariableDeclarationList(node.initializer)
+    ? convertBindingName(firstDecl?.name ?? ts.factory.createIdentifier("_"))
+    : convertBindingName(node.initializer as ts.BindingName);
+
+  const body = convertStatement(node.statement, checker);
+  return {
+    kind: "forOfStatement",
+    variable,
+    expression: convertExpression(node.expression, checker),
+    body: body ?? { kind: "emptyStatement" },
+  };
+};
+
+/**
+ * Convert for-in statement
+ */
+export const convertForInStatement = (
+  node: ts.ForInStatement,
+  checker: ts.TypeChecker
+): IrForStatement => {
+  // Note: for...in needs special handling in C# - variable extraction will be handled in emitter
+  // We'll need to extract the variable info in the emitter phase
+
+  const body = convertStatement(node.statement, checker);
+  // Note: for...in needs special handling in C#
+  return {
+    kind: "forStatement",
+    initializer: undefined,
+    condition: undefined,
+    update: undefined,
+    body: body ?? { kind: "emptyStatement" },
+  };
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Control flow statement converters (if, while, for, switch, try, block)
+ * Main dispatcher - re-exports from control/ subdirectory
+ */
+
+export {
+  convertIfStatement,
+  convertSwitchStatement,
+  convertSwitchCase,
+  convertWhileStatement,
+  convertForStatement,
+  convertForOfStatement,
+  convertForInStatement,
+  convertTryStatement,
+  convertCatchClause,
+  convertBlockStatement,
+} from "./control/index.js";

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

@@ -0,0 +1,120 @@
+/**
+ * Constructor conversion with parameter properties
+ */
+
+import * as ts from "typescript";
+import { IrClassMember, IrStatement } from "../../../../types.js";
+import { convertType } from "../../../../type-converter.js";
+import { convertBlockStatement } from "../../control.js";
+import {
+  hasReadonlyModifier,
+  getAccessibility,
+  convertParameters,
+} from "../../helpers.js";
+
+/**
+ * Convert constructor declaration to IR
+ */
+export const convertConstructor = (
+  node: ts.ConstructorDeclaration,
+  checker: ts.TypeChecker,
+  constructorParams?: ts.NodeArray<ts.ParameterDeclaration>
+): IrClassMember => {
+  // Build constructor body with parameter property assignments
+  const statements: IrStatement[] = [];
+
+  // Add assignments for parameter properties (parameters with explicit modifiers)
+  if (constructorParams) {
+    for (const param of constructorParams) {
+      // Check if parameter has an EXPLICIT accessibility modifier
+      const modifiers = ts.getModifiers(param);
+      const hasAccessibilityModifier = modifiers?.some(
+        (m) =>
+          m.kind === ts.SyntaxKind.PublicKeyword ||
+          m.kind === ts.SyntaxKind.PrivateKeyword ||
+          m.kind === ts.SyntaxKind.ProtectedKeyword
+      );
+
+      if (hasAccessibilityModifier && ts.isIdentifier(param.name)) {
+        // Create: this.name = name;
+        statements.push({
+          kind: "expressionStatement",
+          expression: {
+            kind: "assignment",
+            operator: "=",
+            left: {
+              kind: "memberAccess",
+              object: { kind: "this" },
+              property: param.name.text,
+              isComputed: false,
+              isOptional: false,
+            },
+            right: {
+              kind: "identifier",
+              name: param.name.text,
+            },
+          },
+        });
+      }
+    }
+  }
+
+  // Add existing constructor body statements
+  if (node.body) {
+    const existingBody = convertBlockStatement(node.body, checker);
+    statements.push(...existingBody.statements);
+  }
+
+  return {
+    kind: "constructorDeclaration",
+    parameters: convertParameters(node.parameters, checker),
+    body: { kind: "blockStatement", statements },
+    accessibility: getAccessibility(node),
+  };
+};
+
+/**
+ * Extract parameter properties from constructor
+ */
+export const extractParameterProperties = (
+  constructor: ts.ConstructorDeclaration | undefined,
+  checker: ts.TypeChecker
+): IrClassMember[] => {
+  if (!constructor) {
+    return [];
+  }
+
+  const parameterProperties: IrClassMember[] = [];
+
+  for (const param of constructor.parameters) {
+    // Check if parameter has an EXPLICIT accessibility modifier
+    // (public/private/protected makes it a parameter property)
+    const modifiers = ts.getModifiers(param);
+    const hasAccessibilityModifier = modifiers?.some(
+      (m) =>
+        m.kind === ts.SyntaxKind.PublicKeyword ||
+        m.kind === ts.SyntaxKind.PrivateKeyword ||
+        m.kind === ts.SyntaxKind.ProtectedKeyword
+    );
+
+    if (!hasAccessibilityModifier) {
+      continue; // Not a parameter property
+    }
+
+    // Create a field declaration for this parameter property
+    if (ts.isIdentifier(param.name)) {
+      const accessibility = getAccessibility(param);
+      parameterProperties.push({
+        kind: "propertyDeclaration",
+        name: param.name.text,
+        type: param.type ? convertType(param.type, checker) : undefined,
+        initializer: undefined, // Will be assigned in constructor
+        isStatic: false,
+        isReadonly: hasReadonlyModifier(param),
+        accessibility,
+      });
+    }
+  }
+
+  return parameterProperties;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Class conversion - Public API
+ */
+
+export { convertClassDeclaration } from "./orchestrator.js";
+export { detectOverride, type OverrideInfo } from "./override-detection.js";
+export { convertProperty } from "./properties.js";
+export { convertMethod } from "./methods.js";
+export {
+  convertConstructor,
+  extractParameterProperties,
+} from "./constructors.js";

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

@@ -0,0 +1,61 @@
+/**
+ * Method member conversion
+ */
+
+import * as ts from "typescript";
+import { IrClassMember } from "../../../../types.js";
+import { convertType } from "../../../../type-converter.js";
+import { convertBlockStatement } from "../../control.js";
+import {
+  hasStaticModifier,
+  getAccessibility,
+  convertTypeParameters,
+  convertParameters,
+} from "../../helpers.js";
+import { detectOverride } from "./override-detection.js";
+
+/**
+ * Convert method declaration to IR
+ */
+export const convertMethod = (
+  node: ts.MethodDeclaration,
+  checker: ts.TypeChecker,
+  superClass: ts.ExpressionWithTypeArguments | undefined
+): IrClassMember => {
+  const memberName = ts.isIdentifier(node.name) ? node.name.text : "[computed]";
+
+  // Extract parameter types for method signature
+  const parameterTypes = node.parameters.map((param) => {
+    if (param.type) {
+      // Get type string representation
+      const type = checker.getTypeAtLocation(param.type);
+      return checker.typeToString(type);
+    }
+    return "any";
+  });
+
+  const overrideInfo = detectOverride(
+    memberName,
+    "method",
+    superClass,
+    checker,
+    parameterTypes
+  );
+
+  return {
+    kind: "methodDeclaration",
+    name: memberName,
+    typeParameters: convertTypeParameters(node.typeParameters, checker),
+    parameters: convertParameters(node.parameters, checker),
+    returnType: node.type ? convertType(node.type, checker) : undefined,
+    body: node.body ? convertBlockStatement(node.body, checker) : undefined,
+    isStatic: hasStaticModifier(node),
+    isAsync: !!node.modifiers?.some(
+      (m) => m.kind === ts.SyntaxKind.AsyncKeyword
+    ),
+    isGenerator: !!node.asteriskToken,
+    accessibility: getAccessibility(node),
+    isOverride: overrideInfo.isOverride ? true : undefined,
+    isShadow: overrideInfo.isShadow ? true : undefined,
+  };
+};