Validated Code Translation for Projects with External Libraries

1. El Problema

La traducción de código entre lenguajes, específicamente de Go a Rust para mejorar la seguridad de la memoria, ha avanzado gracias a los Modelos de Lenguaje Grande (LLM). Sin embargo, los enfoques existentes fallan estrepitosamente cuando los programas fuente dependen de bibliotecas externas, debido a dos limitaciones críticas:

1. Alucinación y Resolución de APIs: Los LLMs tienden a "alucinar" APIs o bibliotecas que no existen en el lenguaje objetivo (Rust) o seleccionan las incorrectas. Además, en Rust, la resolución de importaciones es compleja (depende de traits, re-exportaciones y módulos privados); los LLMs a menudo generan código que llama a la API correcta pero falla en la compilación porque faltan las declaraciones de importación (use) necesarias.
2. Validación de Equivalencia Semántica con Tipos Opacos: Validar que la traducción es correcta es difícil cuando se manipulan tipos definidos por bibliotecas externas. Estos tipos suelen ser opacos (sus campos internos no son accesibles directamente) y carecen de interfaces de (de)serialización estables. Las técnicas actuales asumen que los tipos de entrada son estructuralmente idénticos o que se pueden acceder a sus campos, lo cual no es cierto en lenguajes modernos con tipos opacos, impidiendo la comparación directa de valores entre Go y Rust.

2. Metodología

Los autores proponen un marco de trabajo CrossCrate que combina un mecanismo de recuperación de información (RAG) con una tubería de validación cruzada. El proceso se divide en tres etapas principales:

A. Mapeo de Bibliotecas y Resolución de Importaciones (Stage 1 & 2)

Para mitigar las alucinaciones y errores de compilación:

• Base de Conocimiento por Crate (RAG): Se construye una base de conocimiento indexada para cada crate (biblioteca) de Rust objetivo. Esta base no solo contiene las firmas de las APIs, sino también las rutas de importación válidas y los contextos de uso (traits necesarios).
• Recuperación Aumentada: Para cada llamada a una API en Go, el sistema recupera las APIs candidatas más relevantes en Rust basándose en la documentación y firmas.
• Inyección en el Prompt: Se inyectan en el prompt del LLM las APIs recuperadas junto con sus rutas de importación exactas (ej. sha2::{Sha512, Digest}), asegurando que el código generado sea compilable y utilice la sintaxis correcta de Rust.

B. Validación de Interoperabilidad Cruzada (Stage 3)

Para validar la equivalencia semántica sin acceso a campos internos:

• Representación Intermedia (Carrier): Se sintetiza un esquema Protobuf (TProto) que actúa como un formato de datos neutral entre lenguajes. Este esquema convierte los tipos complejos de Go en una estructura plana (carrier) que puede serializarse.
• Generación de Adaptadores: Se sintetizan automáticamente dos pares de adaptadores (glue code):
  1. De los tipos originales de Go/Rust hacia el carrier Protobuf.
  2. Del carrier Protobuf hacia los tipos originales.
• Restricción a APIs Públicas: Estos adaptadores se construyen exclusivamente utilizando APIs públicas de las bibliotecas (constructores, métodos de serialización), evitando el acceso directo a campos privados.
• Validación de Round-Trip: Antes de probar la equivalencia, se valida que la conversión Go -> Protobuf -> Go y Rust -> Protobuf -> Rust sea idempotente (recupere el valor original) sobre casos de prueba reales.

C. Validación de Equivalencia I/O (Differential Testing)

Una vez establecidos los adaptadores validados:

• Se ejecutan las funciones originales en Go y las traducidas en Rust con las mismas entradas de las pruebas unitarias (convertidas al carrier Protobuf).
• Se comparan las salidas observables. Si coinciden, se valida la equivalencia funcional.
• Si falla, el sistema regenera solo el cuerpo de la función (manteniendo los tipos y adaptadores fijos) hasta agotar un presupuesto de intentos.

3. Contribuciones Clave

1. Primera aproximación validada para tipos opacos: Es el primer enfoque capaz de validar la equivalencia de funciones que manipulan tipos definidos por bibliotecas externas y opacos, superando la limitación de asumir estructuras de datos idénticas.
2. Arquitectura RAG para Resolución de Importaciones: Introduce un mecanismo de recuperación de APIs que no solo sugiere la función correcta, sino que resuelve automáticamente las importaciones complejas de Rust (traits, re-exportaciones), eliminando errores de compilación comunes.
3. Validación basada en Adaptadores Sintetizados: Propone un método robusto para cruzar la barrera Go-Rust mediante la síntesis de adaptadores que respetan las invariantes de las bibliotecas, en lugar de intentar forzar la comparación de estructuras de memoria incompatibles.

4. Resultados Experimentales

El sistema se evaluó en 6 repositorios reales de Go con dependencias no triviales (criptografía, derivación de claves, parsing de tiempo), incluyendo proyectos como age, pbkdf2 y argon2.

• Tasa de Éxito: El enfoque logró una tasa de éxito promedio del 95.83% tanto para la compilación como para la equivalencia I/O.
• Mejora Significativa: En comparación con enfoques anteriores (como Oxidizer sin RAG), el sistema mejoró la tasa de éxito en un factor de 2x en promedio y alcanzó el 100% en los casos más dependientes de bibliotecas.
• Ablación:
  • Sin el componente RAG (sin base de conocimiento ni resolución de imports), la tasa de compilación cayó drásticamente (promedio 41.33% para compilación, 0% para equivalencia en funciones con dependencias).
  • Esto demuestra que la resolución de importaciones es tan crítica como la selección de la API correcta.

5. Significado e Impacto

Este trabajo es fundamental para la migración de sistemas críticos a lenguajes seguros como Rust. Demuestra que es posible automatizar la traducción de código que depende de ecosistemas de bibliotecas complejos y opacos, algo que anteriormente se consideraba fuera del alcance de la traducción automática fiable.

Al resolver el problema de la "caja negra" de las bibliotecas externas mediante adaptadores sintetizados y validación de round-trip, el marco CrossCrate permite a las organizaciones migrar sistemas legados de Go a Rust con garantías de corrección funcional, reduciendo el riesgo de introducir bugs durante la transición y facilitando la adopción de Rust en entornos de producción que dependen de bibliotecas de terceros.