Guía de supervivencia para Swift 6: Cómo migrar un proyecto grande sin romper el compilador

Publicado el

La llegada de Swift 6 marca uno de los hitos más importantes en la historia del desarrollo para el ecosistema de Apple desde la transición de Objective-C a Swift. No se trata de una actualización menor con azúcar sintáctico; es un cambio de paradigma centrado en la seguridad de concurrencia en tiempo de compilación (data-race safety).

Para proyectos pequeños, la transición puede ser cuestión de un par de tardes. Sin embargo, si trabajas en una aplicación empresarial grande, con cientos de miles de líneas de código, múltiples módulos y decenas de dependencias de terceros, la simple idea de activar Swift 6 puede provocar sudores fríos. Un solo clic en los ajustes de compilación puede generar miles de errores de golpe.

No entres en pánico. En esta guía de supervivencia te mostraremos cómo abordar la migración de un proyecto grande a Swift 6 de forma estratégica, progresiva y, lo más importante, sin romper el compilador ni detener el ritmo de trabajo de tu equipo.

¿Por qué Swift 6 es diferente (y por qué da tanto miedo)?

En versiones anteriores de Swift, el compilador confiaba en que tú, como desarrollador, sabías lo que hacías al compartir datos entre hilos. Si cometías un error, el resultado era un crash aleatorio en producción o un comportamiento errático difícil de depurar (los temidos data races).

Swift 6 cambia las reglas del juego:

  • Concurrencia estricta por defecto: El compilador ahora analiza matemáticamente el flujo de tus datos. Si existe la más mínima posibilidad de que dos hilos accedan al mismo dato mutable a la vez, el código simplemente no compilará.
  • Protocolo Sendable: Se convierte en el ciudadano de primera clase. Todo lo que cruce fronteras de hilos debe ser seguro para enviar (Sendable).
  • Actores globales: @MainActor se vuelve obligatorio para garantizar que todo lo relacionado con la UI ocurra en el hilo principal.

Fase 1: La preparación (Sin salir de Swift 5.10)

El mayor error que puedes cometer es abrir Xcode, cambiar la versión del lenguaje a Swift 6 en los Build Settings y tratar de arreglar los errores sobre la marcha. Ese camino lleva a la frustración. La migración debe prepararse en Swift 5.10.

1. Activa la verificación estricta de concurrencia

Antes de migrar, ve a los Build Settings de tu proyecto en Xcode 15.4 o posterior y busca Strict Concurrency Checking. Por defecto estará en Minimal. Cámbialo a Targeted y, eventualmente, a Complete.

Esto no impedirá que tu código compile, pero transformará los futuros errores de Swift 6 en advertencias (warnings) en Swift 5. El objetivo aquí es identificar la magnitud del problema sin bloquear el desarrollo diario.

2. Audita tus dependencias de terceros

No puedes migrar tu proyecto si las librerías de las que dependes no son compatibles con la concurrencia de Swift 6.

  • Haz una lista de tus dependencias esenciales (Alamofire, Firebase, Kingfisher, etc.).
  • Actualízalas a sus últimas versiones. La mayoría de los mantenedores de código abierto ya han adaptado sus librerías para que sean Sendable-compliant.

Fase 2: Estrategia de migración módulo a módulo (Divide y vencerás)

Si tu proyecto está modularizado (usando Swift Package Manager, CocoaPods o Tuist), tienes una ventaja enorme. No tienes que migrar toda la aplicación a la vez. Swift 5 y Swift 6 pueden coexistir en el mismo binario.

El flujo de trabajo recomendado:

  1. Empieza por las hojas del árbol (módulos base): Migra primero los módulos que no dependan de nadie, como tus utilidades, extensiones o modelos de datos básicos.
  2. Sube en la jerarquía: Una vez que los módulos base compilen en Swift 6 sin advertencias, pasa a los módulos de red, almacenamiento, lógica de negocio y, finalmente, a la capa de UI.
  3. Aísla con @preconcurrency: Si tienes que importar un módulo antiguo que aún no se ha actualizado, usa @preconcurrency import NombreDelModulo. Esto le dice al compilador de Swift 6 que silencie las advertencias de concurrencia provenientes de esa librería.

Los 3 problemas más comunes en Swift 6 y cómo solucionarlos

Durante la migración, te encontrarás con tres tipos de errores de manera repetitiva. Aquí tienes la receta para solucionar cada uno:

1. El error: «Non-sendable type ‘MyClass’ passed in implicitly asynchronous call»

Este error ocurre cuando intentas pasar una clase normal (un tipo por referencia) a través de diferentes hilos o dentro de un bloque Task.

// Código problemático
class UserSession {
    var token: String?
}

La solución:

  • Opción A (Recomendada): Convierte la clase en un struct (tipo por valor). Los structs son inherentemente seguros porque se copian, no se comparten.
  • Opción B: Si necesitas que sea una clase, conviértela en un Actor para serializar el acceso a sus propiedades.
  • Opción C: Si estás seguro de que la clase es inmutable (todas sus propiedades son let y también son Sendable), márcala explícitamente como Sendable.
// Solución con Actor
actor UserSession {
    var token: String?
}

2. El error: «Call to main actor-isolated context…»

Suele ocurrir cuando intentas actualizar la interfaz de usuario desde un contexto asíncrono que no está garantizado que se ejecute en el hilo principal.

// Código problemático
class ProfileViewModel {
    var username: String = ""

    func loadData() async {
        let name = await api.fetchName()
        self.username = name // Error: Acceso fuera del Main Actor
    }
}

La solución:
Anota tu ViewModel o las funciones de UI con @MainActor. Esto garantiza que todas las operaciones de UI y actualizaciones de estado se realicen de forma segura en el hilo principal.

@MainActor
class ProfileViewModel {
    var username: String = ""

    func loadData() async {
        let name = await api.fetchName()
        self.username = name // Seguro: Ahora se ejecuta en el Main Actor
    }
}

3. El dolor de cabeza de los Closures @escaping

Muchos frameworks antiguos de callback asíncronos chocan frontalmente con Swift 6. Si pasas un closure que se ejecuta en otro hilo, el compilador exigirá que sea @Sendable.

// Cómo adaptarlo en Swift 6
func fetchImage(completion: @escaping @Sendable (Result) -> Void) {
    // ...
}

Checklist de supervivencia para el Tech Lead

Si lideras un equipo de desarrollo, la migración a Swift 6 no es solo técnica, es de gestión. Sigue estos pasos para evitar el caos:

  • [ ] Establece una política de «Cero nuevos Warnings»: Antes de activar Swift 6, prohíbe que se fusionen Pull Requests que introduzcan nuevas advertencias de concurrencia en Swift 5.10.
  • [ ] Crea una rama de integración continua (CI) paralela: Configura un pipeline de CI que compile tu proyecto con Swift 6 de forma experimental para medir el progreso sin bloquear la rama principal (main).
  • [ ] Capacita al equipo: Asegúrate de que todos los desarrolladores entiendan la diferencia entre un Actor, un Task, y qué significa que algo sea Sendable. La inversión en formación ahorrará cientos de horas de refactorización errónea.

Conclusión: El premio detrás del esfuerzo

Migrar un proyecto grande a Swift 6 puede parecer una tarea titánica, pero es una inversión que transformará la calidad de tu software. Al superar la barrera del compilador, obtendrás una aplicación libre de bugs de concurrencia en producción, eliminando de raíz esos bloqueos y comportamientos extraños que antes tomaba semanas depurar.

No intentes dar el salto de un solo golpe. Aplica la estrategia de aproximación gradual, apóyate en las herramientas de análisis de Xcode y recuerda: cada warning que resuelvas hoy es un crash menos que experimentarán tus usuarios mañana. ¡Feliz migración!

Deja una respuesta