Тестирование типов (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;
    };
  };
}