@tsonic/frontend 0.0.1 → 0.0.4

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

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

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

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

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

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

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

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

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

@@ -1,120 +0,0 @@
-/**
- * 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/methods.ts

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