Testing de Tipos (Type Testing) y Transformadores AST de TypeScript

[ Código Fuente TypeScript (*.ts) ]
               │
               ▼
   1. SCANNER (Análisis Léxico: flujo de tokens SyntaxKind)
               │
               ▼
   2. PARSER (Análisis Sintáctico: construcción del AST SourceFile)
               │
               ▼
   3. BINDER (Resolución de Símbolos: población de Tablas de Símbolos)
               │
               ▼
   4. TYPE CHECKER (Análisis Semántico: getTypeOfSymbolAtLocation)
               │
               ├───► [ SUITE DE TYPE TESTING (Vitest / tsd) ]
               │     (Verificación de equivalencia a nivel de TypeChecker)
               ▼
   5. EMITTER (Emisión del AST a JS)
         │
         ├──► [ TRANSFORMADORES AST PERSONALIZADOS ] (Mutación de nodos)
         │
         ▼
[ Artefactos Finales: JavaScript (*.js) + Declaraciones (*.d.ts) ]

// Implementación canónica de igualdad estricta de tipos (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;

// Casos de prueba
type Case1 = Expect<Equal<string, string>>; // true
type Case2 = Expect<Equal<number | string, string | number>>; // true

// ❌ Error de compilación: 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[];
}

// Utilidad de transformación profunda en prueba
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('transforma recursivamente propiedades y arrays anidados en estructuras de solo lectura', () => {
    const rawUser: User = {
      id: 'usr_1',
      name: 'Konstantin',
      role: 'admin',
      permissions: ['read', 'write'],
    };

    const readonlyUser = makeReadonly(rawUser);

    // 1. Verificar el tipo exacto del valor retornado
    expectTypeOf(readonlyUser).toEqualTypeOf<{
      readonly id: string;
      readonly name: string;
      readonly role: 'admin' | 'viewer';
      readonly permissions: readonly string[];
    }>();

    // 2. Verificar que las propiedades no se pueden mutar
    // @ts-expect-error Valida que el compilador rechace la reasignación de campos
    readonlyUser.name = 'Nuevo Nombre';

    // @ts-expect-error Valida que métodos mutadores de arrays estén prohibidos
    readonlyUser.permissions.push('delete');

    // 3. Verificar compatibilidad de firmas de función
    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) => {
      // Visitante recursivo de nodos AST
      function visitor(node: ts.Node): ts.Node {
        // Interceptar llamadas a la función monitorScope(...)
        if (
          ts.isCallExpression(node) &&
          ts.isIdentifier(node.expression) &&
          node.expression.text === 'monitorScope'
        ) {
          // Extraer coordenadas de línea y carácter en el archivo fuente
          const { line, character } = sourceFile.getLineAndCharacterOfPosition(
            node.getStart()
          );

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

          // Adjuntar la cadena de ubicación como segundo argumento inyectado
          const updatedArguments = [
            ...node.arguments,
            factory.createStringLiteral(locationString),
          ];

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

        // Continuar recorriendo nodos descendientes
        return ts.visitEachChild(node, visitor, context);
      }

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