O choque inicial ao ligar o Strict Concurrency em projetos iOS maduros

Quem abriu um aplicativo iOS com três ou quatro anos de histórico, ativou SWIFT_STRICT_CONCURRENCY = complete no Xcode e deu Build conhece bem a sensação: a barra lateral explode com centenas de avisos amarelos sobre tipos não conformes a Sendable, closures escapando de atores e singletons globais mutáveis.

O reflexo mais comum das equipes é tentar silenciar tudo em um fim de semana espalhando @unchecked Sendable e @MainActor no projeto inteiro. Esse atalho compila, mas anula justamente o valor do Swift 6 (eliminação de data races em tempo de compilação) e, pior, costuma criar travamentos sutis na thread principal quando trabalho pesado acaba preso no MainActor sem ninguém perceber.

Se você já domina os fundamentos de async/await, Tasks e Actors em Swift, este guia mostra uma ordem prática de migração módulo a módulo que funciona em bases grandes sem paralisar o roadmap de produto.

Princípio de migração segura: nunca ligue o modo Swift 6 no app inteiro de uma vez. Migre de baixo para cima no grafo de dependências (Design System e Core primeiro, rede e persistência depois, módulos de UI por último), usando targeted antes de complete em cada pacote.

A ordem certa de migração no grafo de módulos

Em aplicativos modularizados com Swift Package Manager (como detalho em Arquitetura Modular e Deeplinks em iOS), os módulos folha (modelos de domínio, DTOs, utilitários e camadas de rede) são importados por todo o restante do app. Se um DTO de resposta da API não for Sendable, todos os Interactors e ViewModels acima dele vão gerar avisos em cascata.

Ordem Bottom-Up de Migração para Swift 6 Strict ConcurrencyFASE 1Core & DTOsStructs imutáveisEnums SendableRisco: BaixoFASE 2Rede & StorageActors para cacheIsolamento de tokenRisco: MédioFASE 3Features & UI@MainActor explícitoViewModels / ViewsRisco: MédioFASE 4App TargetLanguage Mode 6Remove @preconcurrencyValidação no CIAtive strict concurrency como erro no CI por pacote concluído para impedir regressões
A migração bottom-up evita efeitos cascata de warnings e permite entregas incrementais em Pull Requests pequenos.

No Package.swift de cada módulo que estiver migrando, ative a verificação completa via swiftSettings enquanto o restante do app ainda compila em Swift 5. Assim, cada módulo finalizado fica blindado no pipeline de CI:

.target(
    name: "NetworkingCore",
    dependencies: ["DomainModels"],
    swiftSettings: [
        .enableUpcomingFeature("StrictConcurrency")
    ]
)

Os 4 diagnósticos mais frequentes do compilador e como corrigir sem gambiarra

1. Variável estática mutável (Static property 'shared' is not concurrency-safe)

Quase todo app antigo tem um gerenciador global do tipo static var shared = SessionManager() ou um cache em dicionário protegido informalmente. No Swift 6, qualquer estado global mutável precisa ser isolado por um ator ou convertido em tipo imutável.

// Antes: estado global exposto a data races
final class TokenStore {
    static let shared = TokenStore()
    private var accessToken: String?
}

// Depois: isolamento real via actor (sem locks manuais)
public actor TokenStore {
    public static let shared = TokenStore()
    private var accessToken: String?

    public func currentToken() -> String? {
        accessToken
    }

    public func update(token: String?) {
        accessToken = token
    }
}

Quando a leitura for síncrona e de altíssima frequência (por exemplo, um flag lido milhares de vezes por segundo em um logger), em vez de forçar await em todo o app, use OSAllocatedUnfairLock (iOS 16+) ou Mutex da biblioteca Synchronization (iOS 18+) encapsulado em uma classe final com @unchecked Sendable documentado e auditável.

2. Captura de valor não-Sendable atravessando fronteira de ator

Um erro muito comum aparece quando um ViewModel anotado com @MainActor dispara uma Task para decodificar um JSON ou processar imagens e passa uma referência mutável de classe para dentro da closure. A correção mais limpa é trocar classes de dados por struct imutáveis e usar a palavra-chave sending (introduzida no Swift 6) quando o objeto muda de dono de forma segura sem precisar ser compartilhado simultaneamente.

public struct StatementItem: Sendable, Equatable, Decodable {
    public let id: String
    public let amountCents: Int
    public let occurredAt: Date
}

@MainActor
final class StatementViewModel: ObservableObject {
    @Published private(set) var items: [StatementItem] = []
    private let service: StatementServiceProtocol

    init(service: StatementServiceProtocol) {
        self.service = service
    }

    func reload() async {
        do {
            // O serviço executa fora da Main Thread e retorna [StatementItem] Sendable
            let fetched = try await service.fetchRecent()
            self.items = fetched
        } catch {
            // Tratamento de erro seguro na Main Thread
        }
    }
}

3. Delegates do UIKit e callbacks de SDKs antigos

Ao implementar delegates como CLLocationManagerDelegate ou callbacks de SDKs binários de terceiros que ainda não foram recompilados com anotações de concorrência (assunto que aprofundo em isolamento de SDKs legados), o compilador reclama que o método do delegate não bate com o isolamento do seu @MainActor.

Nesses casos, combine @preconcurrency import apenas no arquivo adaptador com métodos nonisolated que despacham apenas dados primitivos (Sendable) para o ator destino:

@preconcurrency import CoreLocation

final class LocationBridge: NSObject, CLLocationManagerDelegate, Sendable {
    private let continuation: AsyncStream<CLLocationCoordinate2D>.Continuation

    nonisolated func locationManager(
        _ manager: CLLocationManager,
        didUpdateLocations locations: [CLLocation]
    ) {
        guard let coord = locations.last?.coordinate else { return }
        continuation.yield(coord)
    }
}

4. Evitando gargalos invisíveis no @MainActor

A armadilha silenciosa do Swift 6 é marcar uma classe inteira como @MainActor e deixar dentro dela um método async que faz parse de JSON grande, hash criptográfico ou redimensionamento de imagem. Em Swift, um método async declarado dentro de um @MainActor continua executando na Main Thread até encontrar uma suspensão que mude de executor.

Para trabalho pesado de CPU, mova o processamento para um tipo nonisolated ou um actor dedicado (ou marque o método utilitário como nonisolated quando ele não acessa propriedades da ViewModel). Medir com o instrumento Swift Concurrency no Instruments do Xcode antes e depois da migração evita que você troque um data race raro por engasgos de rolagem a 30 fps.

Comparativo rápido: quando usar cada mecanismo de isolamento

Cenário no appFerramenta recomendadaO que evitar
DTOs, respostas de API e estados de telastruct / enum imutáveis (Sendable automático)class com propriedades var compartilhadas
ViewModels, Views, Coordinators@MainActor explícito na classe ou protocoloDispatchQueue.main.async espalhado em cada método
Cache em memória, refresh de token, fila de eventosactor dedicado com interface assíncronaSingletons globais sem sincronização
Acesso síncrono ultrarrápido (ex.: logger ou métricas)OSAllocatedUnfairLock / Mutex encapsulado@unchecked Sendable sem lock interno real
SDK de terceiros ainda em Swift 5 / Objective-C@preconcurrency import restrito ao AdapterDesabilitar strict concurrency no módulo inteiro

Checklist para validar a migração no CI

Antes de considerar um módulo oficialmente migrado para Swift 6, rode esta sequência no pipeline de integração contínua (e se quiser estimar o ganho de tempo dos seus builds modularizados, teste a Calculadora de ROI de CI/CD Mobile):

  1. Ative -warnings-as-errors apenas nos targets já migrados para impedir que novos PRs reintroduzam avisos de concorrência.
  2. Rode a suíte de testes de integração com Thread Sanitizer (TSan) habilitado em um job noturno: ele captura condições de corrida que eventualmente ficaram escondidas atrás de código Objective-C ou @unchecked Sendable.
  3. Faça uma busca no repositório por @unchecked Sendable e exija um comentário explicando qual mecanismo (lock, fila serial ou imutabilidade garantida) sustenta cada ocorrência.
  4. Verifique no Instruments se o tempo de execução na Main Thread durante o carregamento da tela inicial não aumentou após a introdução de @MainActor.

Migrar para Swift 6 dá trabalho no começo, mas quando o compilador passa a rejeitar data races no próprio PR em vez de você caçar crashes aleatórios no Crashlytics semanas depois, a manutenção do aplicativo fica radicalmente mais previsível.