Lançamento do Swift 6 - Segurança Completa de Concorrência

Visão Geral do Swift 6

Em setembro de 2024, o Swift 6 foi lançado junto com o Xcode 16. A principal característica desta versão é a capacidade de prevenir completamente data races em tempo de compilação.

Referência: Swift.org - Swift 6

Prevenção Completa de Data Races

Modo de Linguagem Swift 6

No Swift 6, data races se tornam erros de compilação.

// Habilitar modo Swift 6 no Package.swift
// swift-tools-version: 6.0

var counter = 0

func increment() async {
    counter += 1  // Erro: possível data race
}

Rigor de Sendable

// Objetos não-Sendable não podem ser passados para contextos concorrentes
class UnsafeClass {
    var value = 0
}

func example() async {
    let obj = UnsafeClass()

    Task {
        obj.value += 1  // Erro: UnsafeClass não é Sendable
    }
}

// Solução 1: Conformar com Sendable
final class SafeClass: Sendable {
    let value: Int  // Tornar imutável
    init(value: Int) { self.value = value }
}

// Solução 2: Usar actors
actor Counter {
    var value = 0
    func increment() { value += 1 }
}

Referência: Swift Concurrency

Typed Throws

Agora é possível especificar explicitamente o tipo do erro.

// Tradicional: any error
func legacyParse() throws -> Data {
    throw ParseError.invalidFormat
}

// Swift 6: typed throws
enum ParseError: Error {
    case invalidFormat
    case emptyInput
}

func parse() throws(ParseError) -> Data {
    throw .invalidFormat
}

// O chamador conhece o tipo
do {
    let data = try parse()
} catch {
    // O tipo de error é ParseError
    switch error {
    case .invalidFormat:
        print("Erro de formato")
    case .emptyInput:
        print("Entrada vazia")
    }
}

Funções que nunca falham usando never

// Nunca lança erro
func safeParse() throws(Never) -> Data {
    return Data()
}

// Pode ser chamada sem try
let data = safeParse()

Inteiros de 128 bits

let big: Int128 = 170_141_183_460_469_231_731_687_303_715_884_105_727
let ubig: UInt128 = 340_282_366_920_938_463_463_374_607_431_768_211_455

print(big.bitWidth)  // 128

Embedded Swift

Um subconjunto do Swift para ambientes com recursos limitados (como microcontroladores).

// Código para Embedded Swift
@main
struct LEDBlink {
    static func main() {
        let led = DigitalOutput(pin: 13)

        while true {
            led.toggle()
            sleep(milliseconds: 500)
        }
    }
}

# Build com Embedded Swift
swiftc -enable-experimental-feature Embedded -target armv7em-none-eabi main.swift

Referência: Embedded Swift Vision

Melhorias na Interoperabilidade com C++

De C++ para Swift

// Header C++
class CppCounter {
public:
    CppCounter(int initial);
    void increment();
    int getValue() const;
private:
    int value;
};

// Uso no Swift
import CppCounter

let counter = CppCounter(42)
counter.increment()
print(counter.getValue())  // 43

De Swift para C++

// Swift
@_expose(Cxx)
public func swiftFunction() -> Int {
    return 42
}

// Chamada do C++
#include "MyModule-Swift.h"

int result = swiftFunction();

Referência: Swift C++ Interoperability

Mutex e Atomic para Sincronização

import Synchronization

// Mutex
let mutex = Mutex(initialValue: 0)

mutex.withLock { value in
    value += 1
}

// Atomic
let atomic = Atomic<Int>(0)

atomic.wrappingAdd(1, ordering: .relaxed)
let current = atomic.load(ordering: .acquiring)

Migração Gradual

Avisos no Modo Swift 5

// Package.swift
let package = Package(
    swiftLanguageVersions: [.v5],  // Ainda Swift 5
    // ...
)

// Habilitar avisos de concorrência
swiftSettings: [
    .enableUpcomingFeature("StrictConcurrency")
]

Migração por Arquivo

// Apenas arquivos específicos no modo Swift 6
// Adicionar no início do arquivo
// swift-tools-version: 6.0

Integração com Xcode 16

Configurações de Build

SWIFT_VERSION = 6.0
SWIFT_STRICT_CONCURRENCY = complete

Novos Avisos e Sugestões de Correção

// O Xcode sugere correções automáticas
class MyClass {
    var data: [Int] = []

    func process() async {
        // Aviso + Fix-it: adicionar @MainActor
        data.append(1)
    }
}

Melhorias de Desempenho

Resumo

O Swift 6 elevou a segurança da linguagem a um novo patamar.

• Prevenção de data race: Detecção completa em tempo de compilação
• Typed throws: Melhoria no tratamento de erros
• Inteiros de 128 bits: Suporte para números grandes
• Embedded Swift: Suporte para sistemas embarcados
• Interoperabilidade C++: Integração mais profunda

Projetos existentes podem migrar gradualmente, e a compatibilidade com Swift 5 é mantida.