@tsonic/frontend 0.0.1

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

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Class declaration converter
+ * Main dispatcher - re-exports from classes/ subdirectory
+ */
+
+export { convertClassDeclaration } from "./classes/index.js";

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Declaration converters - Public API
+ */
+
+export { setMetadataRegistry, setBindingRegistry } from "./registry.js";
+export { convertVariableStatement } from "./variables.js";
+export { convertFunctionDeclaration } from "./functions.js";
+export { convertClassDeclaration } from "./classes.js";
+export {
+  convertInterfaceDeclaration,
+  convertInterfaceMember,
+} from "./interfaces.js";
+export { convertEnumDeclaration } from "./enums.js";
+export { convertTypeAliasDeclaration } from "./type-aliases.js";

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

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

@@ -0,0 +1,45 @@
+/**
+ * Metadata and binding registry management
+ */
+
+import { DotnetMetadataRegistry } from "../../../../dotnet-metadata.js";
+import { BindingRegistry } from "../../../../program/bindings.js";
+
+/**
+ * Module-level metadata registry singleton
+ * Set once at the start of compilation via setMetadataRegistry()
+ */
+let _metadataRegistry: DotnetMetadataRegistry = new DotnetMetadataRegistry();
+
+/**
+ * Module-level binding registry singleton
+ * Set once at the start of compilation via setBindingRegistry()
+ */
+let _bindingRegistry: BindingRegistry = new BindingRegistry();
+
+/**
+ * Set the metadata registry for this compilation
+ * Called once at the start of IR building
+ */
+export const setMetadataRegistry = (registry: DotnetMetadataRegistry): void => {
+  _metadataRegistry = registry;
+};
+
+/**
+ * Get the current metadata registry
+ */
+export const getMetadataRegistry = (): DotnetMetadataRegistry =>
+  _metadataRegistry;
+
+/**
+ * Set the binding registry for this compilation
+ * Called once at the start of IR building
+ */
+export const setBindingRegistry = (registry: BindingRegistry): void => {
+  _bindingRegistry = registry;
+};
+
+/**
+ * Get the current binding registry
+ */
+export const getBindingRegistry = (): BindingRegistry => _bindingRegistry;

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

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