@tsonic/frontend 0.0.1 → 0.0.2

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

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

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

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

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

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

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