@tsonic/frontend 0.0.1 → 0.0.4

package/src/types/support-types.test.ts

@@ -1,81 +0,0 @@
-/**
- * Tests for support types recognition using real TypeScript types.
- */
-
-import { describe, it, before, after } from "mocha";
-import { strict as assert } from "assert";
-import { checkUnsupportedSupportType } from "./support-types.js";
-import {
-  createTestHarness,
-  getSupportTypes,
-  type TestHarness,
-} from "./test-harness.js";
-
-describe("Support Types", () => {
-  let harness: TestHarness;
-  let types: ReturnType<typeof getSupportTypes>;
-
-  before(() => {
-    // Create test harness with real TypeScript program
-    harness = createTestHarness();
-    types = getSupportTypes(harness);
-  });
-
-  after(() => {
-    // Clean up temporary files
-    harness.cleanup();
-  });
-
-  describe("checkUnsupportedSupportType", () => {
-    it("should detect TSUnsafePointer as unsupported", () => {
-      const error = checkUnsupportedSupportType(
-        types.unsafePointer,
-        harness.checker
-      );
-
-      assert.ok(error);
-      assert.match(error!, /unsafe pointer/i);
-    });
-
-    it("should detect TSFixed as unsupported", () => {
-      const error = checkUnsupportedSupportType(types.fixed, harness.checker);
-
-      assert.ok(error);
-      assert.match(error!, /fixed-size buffer/i);
-    });
-
-    it("should detect TSStackAlloc as unsupported", () => {
-      const error = checkUnsupportedSupportType(
-        types.stackAlloc,
-        harness.checker
-      );
-
-      assert.ok(error);
-      assert.match(error!, /stackalloc/i);
-    });
-
-    it("should allow TSByRef (supported)", () => {
-      const error = checkUnsupportedSupportType(types.byRef, harness.checker);
-
-      assert.equal(error, undefined);
-    });
-
-    it("should allow TSNullable (supported)", () => {
-      const error = checkUnsupportedSupportType(
-        types.nullable,
-        harness.checker
-      );
-
-      assert.equal(error, undefined);
-    });
-
-    it("should allow TSDelegate (supported)", () => {
-      const error = checkUnsupportedSupportType(
-        types.delegate,
-        harness.checker
-      );
-
-      assert.equal(error, undefined);
-    });
-  });
-});

package/src/types/support-types.ts

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

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

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