Lanzamiento de Swift 6 - Seguridad completa de concurrencia

Descripción general de Swift 6

En septiembre de 2024, Swift 6 fue lanzado junto con Xcode 16. La característica más importante de esta versión es la capacidad de prevenir completamente los data races en tiempo de compilación.

Referencia: Swift.org - Swift 6

Prevención completa de data races

Modo de lenguaje Swift 6

En Swift 6, los data races se convierten en errores de compilación.

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

var counter = 0

func increment() async {
    counter += 1  // Error: posible data race
}

Aplicación estricta de Sendable

// No se pueden pasar objetos no Sendable a contextos concurrentes
class UnsafeClass {
    var value = 0
}

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

    Task {
        obj.value += 1  // Error: UnsafeClass no es Sendable
    }
}

// Solución 1: Conformar a Sendable
final class SafeClass: Sendable {
    let value: Int  // Hacerlo inmutable
    init(value: Int) { self.value = value }
}

// Solución 2: Usar actor
actor Counter {
    var value = 0
    func increment() { value += 1 }
}

Referencia: Swift Concurrency

Typed throws

Ahora es posible especificar explícitamente el tipo de error.

// 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
}

// El tipo se conoce en el lado de la llamada
do {
    let data = try parse()
} catch {
    // El tipo de error es ParseError
    switch error {
    case .invalidFormat:
        print("Error de formato")
    case .emptyInput:
        print("La entrada está vacía")
    }
}

Funciones que nunca fallan usando never

// Nunca lanza un error
func safeParse() throws(Never) -> Data {
    return Data()
}

// Se puede llamar sin try
let data = safeParse()

Enteros 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

Un subconjunto de Swift para entornos con 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)
        }
    }
}

# Compilar con Embedded Swift
swiftc -enable-experimental-feature Embedded -target armv7em-none-eabi main.swift

Referencia: Embedded Swift Vision

Mejoras en la interoperabilidad con C++

De C++ a Swift

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

// Uso desde Swift
import CppCounter

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

De Swift a C++

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

// Llamada desde C++
#include "MyModule-Swift.h"

int result = swiftFunction();

Referencia: Swift C++ Interoperability

Mutex y Atomic para sincronización

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)

Migración gradual

Advertencias en modo Swift 5

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

// Habilitar advertencias de concurrencia
swiftSettings: [
    .enableUpcomingFeature("StrictConcurrency")
]

Migración por archivo

// Solo archivos específicos en modo Swift 6
// Agregar al inicio del archivo
// swift-tools-version: 6.0

Integración con Xcode 16

Configuración de compilación

SWIFT_VERSION = 6.0
SWIFT_STRICT_CONCURRENCY = complete

Nuevas advertencias y sugerencias de corrección

// Xcode sugiere correcciones automáticas
class MyClass {
    var data: [Int] = []

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

Mejoras de rendimiento

Resumen

Swift 6 eleva la seguridad del lenguaje a un nuevo nivel.

• Prevención de data races: Detección completa en tiempo de compilación
• Typed throws: Mejora en el manejo de errores
• Enteros de 128 bits: Soporte para números grandes
• Embedded Swift: Soporte para sistemas embebidos
• Interoperabilidad C++: Integración más profunda

Los proyectos existentes pueden migrar gradualmente, y también se mantiene la compatibilidad con Swift 5.