@tsonic/frontend 0.0.1

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

@@ -0,0 +1,137 @@
+/**
+ * Call and new expression converters
+ */
+
+import * as ts from "typescript";
+import { IrCallExpression, IrNewExpression } from "../../types.js";
+import {
+  getInferredType,
+  extractTypeArguments,
+  checkIfRequiresSpecialization,
+} from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+
+/**
+ * Extract argument passing modes from resolved signature
+ * Returns array aligned with arguments, indicating ref/out/in/value for each
+ */
+const extractArgumentPassing = (
+  node: ts.CallExpression | ts.NewExpression,
+  checker: ts.TypeChecker
+): readonly ("value" | "ref" | "out" | "in")[] | undefined => {
+  try {
+    const signature = checker.getResolvedSignature(node);
+    if (!signature || !signature.declaration) {
+      return undefined;
+    }
+
+    const decl = signature.declaration;
+    let parameters: readonly ts.ParameterDeclaration[] = [];
+
+    // Extract parameters from declaration
+    if (
+      ts.isFunctionDeclaration(decl) ||
+      ts.isMethodDeclaration(decl) ||
+      ts.isConstructorDeclaration(decl) ||
+      ts.isArrowFunction(decl) ||
+      ts.isFunctionExpression(decl)
+    ) {
+      parameters = decl.parameters;
+    }
+
+    if (parameters.length === 0) {
+      return undefined;
+    }
+
+    // Build passing mode for each parameter
+    const passingModes: ("value" | "ref" | "out" | "in")[] = [];
+
+    for (const param of parameters) {
+      let passing: "value" | "ref" | "out" | "in" = "value";
+
+      // Check if parameter type is ref<T>, out<T>, or in<T>
+      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
+        ) {
+          passing = typeName === "in" ? "in" : typeName;
+        }
+      }
+
+      passingModes.push(passing);
+    }
+
+    return passingModes;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Convert call expression
+ */
+export const convertCallExpression = (
+  node: ts.CallExpression,
+  checker: ts.TypeChecker
+): IrCallExpression => {
+  // Extract type arguments from the call signature
+  const typeArguments = extractTypeArguments(node, checker);
+  const requiresSpecialization = checkIfRequiresSpecialization(node, checker);
+  const argumentPassing = extractArgumentPassing(node, checker);
+
+  return {
+    kind: "call",
+    callee: convertExpression(node.expression, checker),
+    arguments: node.arguments.map((arg) => {
+      if (ts.isSpreadElement(arg)) {
+        return {
+          kind: "spread" as const,
+          expression: convertExpression(arg.expression, checker),
+        };
+      }
+      return convertExpression(arg, checker);
+    }),
+    isOptional: node.questionDotToken !== undefined,
+    inferredType: getInferredType(node, checker),
+    typeArguments,
+    requiresSpecialization,
+    argumentPassing,
+  };
+};
+
+/**
+ * Convert new expression
+ */
+export const convertNewExpression = (
+  node: ts.NewExpression,
+  checker: ts.TypeChecker
+): IrNewExpression => {
+  // Extract type arguments from the constructor signature
+  const typeArguments = extractTypeArguments(node, checker);
+  const requiresSpecialization = checkIfRequiresSpecialization(node, checker);
+
+  return {
+    kind: "new",
+    callee: convertExpression(node.expression, checker),
+    arguments:
+      node.arguments?.map((arg) => {
+        if (ts.isSpreadElement(arg)) {
+          return {
+            kind: "spread" as const,
+            expression: convertExpression(arg.expression, checker),
+          };
+        }
+        return convertExpression(arg, checker);
+      }) ?? [],
+    inferredType: getInferredType(node, checker),
+    typeArguments,
+    requiresSpecialization,
+  };
+};

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

@@ -0,0 +1,84 @@
+/**
+ * Collection expression converters (arrays and objects)
+ */
+
+import * as ts from "typescript";
+import {
+  IrArrayExpression,
+  IrObjectExpression,
+  IrObjectProperty,
+} from "../../types.js";
+import { getInferredType, getContextualType } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+
+/**
+ * Convert array literal expression
+ */
+export const convertArrayLiteral = (
+  node: ts.ArrayLiteralExpression,
+  checker: ts.TypeChecker
+): IrArrayExpression => {
+  return {
+    kind: "array",
+    elements: node.elements.map((elem) => {
+      if (ts.isOmittedExpression(elem)) {
+        return undefined; // Hole in sparse array
+      }
+      if (ts.isSpreadElement(elem)) {
+        return {
+          kind: "spread" as const,
+          expression: convertExpression(elem.expression, checker),
+        };
+      }
+      return convertExpression(elem, checker);
+    }),
+    inferredType: getInferredType(node, checker),
+  };
+};
+
+/**
+ * Convert object literal expression
+ */
+export const convertObjectLiteral = (
+  node: ts.ObjectLiteralExpression,
+  checker: ts.TypeChecker
+): IrObjectExpression => {
+  const properties: IrObjectProperty[] = [];
+
+  node.properties.forEach((prop) => {
+    if (ts.isPropertyAssignment(prop)) {
+      const key = ts.isComputedPropertyName(prop.name)
+        ? convertExpression(prop.name.expression, checker)
+        : ts.isIdentifier(prop.name)
+          ? prop.name.text
+          : String(prop.name.text);
+
+      properties.push({
+        kind: "property",
+        key,
+        value: convertExpression(prop.initializer, checker),
+        shorthand: false,
+      });
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      properties.push({
+        kind: "property",
+        key: prop.name.text,
+        value: { kind: "identifier", name: prop.name.text },
+        shorthand: true,
+      });
+    } else if (ts.isSpreadAssignment(prop)) {
+      properties.push({
+        kind: "spread",
+        expression: convertExpression(prop.expression, checker),
+      });
+    }
+    // Skip getters/setters/methods for now (can add later if needed)
+  });
+
+  return {
+    kind: "object",
+    properties,
+    inferredType: getInferredType(node, checker),
+    contextualType: getContextualType(node, checker),
+  };
+};

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

@@ -0,0 +1,62 @@
+/**
+ * Function expression converters (function expressions and arrow functions)
+ */
+
+import * as ts from "typescript";
+import {
+  IrFunctionExpression,
+  IrArrowFunctionExpression,
+} from "../../types.js";
+import { getInferredType } from "./helpers.js";
+import { convertExpression } from "../../expression-converter.js";
+import {
+  convertParameters,
+  convertBlockStatement,
+} from "../../statement-converter.js";
+import { convertType } from "../../type-converter.js";
+
+/**
+ * Convert function expression
+ */
+export const convertFunctionExpression = (
+  node: ts.FunctionExpression,
+  checker: ts.TypeChecker
+): IrFunctionExpression => {
+  return {
+    kind: "functionExpression",
+    name: node.name?.text,
+    parameters: convertParameters(node.parameters, checker),
+    returnType: node.type ? convertType(node.type, checker) : undefined,
+    body: node.body
+      ? convertBlockStatement(node.body, checker)
+      : { kind: "blockStatement", statements: [] },
+    isAsync: !!node.modifiers?.some(
+      (m) => m.kind === ts.SyntaxKind.AsyncKeyword
+    ),
+    isGenerator: !!node.asteriskToken,
+    inferredType: getInferredType(node, checker),
+  };
+};
+
+/**
+ * Convert arrow function expression
+ */
+export const convertArrowFunction = (
+  node: ts.ArrowFunction,
+  checker: ts.TypeChecker
+): IrArrowFunctionExpression => {
+  const body = ts.isBlock(node.body)
+    ? convertBlockStatement(node.body, checker)
+    : convertExpression(node.body, checker);
+
+  return {
+    kind: "arrowFunction",
+    parameters: convertParameters(node.parameters, checker),
+    returnType: node.type ? convertType(node.type, checker) : undefined,
+    body,
+    isAsync: !!node.modifiers?.some(
+      (m) => m.kind === ts.SyntaxKind.AsyncKeyword
+    ),
+    inferredType: getInferredType(node, checker),
+  };
+};

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

@@ -0,0 +1,264 @@
+/**
+ * Helper functions for expression conversion
+ */
+
+import * as ts from "typescript";
+import { IrType } from "../../types.js";
+import { convertType, convertTsTypeToIr } from "../../type-converter.js";
+
+/**
+ * Helper to get inferred type from TypeScript node
+ * Prefers contextual type (from assignment target, return position, etc.)
+ * over literal type to handle cases like empty arrays `[]` correctly.
+ */
+export const getInferredType = (
+  node: ts.Node,
+  checker: ts.TypeChecker
+): IrType | undefined => {
+  try {
+    // Try contextual type first (from assignment target, parameter, return, etc.)
+    // This is essential for empty arrays: [] has literal type never[] but contextual
+    // type Player[] when assigned to a Player[] variable
+    const expr = ts.isExpression(node) ? node : undefined;
+    const contextualType = expr ? checker.getContextualType(expr) : undefined;
+    const tsType = contextualType ?? checker.getTypeAtLocation(node);
+
+    const typeNode = checker.typeToTypeNode(
+      tsType,
+      node,
+      ts.NodeBuilderFlags.None
+    );
+    return typeNode ? convertType(typeNode, checker) : undefined;
+  } catch {
+    // If type extraction fails, return undefined
+    return undefined;
+  }
+};
+
+/**
+ * Extract type arguments from a call or new expression
+ * This captures both explicit type arguments and inferred ones
+ */
+export const extractTypeArguments = (
+  node: ts.CallExpression | ts.NewExpression,
+  checker: ts.TypeChecker
+): readonly IrType[] | undefined => {
+  try {
+    // First check for explicit type arguments
+    if (node.typeArguments && node.typeArguments.length > 0) {
+      return node.typeArguments.map((typeArg) => convertType(typeArg, checker));
+    }
+
+    // Try to get inferred type arguments from resolved signature
+    const signature = checker.getResolvedSignature(node);
+    if (!signature) {
+      return undefined;
+    }
+
+    const typeParameters = signature.typeParameters;
+    if (!typeParameters || typeParameters.length === 0) {
+      return undefined;
+    }
+
+    // Get the type arguments inferred by the checker
+    const typeArgs: IrType[] = [];
+    for (const typeParam of typeParameters) {
+      // Try to resolve the instantiated type for this parameter
+      const typeNode = checker.typeToTypeNode(
+        typeParam as ts.Type,
+        node,
+        ts.NodeBuilderFlags.None
+      );
+      if (typeNode) {
+        typeArgs.push(convertType(typeNode, checker));
+      }
+    }
+
+    return typeArgs.length > 0 ? typeArgs : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * Check if a call/new expression requires specialization
+ * Returns true for conditional types, infer, variadic generics, this typing
+ */
+export const checkIfRequiresSpecialization = (
+  node: ts.CallExpression | ts.NewExpression,
+  checker: ts.TypeChecker
+): boolean => {
+  try {
+    const signature = checker.getResolvedSignature(node);
+    if (!signature || !signature.declaration) {
+      return false;
+    }
+
+    const decl = signature.declaration;
+
+    // Check for conditional return types
+    if (
+      ts.isFunctionDeclaration(decl) ||
+      ts.isMethodDeclaration(decl) ||
+      ts.isFunctionTypeNode(decl)
+    ) {
+      if (decl.type && ts.isConditionalTypeNode(decl.type)) {
+        return true;
+      }
+    }
+
+    // Check for variadic type parameters (rest parameters with generic types)
+    const typeParameters = signature.typeParameters;
+    if (typeParameters) {
+      for (const typeParam of typeParameters) {
+        const constraint = typeParam.getConstraint();
+        if (constraint) {
+          const constraintStr = checker.typeToString(constraint);
+          // Check for unknown[] which indicates variadic
+          if (
+            constraintStr.includes("unknown[]") ||
+            constraintStr.includes("any[]")
+          ) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Convert TypeScript binary operator token to string
+ */
+export const convertBinaryOperator = (
+  token: ts.BinaryOperatorToken
+): string => {
+  const operatorMap: Record<number, string> = {
+    [ts.SyntaxKind.PlusToken]: "+",
+    [ts.SyntaxKind.MinusToken]: "-",
+    [ts.SyntaxKind.AsteriskToken]: "*",
+    [ts.SyntaxKind.SlashToken]: "/",
+    [ts.SyntaxKind.PercentToken]: "%",
+    [ts.SyntaxKind.AsteriskAsteriskToken]: "**",
+    [ts.SyntaxKind.EqualsEqualsToken]: "==",
+    [ts.SyntaxKind.ExclamationEqualsToken]: "!=",
+    [ts.SyntaxKind.EqualsEqualsEqualsToken]: "===",
+    [ts.SyntaxKind.ExclamationEqualsEqualsToken]: "!==",
+    [ts.SyntaxKind.LessThanToken]: "<",
+    [ts.SyntaxKind.GreaterThanToken]: ">",
+    [ts.SyntaxKind.LessThanEqualsToken]: "<=",
+    [ts.SyntaxKind.GreaterThanEqualsToken]: ">=",
+    [ts.SyntaxKind.LessThanLessThanToken]: "<<",
+    [ts.SyntaxKind.GreaterThanGreaterThanToken]: ">>",
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: ">>>",
+    [ts.SyntaxKind.AmpersandToken]: "&",
+    [ts.SyntaxKind.BarToken]: "|",
+    [ts.SyntaxKind.CaretToken]: "^",
+    [ts.SyntaxKind.AmpersandAmpersandToken]: "&&",
+    [ts.SyntaxKind.BarBarToken]: "||",
+    [ts.SyntaxKind.QuestionQuestionToken]: "??",
+    [ts.SyntaxKind.InKeyword]: "in",
+    [ts.SyntaxKind.InstanceOfKeyword]: "instanceof",
+    [ts.SyntaxKind.EqualsToken]: "=",
+    [ts.SyntaxKind.PlusEqualsToken]: "+=",
+    [ts.SyntaxKind.MinusEqualsToken]: "-=",
+    [ts.SyntaxKind.AsteriskEqualsToken]: "*=",
+    [ts.SyntaxKind.SlashEqualsToken]: "/=",
+    [ts.SyntaxKind.PercentEqualsToken]: "%=",
+    [ts.SyntaxKind.AsteriskAsteriskEqualsToken]: "**=",
+    [ts.SyntaxKind.LessThanLessThanEqualsToken]: "<<=",
+    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken]: ">>=",
+    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: ">>>=",
+    [ts.SyntaxKind.AmpersandEqualsToken]: "&=",
+    [ts.SyntaxKind.BarEqualsToken]: "|=",
+    [ts.SyntaxKind.CaretEqualsToken]: "^=",
+    [ts.SyntaxKind.AmpersandAmpersandEqualsToken]: "&&=",
+    [ts.SyntaxKind.BarBarEqualsToken]: "||=",
+    [ts.SyntaxKind.QuestionQuestionEqualsToken]: "??=",
+  };
+
+  return operatorMap[token.kind] ?? "=";
+};
+
+/**
+ * Check if a binary operator token is an assignment operator
+ */
+export const isAssignmentOperator = (
+  token: ts.BinaryOperatorToken
+): boolean => {
+  return (
+    token.kind >= ts.SyntaxKind.FirstAssignment &&
+    token.kind <= ts.SyntaxKind.LastAssignment
+  );
+};
+
+/**
+ * Get the contextual type for an expression (for object literals).
+ * Returns an IrType with type arguments if the contextual type is a named type
+ * (interface, class, generic), or undefined if it's an anonymous/primitive type.
+ *
+ * This captures the full type including generic type arguments (e.g., Container<T>),
+ * which is essential for emitting correct C# object initializers.
+ */
+export const getContextualType = (
+  node: ts.Expression,
+  checker: ts.TypeChecker
+): IrType | undefined => {
+  try {
+    const contextualType = checker.getContextualType(node);
+    if (!contextualType) {
+      return undefined;
+    }
+
+    // Check if it's an object type with a symbol (named type)
+    const symbol = contextualType.getSymbol();
+    if (!symbol) {
+      return undefined;
+    }
+
+    // Get the symbol name
+    const name = symbol.getName();
+
+    // Skip anonymous types and built-in types
+    if (name === "__type" || name === "__object" || name === "Object") {
+      return undefined;
+    }
+
+    // Check that it's actually a class or interface declaration
+    const declarations = symbol.getDeclarations();
+    if (declarations && declarations.length > 0) {
+      const firstDecl = declarations[0];
+      if (
+        firstDecl &&
+        (ts.isInterfaceDeclaration(firstDecl) ||
+          ts.isClassDeclaration(firstDecl) ||
+          ts.isTypeAliasDeclaration(firstDecl))
+      ) {
+        // Convert the full contextual type to IR, capturing type arguments
+        return convertTsTypeToIr(contextualType, checker);
+      }
+    }
+
+    return undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * @deprecated Use getContextualType instead - returns IrType with type arguments
+ */
+export const getContextualTypeName = (
+  node: ts.Expression,
+  checker: ts.TypeChecker
+): string | undefined => {
+  const irType = getContextualType(node, checker);
+  if (irType && irType.kind === "referenceType") {
+    return irType.name;
+  }
+  return undefined;
+};

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

@@ -0,0 +1,43 @@
+/**
+ * Expression converters barrel exports
+ */
+
+// Helpers
+export {
+  getInferredType,
+  extractTypeArguments,
+  checkIfRequiresSpecialization,
+  convertBinaryOperator,
+  isAssignmentOperator,
+} from "./helpers.js";
+
+// Literals
+export { convertLiteral } from "./literals.js";
+
+// Collections
+export { convertArrayLiteral, convertObjectLiteral } from "./collections.js";
+
+// Member access
+export { convertMemberExpression } from "./access.js";
+
+// Calls
+export { convertCallExpression, convertNewExpression } from "./calls.js";
+
+// Operators
+export {
+  convertBinaryExpression,
+  convertUnaryExpression,
+  convertUpdateExpression,
+} from "./operators.js";
+
+// Functions
+export {
+  convertFunctionExpression,
+  convertArrowFunction,
+} from "./functions.js";
+
+// Other
+export {
+  convertConditionalExpression,
+  convertTemplateLiteral,
+} from "./other.js";

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

@@ -0,0 +1,22 @@
+/**
+ * Literal expression converters
+ */
+
+import * as ts from "typescript";
+import { IrLiteralExpression } from "../../types.js";
+import { getInferredType } from "./helpers.js";
+
+/**
+ * Convert string or numeric literal
+ */
+export const convertLiteral = (
+  node: ts.StringLiteral | ts.NumericLiteral,
+  checker: ts.TypeChecker
+): IrLiteralExpression => {
+  return {
+    kind: "literal",
+    value: ts.isStringLiteral(node) ? node.text : Number(node.text),
+    raw: node.getText(),
+    inferredType: getInferredType(node, checker),
+  };
+};