@tsonic/frontend 0.0.1 → 0.0.2

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

@@ -1,166 +0,0 @@
-/**
- * Class declaration conversion orchestrator
- */
-
-import * as ts from "typescript";
-import { IrClassDeclaration, IrClassMember } from "../../../../types.js";
-import { convertExpression } from "../../../../expression-converter.js";
-import { convertType } from "../../../../type-converter.js";
-import { hasExportModifier, convertTypeParameters } from "../../helpers.js";
-import { convertProperty } from "./properties.js";
-import { convertMethod } from "./methods.js";
-import {
-  convertConstructor,
-  extractParameterProperties,
-} from "./constructors.js";
-
-/**
- * Convert a single class member
- */
-const convertClassMember = (
-  node: ts.ClassElement,
-  checker: ts.TypeChecker,
-  superClass: ts.ExpressionWithTypeArguments | undefined,
-  constructorParams?: ts.NodeArray<ts.ParameterDeclaration>
-): IrClassMember | null => {
-  if (ts.isPropertyDeclaration(node)) {
-    return convertProperty(node, checker, superClass);
-  }
-
-  if (ts.isMethodDeclaration(node)) {
-    return convertMethod(node, checker, superClass);
-  }
-
-  if (ts.isConstructorDeclaration(node)) {
-    return convertConstructor(node, checker, constructorParams);
-  }
-
-  return null;
-};
-
-/**
- * Filter members to only include those declared directly on this class
- */
-const filterOwnMembers = (
-  node: ts.ClassDeclaration,
-  checker: ts.TypeChecker
-): readonly ts.ClassElement[] => {
-  return node.members.filter((m) => {
-    // Always include constructors and methods declared on this class
-    if (ts.isConstructorDeclaration(m) || ts.isMethodDeclaration(m)) {
-      return true;
-    }
-    // For properties, only include if they're declared directly on this class
-    if (ts.isPropertyDeclaration(m)) {
-      // Check if this property has a declaration on this specific class node
-      const symbol = checker.getSymbolAtLocation(m.name);
-      if (!symbol) return true; // Include if we can't determine
-      const declarations = symbol.getDeclarations() || [];
-      // Only include if this exact node is in the declarations
-      return declarations.some((d) => d === m);
-    }
-    return true;
-  });
-};
-
-/**
- * Deduplicate members by name, keeping first occurrence
- */
-const deduplicateMembers = (
-  members: readonly IrClassMember[]
-): readonly IrClassMember[] => {
-  const seenNames = new Set<string>();
-  return members.filter((member) => {
-    if (member.kind === "constructorDeclaration") {
-      return true; // Always include constructor
-    }
-    const name =
-      member.kind === "propertyDeclaration" ||
-      member.kind === "methodDeclaration"
-        ? member.name
-        : null;
-    if (!name) return true;
-    if (seenNames.has(name)) {
-      return false; // Skip duplicate
-    }
-    seenNames.add(name);
-    return true;
-  });
-};
-
-/**
- * Check if a type reference is the struct marker
- */
-const isStructMarker = (
-  typeRef: ts.ExpressionWithTypeArguments,
-  checker: ts.TypeChecker
-): boolean => {
-  const symbol = checker.getSymbolAtLocation(typeRef.expression);
-  return symbol?.escapedName === "struct" || symbol?.escapedName === "Struct";
-};
-
-/**
- * Convert class declaration to IR
- */
-export const convertClassDeclaration = (
-  node: ts.ClassDeclaration,
-  checker: ts.TypeChecker
-): IrClassDeclaration | null => {
-  if (!node.name) return null;
-
-  const superClass = node.heritageClauses?.find(
-    (h) => h.token === ts.SyntaxKind.ExtendsKeyword
-  )?.types[0];
-
-  // Detect struct marker in implements clause
-  let isStruct = false;
-  const implementsClause = node.heritageClauses?.find(
-    (h) => h.token === ts.SyntaxKind.ImplementsKeyword
-  );
-  const implementsTypes =
-    implementsClause?.types
-      .filter((t) => {
-        if (isStructMarker(t, checker)) {
-          isStruct = true;
-          return false; // Remove marker from implements
-        }
-        return true;
-      })
-      .map((t) => convertType(t, checker)) ?? [];
-
-  // Extract parameter properties from constructor
-  const constructor = node.members.find(ts.isConstructorDeclaration);
-  const parameterProperties = extractParameterProperties(constructor, checker);
-
-  // Filter to only include members declared directly on this class (not inherited)
-  const ownMembers = filterOwnMembers(node, checker);
-
-  const convertedMembers = ownMembers
-    .map((m) =>
-      convertClassMember(m, checker, superClass, constructor?.parameters)
-    )
-    .filter((m): m is IrClassMember => m !== null);
-
-  // Deduplicate members by name (keep first occurrence)
-  // Parameter properties should take precedence over regular properties with same name
-  const allMembers = [...parameterProperties, ...convertedMembers];
-  const deduplicatedMembers = deduplicateMembers(allMembers);
-
-  // Filter out __brand property if this is a struct
-  const finalMembers = isStruct
-    ? deduplicatedMembers.filter(
-        (m) => m.kind !== "propertyDeclaration" || m.name !== "__brand"
-      )
-    : deduplicatedMembers;
-
-  return {
-    kind: "classDeclaration",
-    name: node.name.text,
-    typeParameters: convertTypeParameters(node.typeParameters, checker),
-    superClass: superClass ? convertExpression(superClass, checker) : undefined,
-    implements: implementsTypes,
-    members: finalMembers,
-    isExported: hasExportModifier(node),
-    isStruct,
-  };
-};

package/src/ir/converters/statements/declarations/classes/override-detection.ts

@@ -1,116 +0,0 @@
-/**
- * Override detection for class members
- */
-
-import * as ts from "typescript";
-import { getMetadataRegistry } from "../registry.js";
-
-export type OverrideInfo = {
-  readonly isOverride: boolean;
-  readonly isShadow: boolean;
-};
-
-/**
- * Check if a method/property should be marked as override based on base class metadata
- */
-export const detectOverride = (
-  memberName: string,
-  memberKind: "method" | "property",
-  superClass: ts.ExpressionWithTypeArguments | undefined,
-  checker: ts.TypeChecker,
-  parameterTypes?: readonly string[]
-): OverrideInfo => {
-  if (!superClass) {
-    return { isOverride: false, isShadow: false };
-  }
-
-  // Resolve the base class type
-  const baseType = checker.getTypeAtLocation(superClass.expression);
-  const baseSymbol = baseType.getSymbol();
-
-  if (!baseSymbol) {
-    return { isOverride: false, isShadow: false };
-  }
-
-  // Get fully-qualified name for .NET types
-  const qualifiedName = checker.getFullyQualifiedName(baseSymbol);
-
-  // Check if this is a .NET type (starts with "System." or other .NET namespaces)
-  const isDotNetType =
-    qualifiedName.startsWith("System.") ||
-    qualifiedName.startsWith("Microsoft.") ||
-    qualifiedName.startsWith("Tsonic.Runtime.");
-
-  if (isDotNetType) {
-    return detectDotNetOverride(
-      memberName,
-      memberKind,
-      qualifiedName,
-      parameterTypes
-    );
-  } else {
-    return detectTypeScriptOverride(memberName, memberKind, baseSymbol);
-  }
-};
-
-/**
- * Detect override for .NET base classes using metadata
- */
-const detectDotNetOverride = (
-  memberName: string,
-  memberKind: "method" | "property",
-  qualifiedName: string,
-  parameterTypes?: readonly string[]
-): OverrideInfo => {
-  const metadata = getMetadataRegistry();
-
-  if (memberKind === "method" && parameterTypes) {
-    const signature = `${memberName}(${parameterTypes.join(",")})`;
-    const isVirtual = metadata.isVirtualMember(qualifiedName, signature);
-    const isSealed = metadata.isSealedMember(qualifiedName, signature);
-    return { isOverride: isVirtual && !isSealed, isShadow: !isVirtual };
-  } else if (memberKind === "property") {
-    // For properties, check without parameters
-    const isVirtual = metadata.isVirtualMember(qualifiedName, memberName);
-    const isSealed = metadata.isSealedMember(qualifiedName, memberName);
-    return { isOverride: isVirtual && !isSealed, isShadow: !isVirtual };
-  }
-
-  return { isOverride: false, isShadow: false };
-};
-
-/**
- * Detect override for TypeScript base classes
- */
-const detectTypeScriptOverride = (
-  memberName: string,
-  memberKind: "method" | "property",
-  baseSymbol: ts.Symbol
-): OverrideInfo => {
-  const baseDeclarations = baseSymbol.getDeclarations();
-
-  if (!baseDeclarations || baseDeclarations.length === 0) {
-    return { isOverride: false, isShadow: false };
-  }
-
-  for (const baseDecl of baseDeclarations) {
-    if (ts.isClassDeclaration(baseDecl)) {
-      // Check if base class has this member
-      const baseMember = baseDecl.members.find((m) => {
-        if (memberKind === "method" && ts.isMethodDeclaration(m)) {
-          return ts.isIdentifier(m.name) && m.name.text === memberName;
-        } else if (memberKind === "property" && ts.isPropertyDeclaration(m)) {
-          return ts.isIdentifier(m.name) && m.name.text === memberName;
-        }
-        return false;
-      });
-
-      if (baseMember) {
-        // In TypeScript, all methods can be overridden unless final (not supported in TS)
-        return { isOverride: true, isShadow: false };
-      }
-    }
-  }
-
-  return { isOverride: false, isShadow: false };
-};

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

@@ -1,63 +0,0 @@
-/**
- * Property member conversion
- */
-
-import * as ts from "typescript";
-import { IrClassMember } from "../../../../types.js";
-import { convertExpression } from "../../../../expression-converter.js";
-import { convertType, inferType } from "../../../../type-converter.js";
-import {
-  hasStaticModifier,
-  hasReadonlyModifier,
-  getAccessibility,
-} from "../../helpers.js";
-import { detectOverride } from "./override-detection.js";
-
-/**
- * Get the IR type for a property declaration.
- * Uses explicit annotation if present, otherwise infers from TypeChecker.
- * C# requires explicit types for class fields (no 'var').
- */
-const getPropertyType = (
-  node: ts.PropertyDeclaration,
-  checker: ts.TypeChecker
-) => {
-  // If there's an explicit type annotation, use it
-  if (node.type) {
-    return convertType(node.type, checker);
-  }
-  // Infer type from checker (always needed for class fields)
-  return inferType(node, checker);
-};
-
-/**
- * Convert property declaration to IR
- */
-export const convertProperty = (
-  node: ts.PropertyDeclaration,
-  checker: ts.TypeChecker,
-  superClass: ts.ExpressionWithTypeArguments | undefined
-): IrClassMember => {
-  const memberName = ts.isIdentifier(node.name) ? node.name.text : "[computed]";
-
-  const overrideInfo = detectOverride(
-    memberName,
-    "property",
-    superClass,
-    checker
-  );
-
-  return {
-    kind: "propertyDeclaration",
-    name: memberName,
-    type: getPropertyType(node, checker),
-    initializer: node.initializer
-      ? convertExpression(node.initializer, checker)
-      : undefined,
-    isStatic: hasStaticModifier(node),
-    isReadonly: hasReadonlyModifier(node),
-    accessibility: getAccessibility(node),
-    isOverride: overrideInfo.isOverride ? true : undefined,
-    isShadow: overrideInfo.isShadow ? true : undefined,
-  };
-};

package/src/ir/converters/statements/declarations/enums.ts

@@ -1,29 +0,0 @@
-/**
- * Enum declaration converter
- */
-
-import * as ts from "typescript";
-import { IrEnumDeclaration } from "../../../types.js";
-import { convertExpression } from "../../../expression-converter.js";
-import { hasExportModifier } from "../helpers.js";
-
-/**
- * Convert enum declaration
- */
-export const convertEnumDeclaration = (
-  node: ts.EnumDeclaration,
-  checker: ts.TypeChecker
-): IrEnumDeclaration => {
-  return {
-    kind: "enumDeclaration",
-    name: node.name.text,
-    members: node.members.map((m) => ({
-      kind: "enumMember" as const,
-      name: ts.isIdentifier(m.name) ? m.name.text : "[computed]",
-      initializer: m.initializer
-        ? convertExpression(m.initializer, checker)
-        : undefined,
-    })),
-    isExported: hasExportModifier(node),
-  };
-};

package/src/ir/converters/statements/declarations/functions.ts

@@ -1,39 +0,0 @@
-/**
- * Function declaration converter
- */
-
-import * as ts from "typescript";
-import { IrFunctionDeclaration } from "../../../types.js";
-import { convertType } from "../../../type-converter.js";
-import { convertBlockStatement } from "../control.js";
-import {
-  hasExportModifier,
-  convertTypeParameters,
-  convertParameters,
-} from "../helpers.js";
-
-/**
- * Convert function declaration
- */
-export const convertFunctionDeclaration = (
-  node: ts.FunctionDeclaration,
-  checker: ts.TypeChecker
-): IrFunctionDeclaration | null => {
-  if (!node.name) return null;
-
-  return {
-    kind: "functionDeclaration",
-    name: node.name.text,
-    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)
-      : { kind: "blockStatement", statements: [] },
-    isAsync: !!node.modifiers?.some(
-      (m) => m.kind === ts.SyntaxKind.AsyncKeyword
-    ),
-    isGenerator: !!node.asteriskToken,
-    isExported: hasExportModifier(node),
-  };
-};

package/src/ir/converters/statements/declarations/interfaces.ts

@@ -1,131 +0,0 @@
-/**
- * Interface declaration converter
- */
-
-import * as ts from "typescript";
-import { IrInterfaceDeclaration, IrInterfaceMember } from "../../../types.js";
-import { convertType } from "../../../type-converter.js";
-import {
-  hasExportModifier,
-  hasReadonlyModifier,
-  convertTypeParameters,
-  convertParameters,
-} from "../helpers.js";
-
-/**
- * Convert interface member
- */
-export const convertInterfaceMember = (
-  node: ts.TypeElement,
-  checker: ts.TypeChecker
-): IrInterfaceMember | null => {
-  if (ts.isPropertySignature(node) && node.type) {
-    return {
-      kind: "propertySignature",
-      name:
-        node.name && ts.isIdentifier(node.name) ? node.name.text : "[computed]",
-      type: convertType(node.type, checker),
-      isOptional: !!node.questionToken,
-      isReadonly: hasReadonlyModifier(node),
-    };
-  }
-
-  if (ts.isMethodSignature(node)) {
-    return {
-      kind: "methodSignature",
-      name:
-        node.name && ts.isIdentifier(node.name) ? node.name.text : "[computed]",
-      typeParameters: convertTypeParameters(node.typeParameters, checker),
-      parameters: convertParameters(node.parameters, checker),
-      returnType: node.type ? convertType(node.type, checker) : undefined,
-    };
-  }
-
-  return null;
-};
-
-/**
- * Check if a type reference is the struct marker
- */
-const isStructMarker = (
-  typeRef: ts.ExpressionWithTypeArguments,
-  checker: ts.TypeChecker
-): boolean => {
-  const symbol = checker.getSymbolAtLocation(typeRef.expression);
-  return symbol?.escapedName === "struct" || symbol?.escapedName === "Struct";
-};
-
-/**
- * Check if an interface declaration IS the struct marker itself (should be filtered out)
- */
-const isMarkerInterface = (node: ts.InterfaceDeclaration): boolean => {
-  const name = node.name.text;
-  if (name !== "struct" && name !== "Struct") {
-    return false;
-  }
-
-  // Check if it has only the __brand property
-  const members = node.members;
-  if (members.length !== 1) {
-    return false;
-  }
-
-  const member = members[0];
-  if (!member || !ts.isPropertySignature(member)) {
-    return false;
-  }
-
-  const memberName =
-    member.name && ts.isIdentifier(member.name) ? member.name.text : "";
-  return memberName === "__brand";
-};
-
-/**
- * Convert interface declaration
- * Returns null for marker interfaces that should be filtered out
- */
-export const convertInterfaceDeclaration = (
-  node: ts.InterfaceDeclaration,
-  checker: ts.TypeChecker
-): IrInterfaceDeclaration | null => {
-  // Filter out marker interfaces completely
-  if (isMarkerInterface(node)) {
-    return null;
-  }
-  // Detect struct marker in extends clause
-  let isStruct = false;
-  const extendsClause = node.heritageClauses?.find(
-    (h) => h.token === ts.SyntaxKind.ExtendsKeyword
-  );
-  const extendsTypes =
-    extendsClause?.types
-      .filter((t) => {
-        if (isStructMarker(t, checker)) {
-          isStruct = true;
-          return false; // Remove marker from extends
-        }
-        return true;
-      })
-      .map((t) => convertType(t, checker)) ?? [];
-
-  const allMembers = node.members
-    .map((m) => convertInterfaceMember(m, checker))
-    .filter((m): m is IrInterfaceMember => m !== null);
-
-  // Filter out __brand property if this is a struct
-  const finalMembers = isStruct
-    ? allMembers.filter(
-        (m) => m.kind !== "propertySignature" || m.name !== "__brand"
-      )
-    : allMembers;
-
-  return {
-    kind: "interfaceDeclaration",
-    name: node.name.text,
-    typeParameters: convertTypeParameters(node.typeParameters, checker),
-    extends: extendsTypes,
-    members: finalMembers,
-    isExported: hasExportModifier(node),
-    isStruct,
-  };
-};

package/src/ir/converters/statements/declarations/type-aliases.ts

@@ -1,25 +0,0 @@
-/**
- * Type alias declaration converter
- */
-
-import * as ts from "typescript";
-import { IrTypeAliasDeclaration } from "../../../types.js";
-import { convertType } from "../../../type-converter.js";
-import { hasExportModifier, convertTypeParameters } from "../helpers.js";
-
-/**
- * Convert type alias declaration
- */
-export const convertTypeAliasDeclaration = (
-  node: ts.TypeAliasDeclaration,
-  checker: ts.TypeChecker
-): IrTypeAliasDeclaration => {
-  return {
-    kind: "typeAliasDeclaration",
-    name: node.name.text,
-    typeParameters: convertTypeParameters(node.typeParameters, checker),
-    type: convertType(node.type, checker),
-    isExported: hasExportModifier(node),
-    isStruct: false, // Type aliases are not structs by default
-  };
-};

package/src/ir/converters/statements/declarations/variables.ts

@@ -1,60 +0,0 @@
-/**
- * Variable declaration converter
- */
-
-import * as ts from "typescript";
-import { IrVariableDeclaration } from "../../../types.js";
-import { convertExpression } from "../../../expression-converter.js";
-import {
-  convertType,
-  convertBindingName,
-  inferType,
-} from "../../../type-converter.js";
-import { hasExportModifier } from "../helpers.js";
-
-/**
- * Get the IR type for a variable declaration.
- * Uses explicit annotation if present, otherwise infers from TypeChecker.
- */
-const getDeclarationType = (
-  decl: ts.VariableDeclaration,
-  checker: ts.TypeChecker,
-  needsExplicitType: boolean
-) => {
-  // If there's an explicit type annotation, use it
-  if (decl.type) {
-    return convertType(decl.type, checker);
-  }
-  // If we need an explicit type (for module-level exports), infer it
-  if (needsExplicitType) {
-    return inferType(decl, checker);
-  }
-  return undefined;
-};
-
-/**
- * Convert variable statement
- */
-export const convertVariableStatement = (
-  node: ts.VariableStatement,
-  checker: ts.TypeChecker
-): IrVariableDeclaration => {
-  const isConst = !!(node.declarationList.flags & ts.NodeFlags.Const);
-  const isLet = !!(node.declarationList.flags & ts.NodeFlags.Let);
-  const declarationKind = isConst ? "const" : isLet ? "let" : "var";
-  const isExported = hasExportModifier(node);
-
-  return {
-    kind: "variableDeclaration",
-    declarationKind,
-    declarations: node.declarationList.declarations.map((decl) => ({
-      kind: "variableDeclarator",
-      name: convertBindingName(decl.name),
-      type: getDeclarationType(decl, checker, isExported),
-      initializer: decl.initializer
-        ? convertExpression(decl.initializer, checker)
-        : undefined,
-    })),
-    isExported,
-  };
-};

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

@@ -1,16 +0,0 @@
-/**
- * Declaration converters (variables, functions, classes, interfaces, enums, type aliases)
- * Main dispatcher - re-exports from declarations/ subdirectory
- */
-
-export {
-  setMetadataRegistry,
-  setBindingRegistry,
-  convertVariableStatement,
-  convertFunctionDeclaration,
-  convertClassDeclaration,
-  convertInterfaceDeclaration,
-  convertInterfaceMember,
-  convertEnumDeclaration,
-  convertTypeAliasDeclaration,
-} from "./declarations/index.js";