Тестування типів (Type Testing) та AST-трансформери TypeScript

[ Вихідний код TypeScript (*.ts) ]
               │
               ▼
   1. SCANNER (Лексичний аналіз: потік токенів SyntaxKind)
               │
               ▼
   2. PARSER (Синтаксичний аналіз: побудова SourceFile AST)
               │
               ▼
   3. BINDER (Зв'язування ідентифікаторів у таблицю Symbols)
               │
               ▼
   4. TYPE CHECKER (Семантичний аналіз типів: getTypeOfSymbolAtLocation)
               │
               ├───► [ TYPE TESTING SUITE (Vitest / tsd) ]
               │     (Верифікація еквівалентності типів на рівні TypeChecker)
               ▼
   5. EMITTER (Трансляція AST у JS)
         │
         ├──► [ КАСТОМНІ AST-ТРАНСФОРМЕРИ ] (Мутація дерева вузлів)
         │
         ▼
[ Фінальний артефакт: JavaScript (*.js) + Декларації (*.d.ts) ]

// Еталонна реалізація перевірки ідентичності типів (Strict Type Equality)
export type Equal<X, Y> = 
  (<T>() => T extends X ? 1 : 2) extends 
  (<T>() => T extends Y ? 1 : 2) ? true : false;

export type Expect<T extends true> = T;
export type ExpectFalse<T extends false> = T;

// Приклади перевірки
type Case1 = Expect<Equal<string, string>>; // true
type Case2 = Expect<Equal<number | string, string | number>>; // true

// ❌ Помилка компіляції: Type 'false' does not satisfy the constraint 'true'
// type Case3 = Expect<Equal<any, string>>;

import { describe, it, expectTypeOf, assertType } from 'vitest';

interface User {
  id: string;
  name: string;
  role: 'admin' | 'viewer';
  permissions: string[];
}

// Тестована утиліта глибокого перетворення
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends (infer R)[]
    ? readonly DeepReadonly<R>[]
    : T[P] extends object
      ? DeepReadonly<T[P]>
      : T[P];
};

function makeReadonly<T extends object>(target: T): DeepReadonly<T> {
  return Object.freeze({ ...target }) as DeepReadonly<T>;
}

describe('Type Testing: DeepReadonly<T>', () => {
  it('коректно трансформує всі поля та вкладені масиви у readonly', () => {
    const rawUser: User = {
      id: 'usr_1',
      name: 'Костянтин',
      role: 'admin',
      permissions: ['read', 'write'],
    };

    const readonlyUser = makeReadonly(rawUser);

    // 1. Перевірка точного типу поверненого значення
    expectTypeOf(readonlyUser).toEqualTypeOf<{
      readonly id: string;
      readonly name: string;
      readonly role: 'admin' | 'viewer';
      readonly permissions: readonly string[];
    }>();

    // 2. Перевірка, що властивості неможливо мутувати
    // @ts-expect-error Перевіряємо, що компілятор забороняє перезапис поля
    readonlyUser.name = 'Нове ім\'я';

    // @ts-expect-error Перевіряємо, що push у масив заборонений на рівні типів
    readonlyUser.permissions.push('delete');

    // 3. Перевірка відповідності сигнатур функцій
    assertType<(target: User) => DeepReadonly<User>>(makeReadonly);
  });
});

pnpm exec vitest --typecheck --run

import ts from 'typescript';

export function createTraceTransformer(): ts.TransformerFactory<ts.SourceFile> {
  return (context: ts.TransformationContext) => {
    const { factory } = context;

    return (sourceFile: ts.SourceFile) => {
      // Рекурсивний відвідувач вузлів AST
      function visitor(node: ts.Node): ts.Node {
        // Шукаємо виклики функції monitorScope(...)
        if (
          ts.isCallExpression(node) &&
          ts.isIdentifier(node.expression) &&
          node.expression.text === 'monitorScope'
        ) {
          // Отримуємо координати рядка у вихідному файлі
          const { line, character } = sourceFile.getLineAndCharacterOfPosition(
            node.getStart()
          );

          const locationString = `${sourceFile.fileName}:${line + 1}:${character + 1}`;

          // Додаємо рядковий літерал із координатами другим аргументом
          const updatedArguments = [
            ...node.arguments,
            factory.createStringLiteral(locationString),
          ];

          return factory.updateCallExpression(
            node,
            node.expression,
            node.typeArguments,
            updatedArguments
          );
        }

        // Продовжуємо обхід дочірніх вузлів
        return ts.visitEachChild(node, visitor, context);
      }

      return ts.visitNode(sourceFile, visitor) as ts.SourceFile;
    };
  };
}