@tsonic/frontend 0.0.1 → 0.0.2

package/src/ir/statement-converter.ts

@@ -1,128 +0,0 @@
-/**
- * Statement converter - TypeScript AST to IR statements
- * Main dispatcher - delegates to specialized modules
- */
-
-import * as ts from "typescript";
-import { IrStatement } from "./types.js";
-import { convertExpression } from "./expression-converter.js";
-
-// Import converters from specialized modules
-import {
-  convertVariableStatement,
-  convertFunctionDeclaration,
-  convertClassDeclaration,
-  convertInterfaceDeclaration,
-  convertEnumDeclaration,
-  convertTypeAliasDeclaration,
-} from "./converters/statements/declarations.js";
-
-import {
-  convertIfStatement,
-  convertWhileStatement,
-  convertForStatement,
-  convertForOfStatement,
-  convertForInStatement,
-  convertSwitchStatement,
-  convertTryStatement,
-  convertBlockStatement,
-} from "./converters/statements/control.js";
-
-/**
- * Main statement converter dispatcher
- */
-export const convertStatement = (
-  node: ts.Node,
-  checker: ts.TypeChecker
-): IrStatement | null => {
-  if (ts.isVariableStatement(node)) {
-    return convertVariableStatement(node, checker);
-  }
-  if (ts.isFunctionDeclaration(node)) {
-    return convertFunctionDeclaration(node, checker);
-  }
-  if (ts.isClassDeclaration(node)) {
-    return convertClassDeclaration(node, checker);
-  }
-  if (ts.isInterfaceDeclaration(node)) {
-    return convertInterfaceDeclaration(node, checker);
-  }
-  if (ts.isEnumDeclaration(node)) {
-    return convertEnumDeclaration(node, checker);
-  }
-  if (ts.isTypeAliasDeclaration(node)) {
-    return convertTypeAliasDeclaration(node, checker);
-  }
-  if (ts.isExpressionStatement(node)) {
-    return {
-      kind: "expressionStatement",
-      expression: convertExpression(node.expression, checker),
-    };
-  }
-  if (ts.isReturnStatement(node)) {
-    return {
-      kind: "returnStatement",
-      expression: node.expression
-        ? convertExpression(node.expression, checker)
-        : undefined,
-    };
-  }
-  if (ts.isIfStatement(node)) {
-    return convertIfStatement(node, checker);
-  }
-  if (ts.isWhileStatement(node)) {
-    return convertWhileStatement(node, checker);
-  }
-  if (ts.isForStatement(node)) {
-    return convertForStatement(node, checker);
-  }
-  if (ts.isForOfStatement(node)) {
-    return convertForOfStatement(node, checker);
-  }
-  if (ts.isForInStatement(node)) {
-    return convertForInStatement(node, checker);
-  }
-  if (ts.isSwitchStatement(node)) {
-    return convertSwitchStatement(node, checker);
-  }
-  if (ts.isThrowStatement(node)) {
-    if (!node.expression) {
-      return null;
-    }
-    return {
-      kind: "throwStatement",
-      expression: convertExpression(node.expression, checker),
-    };
-  }
-  if (ts.isTryStatement(node)) {
-    return convertTryStatement(node, checker);
-  }
-  if (ts.isBlock(node)) {
-    return convertBlockStatement(node, checker);
-  }
-  if (ts.isBreakStatement(node)) {
-    return {
-      kind: "breakStatement",
-      label: node.label?.text,
-    };
-  }
-  if (ts.isContinueStatement(node)) {
-    return {
-      kind: "continueStatement",
-      label: node.label?.text,
-    };
-  }
-  if (ts.isEmptyStatement(node)) {
-    return { kind: "emptyStatement" };
-  }
-
-  return null;
-};
-
-// Re-export commonly used functions for backward compatibility
-export { convertBlockStatement } from "./converters/statements/control.js";
-export { convertParameters } from "./converters/statements/helpers.js";
-export {
-  setMetadataRegistry,
-  setBindingRegistry,
-} from "./converters/statements/declarations.js";

package/src/ir/type-converter/arrays.ts

@@ -1,20 +0,0 @@
-/**
- * Array type conversion
- */
-
-import * as ts from "typescript";
-import { IrType } from "../types.js";
-
-/**
- * Convert TypeScript array type to IR array type
- */
-export const convertArrayType = (
-  node: ts.ArrayTypeNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrType => {
-  return {
-    kind: "arrayType",
-    elementType: convertType(node.elementType, checker),
-  };
-};

package/src/ir/type-converter/converter.ts

@@ -1,10 +0,0 @@
-/**
- * Type converter - TypeScript types to IR types
- * Main dispatcher - re-exports from orchestrator
- */
-
-export {
-  convertType,
-  convertFunctionType,
-  convertObjectType,
-} from "./orchestrator.js";

package/src/ir/type-converter/functions.ts

@@ -1,22 +0,0 @@
-/**
- * Function type conversion
- */
-
-import * as ts from "typescript";
-import { IrType, IrFunctionType } from "../types.js";
-import { convertParameters as convertParametersFromStatement } from "../statement-converter.js";
-
-/**
- * Convert TypeScript function type to IR function type
- */
-export const convertFunctionType = (
-  node: ts.FunctionTypeNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrFunctionType => {
-  return {
-    kind: "functionType",
-    parameters: convertParametersFromStatement(node.parameters, checker),
-    returnType: convertType(node.type, checker),
-  };
-};

package/src/ir/type-converter/inference.ts

@@ -1,122 +0,0 @@
-/**
- * Type inference - Converts TypeScript inferred types to IR types
- *
- * This uses the TypeChecker to get the inferred type and converts it to IR.
- * Used for declarations without explicit type annotations where the type
- * must be inferred from the initializer.
- */
-
-import * as ts from "typescript";
-import type { IrType } from "../types.js";
-
-/**
- * Infer IR type from a declaration node using the TypeChecker.
- * Returns undefined for complex types that cannot be easily represented.
- */
-export const inferType = (
-  node: ts.VariableDeclaration | ts.PropertyDeclaration,
-  checker: ts.TypeChecker
-): IrType | undefined => {
-  const type = checker.getTypeAtLocation(node);
-  return convertTsTypeToIr(type, checker);
-};
-
-/**
- * Convert a TypeScript Type (from checker) to IR type.
- * This is different from convertType which takes a TypeNode (syntax).
- */
-export const convertTsTypeToIr = (
-  type: ts.Type,
-  checker: ts.TypeChecker
-): IrType | undefined => {
-  const flags = type.flags;
-
-  // Primitives
-  if (flags & ts.TypeFlags.Number || flags & ts.TypeFlags.NumberLiteral) {
-    return { kind: "primitiveType", name: "number" };
-  }
-  if (flags & ts.TypeFlags.String || flags & ts.TypeFlags.StringLiteral) {
-    return { kind: "primitiveType", name: "string" };
-  }
-  if (flags & ts.TypeFlags.Boolean || flags & ts.TypeFlags.BooleanLiteral) {
-    return { kind: "primitiveType", name: "boolean" };
-  }
-  if (flags & ts.TypeFlags.Void) {
-    return { kind: "voidType" };
-  }
-  if (flags & ts.TypeFlags.Null) {
-    return { kind: "primitiveType", name: "null" };
-  }
-  if (flags & ts.TypeFlags.Undefined) {
-    return { kind: "primitiveType", name: "undefined" };
-  }
-
-  // Object type - check if it's an array
-  if (flags & ts.TypeFlags.Object) {
-    // Check for array type
-    if (checker.isArrayType(type)) {
-      const typeArgs = checker.getTypeArguments(type as ts.TypeReference);
-      if (typeArgs.length > 0) {
-        const elementType = convertTsTypeToIr(typeArgs[0]!, checker);
-        if (elementType) {
-          return { kind: "arrayType", elementType };
-        }
-      }
-      return { kind: "arrayType", elementType: { kind: "anyType" } };
-    }
-
-    // Check for callable signatures (function types)
-    const callSignatures = type.getCallSignatures();
-    if (callSignatures.length > 0) {
-      // Function types need complex handling - return undefined for now
-      return undefined;
-    }
-
-    // Check for symbol with name (class, interface, etc.)
-    const objectType = type as ts.ObjectType;
-    if (objectType.symbol) {
-      const name = objectType.symbol.name;
-      // Skip internal TypeScript symbol names
-      if (name.startsWith("__")) {
-        return undefined;
-      }
-      // For named types, return as reference type with type arguments if generic
-      if (name && name !== "Object" && name !== "Array") {
-        // Extract type arguments for generic types
-        const typeRef = type as ts.TypeReference;
-        const typeArgs = checker.getTypeArguments(typeRef);
-        if (typeArgs && typeArgs.length > 0) {
-          const irTypeArgs = typeArgs
-            .map((arg) => convertTsTypeToIr(arg, checker))
-            .filter((t): t is IrType => t !== undefined);
-          if (irTypeArgs.length === typeArgs.length) {
-            return { kind: "referenceType", name, typeArguments: irTypeArgs };
-          }
-        }
-        return { kind: "referenceType", name };
-      }
-    }
-
-    // Anonymous object type
-    return undefined;
-  }
-
-  // Type parameters (e.g., T in Container<T>)
-  if (flags & ts.TypeFlags.TypeParameter) {
-    const typeParam = type as ts.TypeParameter;
-    const name = typeParam.symbol?.name ?? "T";
-    return { kind: "referenceType", name };
-  }
-
-  // Any and unknown
-  if (flags & ts.TypeFlags.Any || flags & ts.TypeFlags.Unknown) {
-    return { kind: "anyType" };
-  }
-
-  // Union and intersection types - too complex for simple inference
-  if (flags & ts.TypeFlags.Union || flags & ts.TypeFlags.Intersection) {
-    return undefined;
-  }
-
-  return undefined;
-};

package/src/ir/type-converter/literals.ts

@@ -1,40 +0,0 @@
-/**
- * Literal type conversion
- */
-
-import * as ts from "typescript";
-import { IrType } from "../types.js";
-
-/**
- * Convert TypeScript literal type to IR literal type
- */
-export const convertLiteralType = (node: ts.LiteralTypeNode): IrType => {
-  const literal = node.literal;
-
-  if (ts.isStringLiteral(literal)) {
-    return { kind: "literalType", value: literal.text };
-  }
-
-  if (ts.isNumericLiteral(literal)) {
-    return { kind: "literalType", value: Number(literal.text) };
-  }
-
-  if (literal.kind === ts.SyntaxKind.TrueKeyword) {
-    return { kind: "literalType", value: true };
-  }
-
-  if (literal.kind === ts.SyntaxKind.FalseKeyword) {
-    return { kind: "literalType", value: false };
-  }
-
-  if (literal.kind === ts.SyntaxKind.NullKeyword) {
-    return { kind: "primitiveType", name: "null" };
-  }
-
-  if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {
-    return { kind: "primitiveType", name: "undefined" };
-  }
-
-  // Fallback
-  return { kind: "anyType" };
-};

package/src/ir/type-converter/objects.ts

@@ -1,107 +0,0 @@
-/**
- * Object/interface type conversion
- */
-
-import * as ts from "typescript";
-import {
-  IrType,
-  IrObjectType,
-  IrDictionaryType,
-  IrInterfaceMember,
-  IrPropertySignature,
-  IrMethodSignature,
-} from "../types.js";
-import { convertParameters as convertParametersFromStatement } from "../statement-converter.js";
-
-/**
- * Convert TypeScript object literal type to IR type.
- *
- * Returns IrDictionaryType for pure index signature types like:
- * - `{ [k: string]: T }`
- * - `{ [k: number]: T }`
- *
- * Returns IrObjectType for regular object types with named members.
- */
-export const convertObjectType = (
-  node: ts.TypeLiteralNode,
-  checker: ts.TypeChecker,
-  convertType: (node: ts.TypeNode, checker: ts.TypeChecker) => IrType
-): IrObjectType | IrDictionaryType => {
-  // Check for pure index signature type (no other members)
-  const indexSignatures = node.members.filter(ts.isIndexSignatureDeclaration);
-  const otherMembers = node.members.filter(
-    (m) => !ts.isIndexSignatureDeclaration(m)
-  );
-
-  // If ONLY index signature(s) exist, convert to dictionary type
-  if (indexSignatures.length > 0 && otherMembers.length === 0) {
-    // Use the first index signature (TypeScript allows multiple, but we take first)
-    const indexSig = indexSignatures[0]!;
-    const keyParam = indexSig.parameters[0];
-
-    // Determine key type from parameter type
-    const keyType: IrType = keyParam?.type
-      ? convertKeyType(keyParam.type)
-      : { kind: "primitiveType", name: "string" };
-
-    // Determine value type
-    const valueType: IrType = indexSig.type
-      ? convertType(indexSig.type, checker)
-      : { kind: "anyType" };
-
-    return {
-      kind: "dictionaryType",
-      keyType,
-      valueType,
-    };
-  }
-
-  // Regular object type with named members
-  const members: IrInterfaceMember[] = [];
-
-  node.members.forEach((member) => {
-    if (ts.isPropertySignature(member) && member.type) {
-      const propSig: IrPropertySignature = {
-        kind: "propertySignature",
-        name:
-          member.name && ts.isIdentifier(member.name)
-            ? member.name.text
-            : "[computed]",
-        type: convertType(member.type, checker),
-        isOptional: !!member.questionToken,
-        isReadonly: !!member.modifiers?.some(
-          (m) => m.kind === ts.SyntaxKind.ReadonlyKeyword
-        ),
-      };
-      members.push(propSig);
-    } else if (ts.isMethodSignature(member)) {
-      const methSig: IrMethodSignature = {
-        kind: "methodSignature",
-        name:
-          member.name && ts.isIdentifier(member.name)
-            ? member.name.text
-            : "[computed]",
-        parameters: convertParametersFromStatement(member.parameters, checker),
-        returnType: member.type ? convertType(member.type, checker) : undefined,
-      };
-      members.push(methSig);
-    }
-  });
-
-  return { kind: "objectType", members };
-};
-
-/**
- * Convert index signature key type to IR type.
- * Only string and number are valid as index signature keys.
- */
-const convertKeyType = (typeNode: ts.TypeNode): IrType => {
-  if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
-    return { kind: "primitiveType", name: "string" };
-  }
-  if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
-    return { kind: "primitiveType", name: "number" };
-  }
-  // Fallback to string for other cases
-  return { kind: "primitiveType", name: "string" };
-};

package/src/ir/type-converter/orchestrator.ts

@@ -1,85 +0,0 @@
-/**
- * Type conversion orchestrator
- */
-
-import * as ts from "typescript";
-import {
-  IrType,
-  IrFunctionType,
-  IrObjectType,
-  IrDictionaryType,
-} from "../types.js";
-import { convertPrimitiveKeyword } from "./primitives.js";
-import { convertTypeReference } from "./references.js";
-import { convertArrayType } from "./arrays.js";
-import { convertFunctionType } from "./functions.js";
-import { convertObjectType } from "./objects.js";
-import {
-  convertUnionType,
-  convertIntersectionType,
-} from "./unions-intersections.js";
-import { convertLiteralType } from "./literals.js";
-
-/**
- * Convert TypeScript type node to IR type
- */
-export const convertType = (
-  typeNode: ts.TypeNode,
-  checker: ts.TypeChecker
-): IrType => {
-  // Type references (including primitive type names)
-  if (ts.isTypeReferenceNode(typeNode)) {
-    return convertTypeReference(typeNode, checker, convertType);
-  }
-
-  // Primitive keywords
-  const primitiveType = convertPrimitiveKeyword(typeNode.kind);
-  if (primitiveType) {
-    return primitiveType;
-  }
-
-  // Array types
-  if (ts.isArrayTypeNode(typeNode)) {
-    return convertArrayType(typeNode, checker, convertType);
-  }
-
-  // Function types
-  if (ts.isFunctionTypeNode(typeNode)) {
-    return convertFunctionType(typeNode, checker, convertType);
-  }
-
-  // Object/interface types
-  if (ts.isTypeLiteralNode(typeNode)) {
-    return convertObjectType(typeNode, checker, convertType);
-  }
-
-  // Union types
-  if (ts.isUnionTypeNode(typeNode)) {
-    return convertUnionType(typeNode, checker, convertType);
-  }
-
-  // Intersection types
-  if (ts.isIntersectionTypeNode(typeNode)) {
-    return convertIntersectionType(typeNode, checker, convertType);
-  }
-
-  // Literal types
-  if (ts.isLiteralTypeNode(typeNode)) {
-    return convertLiteralType(typeNode);
-  }
-
-  // Parenthesized types
-  if (ts.isParenthesizedTypeNode(typeNode)) {
-    return convertType(typeNode.type, checker);
-  }
-
-  // Default to any type for unsupported types
-  return { kind: "anyType" };
-};
-
-// Re-export specialized converters for backward compatibility
-export { convertFunctionType } from "./functions.js";
-export { convertObjectType } from "./objects.js";
-
-// Export types
-export type { IrFunctionType, IrObjectType, IrDictionaryType };

package/src/ir/type-converter/patterns.ts

@@ -1,73 +0,0 @@
-/**
- * Binding pattern converter - TypeScript patterns to IR patterns
- */
-
-import * as ts from "typescript";
-import { IrPattern, IrObjectPatternProperty } from "../types.js";
-
-/**
- * Convert TypeScript binding name to IR pattern
- */
-export const convertBindingName = (name: ts.BindingName): IrPattern => {
-  if (ts.isIdentifier(name)) {
-    return {
-      kind: "identifierPattern",
-      name: name.text,
-    };
-  }
-
-  if (ts.isArrayBindingPattern(name)) {
-    return {
-      kind: "arrayPattern",
-      elements: name.elements.map((elem) => {
-        if (ts.isOmittedExpression(elem)) {
-          return undefined; // Hole in array pattern
-        }
-        if (ts.isBindingElement(elem)) {
-          return convertBindingName(elem.name);
-        }
-        return undefined;
-      }),
-    };
-  }
-
-  if (ts.isObjectBindingPattern(name)) {
-    const properties: IrObjectPatternProperty[] = [];
-
-    name.elements.forEach((elem) => {
-      if (elem.dotDotDotToken) {
-        // Rest property
-        properties.push({
-          kind: "rest",
-          pattern: convertBindingName(elem.name),
-        });
-      } else {
-        const key = elem.propertyName
-          ? ts.isIdentifier(elem.propertyName)
-            ? elem.propertyName.text
-            : elem.propertyName.getText()
-          : ts.isIdentifier(elem.name)
-            ? elem.name.text
-            : "[computed]";
-
-        properties.push({
-          kind: "property",
-          key,
-          value: convertBindingName(elem.name),
-          shorthand: !elem.propertyName,
-        });
-      }
-    });
-
-    return {
-      kind: "objectPattern",
-      properties,
-    };
-  }
-
-  // Default to identifier pattern (should not reach here normally)
-  return {
-    kind: "identifierPattern",
-    name: "_unknown",
-  };
-};

package/src/ir/type-converter/primitives.ts

@@ -1,57 +0,0 @@
-/**
- * Primitive type conversion
- */
-
-import * as ts from "typescript";
-import { IrType } from "../types.js";
-
-/**
- * Convert TypeScript primitive keyword to IR type
- */
-export const convertPrimitiveKeyword = (kind: ts.SyntaxKind): IrType | null => {
-  switch (kind) {
-    case ts.SyntaxKind.StringKeyword:
-      return { kind: "primitiveType", name: "string" };
-    case ts.SyntaxKind.NumberKeyword:
-      return { kind: "primitiveType", name: "number" };
-    case ts.SyntaxKind.BooleanKeyword:
-      return { kind: "primitiveType", name: "boolean" };
-    case ts.SyntaxKind.NullKeyword:
-      return { kind: "primitiveType", name: "null" };
-    case ts.SyntaxKind.UndefinedKeyword:
-      return { kind: "primitiveType", name: "undefined" };
-    case ts.SyntaxKind.VoidKeyword:
-      return { kind: "voidType" };
-    case ts.SyntaxKind.AnyKeyword:
-      return { kind: "anyType" };
-    case ts.SyntaxKind.UnknownKeyword:
-      return { kind: "unknownType" };
-    case ts.SyntaxKind.NeverKeyword:
-      return { kind: "neverType" };
-    default:
-      return null;
-  }
-};
-
-/**
- * Check if a type name is a primitive type
- */
-export const isPrimitiveTypeName = (
-  typeName: string
-): typeName is "string" | "number" | "boolean" | "null" | "undefined" => {
-  return ["string", "number", "boolean", "null", "undefined"].includes(
-    typeName
-  );
-};
-
-/**
- * Get primitive type IR representation for a type name
- */
-export const getPrimitiveType = (
-  typeName: "string" | "number" | "boolean" | "null" | "undefined"
-): IrType => {
-  return {
-    kind: "primitiveType",
-    name: typeName,
-  };
-};