@tsonic/frontend 0.0.1

package/src/types/support-types.ts

@@ -0,0 +1,288 @@
+/**
+ * Support Types Recognition - Detect and work with _support/types.d.ts marker types.
+ *
+ * This module provides type guards and helpers to recognize special CLR interop types
+ * that don't have JavaScript equivalents: TSByRef, TSUnsafePointer, TSDelegate, etc.
+ *
+ * @see spec/support-types.md for complete documentation
+ */
+
+import * as ts from "typescript";
+
+/**
+ * Support type kind enumeration.
+ * Represents the different marker types from _support/types.d.ts.
+ */
+export type SupportTypeKind =
+  | "TSByRef"
+  | "TSUnsafePointer"
+  | "TSDelegate"
+  | "TSNullable"
+  | "TSFixed"
+  | "TSStackAlloc";
+
+/**
+ * Information about a recognized support type.
+ */
+export type SupportTypeInfo = {
+  readonly kind: SupportTypeKind;
+  readonly wrappedType: ts.Type;
+  readonly typeArguments: readonly ts.Type[];
+};
+
+/**
+ * Check if a type is a support type (TSByRef, TSUnsafePointer, etc.).
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns Support type info if recognized, undefined otherwise
+ */
+export const getSupportTypeInfo = (
+  type: ts.Type,
+  _checker: ts.TypeChecker
+): SupportTypeInfo | undefined => {
+  // Try to get type name from either symbol or aliasSymbol
+  const symbol = type.aliasSymbol || type.symbol;
+  if (!symbol) {
+    return undefined;
+  }
+
+  const typeName = symbol.getName();
+
+  // Check if it's a recognized support type
+  const kind = getSupportTypeKind(typeName);
+  if (!kind) {
+    return undefined;
+  }
+
+  // Extract type arguments - try alias type arguments first, then regular
+  let typeArguments: readonly ts.Type[] = [];
+
+  // Type aliases have aliasTypeArguments
+  if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
+    typeArguments = type.aliasTypeArguments;
+  }
+  // Generic type references have typeArguments through TypeReference interface
+  else if (isGenericTypeReference(type)) {
+    typeArguments = getTypeArguments(type);
+  }
+
+  if (typeArguments.length === 0) {
+    return undefined;
+  }
+
+  const wrappedType = typeArguments[0];
+  if (!wrappedType) {
+    return undefined;
+  }
+
+  return {
+    kind,
+    wrappedType,
+    typeArguments,
+  };
+};
+
+/**
+ * Get support type kind from type name.
+ *
+ * @param typeName - Type symbol name
+ * @returns Support type kind if recognized, undefined otherwise
+ */
+const getSupportTypeKind = (typeName: string): SupportTypeKind | undefined => {
+  switch (typeName) {
+    case "TSByRef":
+      return "TSByRef";
+    case "TSUnsafePointer":
+      return "TSUnsafePointer";
+    case "TSDelegate":
+      return "TSDelegate";
+    case "TSNullable":
+      return "TSNullable";
+    case "TSFixed":
+      return "TSFixed";
+    case "TSStackAlloc":
+      return "TSStackAlloc";
+    default:
+      return undefined;
+  }
+};
+
+/**
+ * Check if a type is TSByRef<T>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSByRef<T>
+ */
+export const isTSByRef = (type: ts.Type, checker: ts.TypeChecker): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSByRef";
+};
+
+/**
+ * Check if a type is TSUnsafePointer<T>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSUnsafePointer<T>
+ */
+export const isTSUnsafePointer = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSUnsafePointer";
+};
+
+/**
+ * Check if a type is TSDelegate<TArgs, TReturn>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSDelegate<TArgs, TReturn>
+ */
+export const isTSDelegate = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSDelegate";
+};
+
+/**
+ * Check if a type is TSNullable<T>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSNullable<T>
+ */
+export const isTSNullable = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSNullable";
+};
+
+/**
+ * Check if a type is TSFixed<T, N>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSFixed<T, N>
+ */
+export const isTSFixed = (type: ts.Type, checker: ts.TypeChecker): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSFixed";
+};
+
+/**
+ * Check if a type is TSStackAlloc<T>.
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns True if type is TSStackAlloc<T>
+ */
+export const isTSStackAlloc = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): boolean => {
+  const info = getSupportTypeInfo(type, checker);
+  return info?.kind === "TSStackAlloc";
+};
+
+/**
+ * Extract the wrapped type from TSByRef<T>.
+ *
+ * @param type - TypeScript type (must be TSByRef<T>)
+ * @param checker - TypeScript type checker
+ * @returns Wrapped type T, or undefined if not TSByRef
+ */
+export const getTSByRefWrappedType = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): ts.Type | undefined => {
+  const info = getSupportTypeInfo(type, checker);
+  if (info?.kind === "TSByRef") {
+    return info.wrappedType;
+  }
+  return undefined;
+};
+
+/**
+ * Extract the wrapped type from TSUnsafePointer<T>.
+ *
+ * @param type - TypeScript type (must be TSUnsafePointer<T>)
+ * @param checker - TypeScript type checker
+ * @returns Wrapped type T, or undefined if not TSUnsafePointer
+ */
+export const getTSUnsafePointerWrappedType = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): ts.Type | undefined => {
+  const info = getSupportTypeInfo(type, checker);
+  if (info?.kind === "TSUnsafePointer") {
+    return info.wrappedType;
+  }
+  return undefined;
+};
+
+/**
+ * Check if type is a generic type reference with type arguments.
+ *
+ * @param type - TypeScript type
+ * @returns True if type is a generic type reference
+ */
+const isGenericTypeReference = (type: ts.Type): boolean => {
+  return (
+    (type.flags & ts.TypeFlags.Object) !== 0 &&
+    ((type as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference) !== 0
+  );
+};
+
+/**
+ * Get type arguments from a generic type reference.
+ *
+ * @param type - TypeScript type (must be generic reference)
+ * @returns Array of type arguments
+ */
+const getTypeArguments = (type: ts.Type): readonly ts.Type[] => {
+  const typeRef = type as ts.TypeReference;
+  if (!typeRef.typeArguments) {
+    return [];
+  }
+  return typeRef.typeArguments;
+};
+
+/**
+ * Check if any support type is unsupported (unsafe pointers, fixed buffers, stackalloc).
+ *
+ * @param type - TypeScript type to check
+ * @param checker - TypeScript type checker
+ * @returns Error message if unsupported, undefined if supported
+ */
+export const checkUnsupportedSupportType = (
+  type: ts.Type,
+  checker: ts.TypeChecker
+): string | undefined => {
+  const info = getSupportTypeInfo(type, checker);
+  if (!info) {
+    return undefined;
+  }
+
+  switch (info.kind) {
+    case "TSUnsafePointer":
+      return "Unsafe pointers are not supported in Tsonic. Use IntPtr for opaque handles.";
+    case "TSFixed":
+      return "Fixed-size buffers (unsafe feature) are not supported. Use arrays or Span<T> instead.";
+    case "TSStackAlloc":
+      return "stackalloc is not supported in Tsonic. Use heap-allocated arrays instead.";
+    case "TSByRef":
+    case "TSDelegate":
+    case "TSNullable":
+      return undefined; // These are supported
+    default:
+      return undefined;
+  }
+};

package/src/types/test-harness.ts

@@ -0,0 +1,180 @@
+/**
+ * Test harness for support types tests.
+ * Creates a real TypeScript program with support type definitions
+ * and provides helpers to extract ts.Type objects.
+ */
+
+import * as ts from "typescript";
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+
+/**
+ * Support type definitions (from _support/types.d.ts)
+ */
+const SUPPORT_TYPES_DEFS = `
+// Support types for CLR interop
+export type TSByRef<T> = { value: T };
+export type TSUnsafePointer<T> = { __brand: "unsafe-pointer"; __type: T };
+export type TSDelegate<TArgs extends any[], TReturn> = { __brand: "delegate"; __args: TArgs; __return: TReturn };
+export type TSNullable<T> = { __brand: "nullable"; __value: T };
+export type TSFixed<T, N extends number> = { __brand: "fixed"; __type: T; __size: N };
+export type TSStackAlloc<T> = { __brand: "stackalloc"; __type: T };
+`;
+
+/**
+ * Test code that uses the support types
+ */
+const TEST_CODE = `
+import type { TSByRef, TSUnsafePointer, TSDelegate, TSNullable, TSFixed, TSStackAlloc } from "./support-types";
+
+// Test variables with support types
+const byRef: TSByRef<number> = { value: 42 };
+const unsafePtr: TSUnsafePointer<string> = null!;
+const delegate: TSDelegate<[string], void> = null!;
+const nullable: TSNullable<number> = null!;
+const fixed: TSFixed<number, 10> = null!;
+const stackAlloc: TSStackAlloc<number> = null!;
+`;
+
+export type TestHarness = {
+  readonly program: ts.Program;
+  readonly checker: ts.TypeChecker;
+  readonly sourceFile: ts.SourceFile;
+  readonly cleanup: () => void;
+};
+
+/**
+ * Create a test harness with a real TypeScript program.
+ * Returns program, checker, and source file for testing.
+ */
+export const createTestHarness = (): TestHarness => {
+  // Create temporary directory
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-test-"));
+
+  // Write support types definition file
+  const supportTypesPath = path.join(tmpDir, "support-types.d.ts");
+  fs.writeFileSync(supportTypesPath, SUPPORT_TYPES_DEFS);
+
+  // Write test code file
+  const testCodePath = path.join(tmpDir, "test.ts");
+  fs.writeFileSync(testCodePath, TEST_CODE);
+
+  // Create TypeScript program
+  const program = ts.createProgram({
+    rootNames: [testCodePath],
+    options: {
+      target: ts.ScriptTarget.ES2020,
+      module: ts.ModuleKind.ES2020,
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true,
+    },
+  });
+
+  const checker = program.getTypeChecker();
+  const sourceFile = program.getSourceFile(testCodePath);
+
+  if (!sourceFile) {
+    throw new Error("Failed to get source file from test program");
+  }
+
+  const cleanup = () => {
+    // Clean up temporary files
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  };
+
+  return {
+    program,
+    checker,
+    sourceFile,
+    cleanup,
+  };
+};
+
+/**
+ * Extract the type of a variable declaration by name.
+ * Gets the type from the type annotation node, not the inferred type.
+ */
+export const getVariableType = (
+  sourceFile: ts.SourceFile,
+  checker: ts.TypeChecker,
+  variableName: string
+): ts.Type | undefined => {
+  let foundType: ts.Type | undefined = undefined;
+
+  const visit = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node)) {
+      if (ts.isIdentifier(node.name) && node.name.text === variableName) {
+        // Get type from type annotation if present
+        if (node.type) {
+          foundType = checker.getTypeFromTypeNode(node.type);
+        } else {
+          foundType = checker.getTypeAtLocation(node);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return foundType;
+};
+
+/**
+ * Get all support type instances from the test harness.
+ */
+export const getSupportTypes = (
+  harness: TestHarness
+): {
+  byRef: ts.Type;
+  unsafePointer: ts.Type;
+  delegate: ts.Type;
+  nullable: ts.Type;
+  fixed: ts.Type;
+  stackAlloc: ts.Type;
+} => {
+  const byRef = getVariableType(harness.sourceFile, harness.checker, "byRef");
+  const unsafePointer = getVariableType(
+    harness.sourceFile,
+    harness.checker,
+    "unsafePtr"
+  );
+  const delegate = getVariableType(
+    harness.sourceFile,
+    harness.checker,
+    "delegate"
+  );
+  const nullable = getVariableType(
+    harness.sourceFile,
+    harness.checker,
+    "nullable"
+  );
+  const fixed = getVariableType(harness.sourceFile, harness.checker, "fixed");
+  const stackAlloc = getVariableType(
+    harness.sourceFile,
+    harness.checker,
+    "stackAlloc"
+  );
+
+  if (
+    !byRef ||
+    !unsafePointer ||
+    !delegate ||
+    !nullable ||
+    !fixed ||
+    !stackAlloc
+  ) {
+    throw new Error("Failed to extract all support types from test harness");
+  }
+
+  return {
+    byRef,
+    unsafePointer,
+    delegate,
+    nullable,
+    fixed,
+    stackAlloc,
+  };
+};

package/src/validation/exports.ts

@@ -0,0 +1,98 @@
+/**
+ * Export validation
+ */
+
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import {
+  DiagnosticsCollector,
+  addDiagnostic,
+  createDiagnostic,
+} from "../types/diagnostic.js";
+import { hasExportModifier, getNodeLocation } from "./helpers.js";
+
+/**
+ * Validate exports (check for duplicates)
+ */
+export const validateExports = (
+  sourceFile: ts.SourceFile,
+  _program: TsonicProgram,
+  collector: DiagnosticsCollector
+): DiagnosticsCollector => {
+  const exportedNames = new Set<string>();
+
+  const visitor = (node: ts.Node): void => {
+    if (ts.isExportDeclaration(node) || ts.isExportAssignment(node)) {
+      // Validate export syntax
+      if (ts.isExportAssignment(node) && !node.isExportEquals) {
+        // export default is allowed
+      } else if (
+        ts.isExportDeclaration(node) &&
+        node.exportClause &&
+        ts.isNamedExports(node.exportClause)
+      ) {
+        node.exportClause.elements.forEach((spec) => {
+          const name = spec.name.text;
+          if (exportedNames.has(name)) {
+            collector = addDiagnostic(
+              collector,
+              createDiagnostic(
+                "TSN1005",
+                "error",
+                `Duplicate export: "${name}"`,
+                getNodeLocation(sourceFile, spec)
+              )
+            );
+          }
+          exportedNames.add(name);
+        });
+      }
+    }
+
+    if (ts.isVariableStatement(node) && hasExportModifier(node)) {
+      node.declarationList.declarations.forEach((decl) => {
+        if (ts.isIdentifier(decl.name)) {
+          const name = decl.name.text;
+          if (exportedNames.has(name)) {
+            collector = addDiagnostic(
+              collector,
+              createDiagnostic(
+                "TSN1005",
+                "error",
+                `Duplicate export: "${name}"`,
+                getNodeLocation(sourceFile, decl)
+              )
+            );
+          }
+          exportedNames.add(name);
+        }
+      });
+    }
+
+    if (
+      (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+      hasExportModifier(node)
+    ) {
+      const name = node.name?.text;
+      if (name) {
+        if (exportedNames.has(name)) {
+          collector = addDiagnostic(
+            collector,
+            createDiagnostic(
+              "TSN1005",
+              "error",
+              `Duplicate export: "${name}"`,
+              getNodeLocation(sourceFile, node)
+            )
+          );
+        }
+        exportedNames.add(name);
+      }
+    }
+
+    ts.forEachChild(node, visitor);
+  };
+
+  visitor(sourceFile);
+  return collector;
+};

package/src/validation/features.ts

@@ -0,0 +1,89 @@
+/**
+ * Unsupported feature validation
+ */
+
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import {
+  DiagnosticsCollector,
+  addDiagnostic,
+  createDiagnostic,
+} from "../types/diagnostic.js";
+import { getNodeLocation } from "./helpers.js";
+
+/**
+ * Validate that unsupported features are not used
+ */
+export const validateUnsupportedFeatures = (
+  sourceFile: ts.SourceFile,
+  _program: TsonicProgram,
+  collector: DiagnosticsCollector
+): DiagnosticsCollector => {
+  const visitor = (node: ts.Node): void => {
+    // Check for features we don't support yet
+    if (ts.isWithStatement(node)) {
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic(
+          "TSN2001",
+          "error",
+          "'with' statement not supported",
+          getNodeLocation(sourceFile, node)
+        )
+      );
+    }
+
+    if (ts.isMetaProperty(node)) {
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic(
+          "TSN2001",
+          "error",
+          "Meta properties (import.meta) not supported",
+          getNodeLocation(sourceFile, node)
+        )
+      );
+    }
+
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      collector = addDiagnostic(
+        collector,
+        createDiagnostic(
+          "TSN2001",
+          "error",
+          "Dynamic import() not supported",
+          getNodeLocation(sourceFile, node),
+          "Use static imports"
+        )
+      );
+    }
+
+    // Check for Promise.then/catch/finally chaining (not supported)
+    if (
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression)
+    ) {
+      const methodName = node.expression.name.text;
+      if (["then", "catch", "finally"].includes(methodName)) {
+        collector = addDiagnostic(
+          collector,
+          createDiagnostic(
+            "TSN3011",
+            "error",
+            `Promise.${methodName}() is not supported`,
+            getNodeLocation(sourceFile, node),
+            "Use async/await instead of Promise chaining"
+          )
+        );
+      }
+    }
+
+    ts.forEachChild(node, visitor);
+  };
+
+  visitor(sourceFile);
+  return collector;
+};

package/src/validation/generics.ts

@@ -0,0 +1,40 @@
+/**
+ * Generic type validation
+ */
+
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import { DiagnosticsCollector, addDiagnostic } from "../types/diagnostic.js";
+import { checkForSymbolIndexSignature } from "../ir/generic-validator.js";
+
+/**
+ * Validate generic types and constraints
+ */
+export const validateGenerics = (
+  sourceFile: ts.SourceFile,
+  _program: TsonicProgram,
+  collector: DiagnosticsCollector
+): DiagnosticsCollector => {
+  const visitor = (node: ts.Node): void => {
+    // Only check for truly unsupported features (no static C# mapping)
+    // Symbol index signatures - TSN7203
+    if (ts.isIndexSignatureDeclaration(node)) {
+      const symbolDiag = checkForSymbolIndexSignature(node, sourceFile);
+      if (symbolDiag) {
+        collector = addDiagnostic(collector, symbolDiag);
+      }
+    }
+
+    // Explicitly visit interface and type literal members
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node)) {
+      for (const member of node.members) {
+        visitor(member);
+      }
+    }
+
+    ts.forEachChild(node, visitor);
+  };
+
+  visitor(sourceFile);
+  return collector;
+};