Swift 6.1 - улучшения параллелизма, Package Traits и многое другое

@MainActor
protocol IsolatedStruct {
  // тут мутабельное состояние, требующее изоляции
}
 
nonisolated extension IsolatedStruct: CustomStringConvertible, Equatable {
  // а тут методы, не требующие изоляции
  var description: String {
    // ...
  }
  
  static func ==(lhs: Self, rhs: Self) -> Bool {
    // ...
  }
}

let tuple = (1, 2, 3,) // теперь работает
func someFunc(param1: Int, param2: String,) { } // и это тоже
let closure = { [weak self, weak delegate,] in } // и это

@MainActor
class DocumentManager {
    private var documents: [Document] = []
    
    func loadDocuments() async {
        // Загрузка с сервера
    }
    
    nonisolated func validateDocument(_ doc: Document) -> Bool {
        // Не требует изоляции
    }
    
    nonisolated func calculateStatistics() -> Statistics {
        // Не требует изоляции
    }
}

@MainActor
class DocumentManager {
    private var documents: [Document] = []
    
    func loadDocuments() async {
        // Загрузка с сервера
    }
}
 
nonisolated extension DocumentManager {
    func validateDocument(_ doc: Document) -> Bool {
        // Логика валидации
    }
    
    func calculateStatistics() -> Statistics {
        // Вычисление статистики
    }
}

// Package.swift
let package = Package(
    name: "BankingApp",
    traits: ["VIPFeatures"],
    // ...
)

@MainActor
struct ContentView: View {
    @State private var data: [Item] = []
    
    var body: some View {
        List(data) { item in
            Text(item.name)
        }
        .task {
            await loadData()
        }
    }
}
 
nonisolated extension ContentView {
    func processData(_ rawData: [RawItem]) -> [Item] {
        // Тяжелая обработка, не требующая MainActor
        return rawData.map { ... }
    }
}

actor ImageLoader {
    private var cache: [URL: UIImage] = [:]
    
    func loadImage(from url: URL) async throws -> UIImage {
        if let cachedImage = cache[url] {
            return cachedImage
        }
        
        let (data, _) = try await URLSession.shared.data(from: url)
        guard let image = UIImage(data: data) else {
            throw ImageError.invalidData
        }
        
        cache[url] = image
        return image
    }
    
    func clearCache() {
        cache.removeAll()
    }
    
    func getCacheSize() -> Int {
        return cache.count
    }
}

nonisolated func getCacheSize() -> Int {
    return cache.count
}

actor ImageLoader {
    private var cache: [URL: UIImage] = [:]
    
    func loadImage(from url: URL) async throws -> UIImage {
        // реализация как выше
    }
    
    func clearCache() {
        cache.removeAll()
    }
}
 
nonisolated extension ImageLoader {
    var cacheCount: Int {
        // Теперь это ошибка, но у нас есть решение!
        // return cache.count
    }
    
    func hasCachedImage(for url: URL) async -> Bool {
        // Используем await для доступа к изолированному состоянию
        return await cache[url] != nil
    }
}

actor ImageLoader {
    // ... как выше
    
    func getCacheSize() -> Int {
        return cache.count
    }
}
 
nonisolated extension ImageLoader {
    func cacheCount() async -> Int {
        return await getCacheSize()
    }
    
    func hasCachedImage(for url: URL) async -> Bool {
        return await cache[url] != nil
    }
}

class ViewModel {
    @MainActor var uiState: UIState = .initial
    
    @MainActor func updateUI() {
        // обновляем интерфейс
    }
    
    nonisolated func performHeavyComputation() -> Result {
        // тяжелые вычисления, не трогающие UI
    }
}

@MainActor
class ViewModel {
    var uiState: UIState = .initial
    
    func updateUI() {
        // обновляем интерфейс
    }
}
 
nonisolated extension ViewModel {
    func performHeavyComputation() -> Result {
        // тяжелые вычисления, не трогающие UI
    }
}

actor NetworkService {
    private var session: URLSession
    private var authToken: String?
    
    init(session: URLSession = .shared) {
        self.session = session
    }
    
    func fetchData<T: Decodable>(from endpoint: Endpoint) async throws -> T {
        guard let authToken else {
            throw NetworkError.unauthorized
        }
        
        var request = endpoint.urlRequest
        request.addValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization")
        
        let (data, response) = try await session.data(for: request)
        // Проверка ответа, декодирование и т.д.
        return try JSONDecoder().decode(T.self, from: data)
    }
    
    func login(username: String, password: String) async throws {
        // Логика авторизации
        self.authToken = "полученный токен"
    }
    
    func buildURL(for endpoint: Endpoint) -> URL {
        // Формирование URL - это чистая функция без доступа к состоянию
        return URL(string: "https://api.example.com/\(endpoint.path)")!
    }
}

nonisolated func buildURL(for endpoint: Endpoint) -> URL {
    return URL(string: "https://api.example.com/\(endpoint.path)")!
}

actor NetworkService {
    private var session: URLSession
    private var authToken: String?
    
    init(session: URLSession = .shared) {
        self.session = session
    }
    
    func fetchData<T: Decodable>(from endpoint: Endpoint) async throws -> T {
        // Тот же код, что и выше
    }
    
    func login(username: String, password: String) async throws {
        // Тот же код, что и выше
    }
}
 
nonisolated extension NetworkService {
    func buildURL(for endpoint: Endpoint) -> URL {
        return URL(string: "https://api.example.com/\(endpoint.path)")!
    }
    
    func validateEndpoint(_ endpoint: Endpoint) -> Bool {
        // Еще одна функция, не требующая изоляции
        return endpoint.path.isEmpty == false
    }
    
    func createRequest(for endpoint: Endpoint) -> URLRequest {
        // И еще одна
        var request = URLRequest(url: buildURL(for: endpoint))
        request.httpMethod = endpoint.method.rawValue
        return request
    }
}

func processItems() async {
    let items = await fetchItems()
    
    // Раньше компилятор часто требовал явного await перед map,
    // даже если внутри использовался Task
    let processedItems = items.map { item in
        Task {
            await processItem(item)
        }
    }
    
    // Ожидаем завершения всех задач
    for task in processedItems {
        _ = await task.value
    }
}

func processInParallel() async throws -> [Result] {
    try await withThrowingTaskGroup(of: Result.self) { group in
        for item in items {
            group.addTask {
                return try await processItem(item)
            }
        }
        
        var results: [Result] = []
        for try await result in group {
            results.append(result)
        }
        return results
    }
}

func processInParallel() async throws -> [Result] {
    try await withThrowingTaskGroup(of: Result.self) { group in
        for item in items {
            group.addTask {
                return try await processItem(item)
            }
        }
        
        // Более простой способ сбора результатов
        return try await group.reduce(into: []) { $0.append($1) }
    }
}

// Старый способ
if let value = await getOptionalValue() {
    await processValue(value)
}
 
// Новый способ
await getOptionalValue().map { value in
    await processValue(value)
}

func processData(@borrowing data: LargeData) -> Result {
    // Используем data, но не меняем ее владельца
    return computeResult(from: data)
}
 
func consumeData(@consuming data: LargeData) -> Result {
    // Забираем владение data, исходный объект больше недоступен
    defer {
        // Какая-то логика освобождения ресурсов, если нужно
    }
    return transformData(data)
}

actor DataProcessor {
    private var sharedData: [String: LargeData] = [:]
    
    func processEntry(key: String, @borrowing processor: (LargeData) -> Result) async -> Result? {
        guard let data = sharedData[key] else {
            return nil
        }
        
        // Безопасно используем данные внутри актора
        return processor(data)
    }
    
    func consumeEntry(key: String) -> LargeData? {
        guard let data = sharedData[key] else {
            return nil
        }
        
        // Явно удаляем данные из актора
        sharedData[key] = nil
        return data
    }
}

@moveOnly struct LargeBuffer {
    var data: [UInt8]
    
    // Инициализатор, конструирующий буфер
    init(size: Int) {
        self.data = Array(repeating: 0, count: size)
    }
    
    // Метод, передающий владение этим объектом
    consuming func passOwnership() -> Self {
        return self
    }
}

func processVideoFrames(@consuming frames: [VideoFrame]) -> [ProcessedFrame] {
    return frames.map { frame in
        // Преобразование каждого фрейма
        ProcessedFrame(from: frame)
    }
    // После завершения функции оригинальные фреймы автоматически освобождаются
}

actor ConfigurationManager {
  private var config: [String: Any] = [:]
  
  func updateConfig(key: String, value: Any) {
      config[key] = value
  }
  
  func getConfigValue(key: String) -> Any? {
      return config[key]
  }
  
  func processConfig(with handler: ([String: Any]) -> Void) {
      handler(config) // Потенциальная проблема!
  }
}

actor ConfigurationManager {
  private var config: [String: Any] = [:]
  
  func updateConfig(key: String, value: Any) {
      config[key] = value
  }
  
  func getConfigValue(key: String) -> Any? {
      return config[key]
  }
  
  func processConfig(with handler: ([String: Any]) -> Void) {
      // Создаем копию конфигурации перед передачей
      let configCopy = config
      handler(configCopy)
  }
}

protocol DataProvider {
  func getData() -> Data
}
 
actor DataManager {
  private var providers: [DataProvider] = []
  
  func addProvider(_ provider: DataProvider) {
      providers.append(provider)
  }
  
  func processAllData<T>(transformer: (Data) -> T) -> [T] {
      return providers.map { provider in
          transformer(provider.getData())
      }
  }
}

actor ResourceManager {
  private var resources: [Resource] = []
  
  func addResource(_ resource: Resource) {
      resources.append(resource)
  }
  
  func getSafeResources() -> [Resource] {
      // Все ресурсы неизменяемые, но компилятор этого не знает
      return resources
  }
}

@frozen struct Resource {
  let id: UUID
  let data: Data
}
 
actor ResourceManager {
  private var resources: [Resource] = []
  
  func addResource(_ resource: Resource) {
      resources.append(resource)
  }
  
  nonisolated func getSafeResources() -> [Resource] {
      // Теперь компилятор знает, что Resource неизменяемый
      return resources
  }
}

// Старый способ
let task = Task(priority: .userInitiated) {
    do {
        let result = try await performHeavyOperation()
        return result
    } catch {
        return fallbackValue
    }
}
 
// Новый способ в Swift 6.1
let task = Task(priority: .userInitiated) {
    return try await performHeavyOperation() 
        ?? fallbackValue
}

func fetchDataWithTimeout() async throws -> Data {
    try await Task.timeout(seconds: 5.0) {
        return try await networkService.fetchData()
    }
}

// В начале приложения
RaceDetector.enable()
 
// Или для отдельных частей кода
RaceDetector.withDetection {
    // Код, который нужно проверить на гонки данных
}

func performLowLevelSynchronization() {
    // Устанавливаем барьер чтения/записи
    Memory.barrier(.readWrite)
    
    // Критическая секция
    unsafeSharedData.modify()
    
    // Еще один барьер для синхронизации
    Memory.barrier(.readWrite)
}

struct ConcurrencyVariation: TestScoping {
    enum Variation {
        case sequential
        case parallel
        case interleaved
    }
    
    let variation: Variation
    
    func apply<T>(_ work: () async throws -> T) async rethrows -> T {
        switch variation {
        case .sequential:
            // Последовательное выполнение
            return try await work()
        case .parallel:
            // Параллельное выполнение
            return try await withTaskGroup(of: T.self) { group in
                group.addTask {
                    return try await work()
                }
                return try await group.next()!
            }
        case .interleaved:
            // Чередующееся выполнение
            // Реализация с искусственными точками приостановки
            return try await work()
        }
    }
}
 
// Использование в тестах
func testDataRace() async {
    for variation in [.sequential, .parallel, .interleaved] {
        await test(scoping: ConcurrencyVariation(variation: variation)) {
            // Тестовый код, который будет выполнятся в разных вариациях
        }
    }
}

func testAsyncErrorHandling() async {
    let error = await #expect(throws: {
        try await functionThatThrows()
    })
    
    // Теперь можно проверить детали ошибки
    XCTAssertTrue(error is NetworkError)
}

func loadDashboardData() async throws -> DashboardData {
    async let userProfile = userService.fetchProfile()
    async let notifications = notificationService.fetchLatest(limit: 10)
    async let statistics = statsService.fetchWeeklySummary()
    
    return try await DashboardData(
        profile: userProfile,
        notifications: notifications,
        stats: statistics
    )
}

@MainActor
class ViewModel {
    private let dataProcessor = DataProcessor()
    
    func updateUI() async {
        let processedData = await dataProcessor.processData()
        // Обновление UI
        updateDisplay(with: processedData)
    }
}
 
actor DataProcessor {
    func processData() -> ProcessedData {
        // Длительная обработка
        return result
    }
}

class DataManager {
    private var tasks: [Task<Void, Never>] = []
    
    func startBackgroundRefresh() {
        let task = Task {
            while !Task.isCancelled {
                do {
                    try await refreshData()
                    try await Task.sleep(nanoseconds: 60_000_000_000) // 1 минута
                } catch {
                    handleError(eror) // Опечатка намеренная
                }
            }
        }
        
        tasks.append(task)
    }
    
    deinit {
        tasks.forEach { $0.cancel() }
    }
}

actor ServiceA {
    let serviceB: ServiceB
    
    init(serviceB: ServiceB) {
        self.serviceB = serviceB
    }
    
    func process() async {
        await serviceB.validate()
    }
}
 
actor ServiceB {
    let serviceA: ServiceA
    
    init(serviceA: ServiceA) {
        self.serviceA = serviceA
    }
    
    func validate() async {
        await serviceA.process()
    }
}

func setupLongRunningTask() {
    Task {
        // Сильный захват self
        while true {
            self.processNextBatch()
            try? await Task.sleep(nanoseconds: 1_000_000_000)
        }
    }
}

class NetworkService {
    private let session: URLSession
    private let baseURL: URL
    private var authToken: String?
    private let lock = NSLock()
    
    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
    }
    
    func fetchData<T: Decodable>(endpoint: String) async throws -> T {
        // Блокировка для безопасного доступа к authToken
        lock.lock()
        guard let token = authToken else {
            lock.unlock()
            throw NetworkError.unauthorized
        }
        lock.unlock()
        
        let url = baseURL.appendingPathComponent(endpoint)
        var request = URLRequest(url: url)
        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        
        let (data, response) = try await session.data(for: request)
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.invalidResponse
        }
        
        return try JSONDecoder().decode(T.self, from: data)
    }
    
    func authenticate(username: String, password: String) async throws {
        // Код аутентификации, который устанавливает authToken
        // ...
        lock.lock()
        self.authToken = "полученный токен"
        lock.unlock()
    }
    
    func buildURL(endpoint: String) -> URL {
        return baseURL.appendingPathComponent(endpoint)
    }
}

actor NetworkService {
    private let session: URLSession
    private let baseURL: URL
    private var authToken: String?
    
    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
    }
    
    func fetchData<T: Decodable>(endpoint: String) async throws -> T {
        guard let token = authToken else {
            throw NetworkError.unauthorized
        }
        
        let url = baseURL.appendingPathComponent(endpoint)
        var request = URLRequest(url: url)
        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        
        let (data, response) = try await session.data(for: request)
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.invalidResponse
        }
        
        return try JSONDecoder().decode(T.self, from: data)
    }
    
    func authenticate(username: String, password: String) async throws {
        // Код аутентификации
        // ...
        self.authToken = "полученный токен"
    }
}
 
// Методы, не требующие изоляции, выносим в расширение
nonisolated extension NetworkService {
    func buildURL(endpoint: String) -> URL {
        return baseURL.appendingPathComponent(endpoint)
    }
    
    func createRequest(endpoint: String) -> URLRequest {
        return URLRequest(url: buildURL(endpoint: endpoint))
    }
}

func loadUserDashboard() async throws -> DashboardViewModel {
    let userID = currentUserID ?? await fetchCurrentUserID()
    
    async let profileTask = fetchUserProfile(userID: userID)
    async let postsTask = fetchRecentPosts(userID: userID)
    async let friendsTask = fetchFriends(userID: userID)
    
    do {
        let profile = try await profileTask
        let posts = try await postsTask
        let friends = try await friendsTask
        
        return DashboardViewModel(
            profile: profile,
            posts: posts,
            friends: friends
        )
    } catch {
        // Обработка ошибок
        throw error
    }
}

func loadUserDashboard() async throws -> DashboardViewModel {
    let userID = currentUserID ?? await fetchCurrentUserID()
    
    return try await withThrowingTaskGroup(of: DashboardComponent.self) { group in
        group.addTask { return .profile(await fetchUserProfile(userID: userID)) }
        group.addTask { return .posts(await fetchRecentPosts(userID: userID)) }
        group.addTask { return .friends(await fetchFriends(userID: userID)) }
        
        var profile: UserProfile?
        var posts: [Post] = []
        var friends: [Friend] = []
        
        for try await component in group {
            switch component {
            case .profile(let userProfile):
                profile = userProfile
            case .posts(let userPosts):
                posts = userPosts
            case .friends(let userFriends):
                friends = userFriends
            }
        }
        
        guard let unwrappedProfile = profile else {
            throw DashboardError.missingProfile
        }
        
        return DashboardViewModel(
            profile: unwrappedProfile,
            posts: posts,
            friends: friends
        )
    }
}
 
// Вспомогательное перечисление для группировки результатов
enum DashboardComponent {
    case profile(UserProfile)
    case posts([Post])
    case friends([Friend])
}

// Старый код
class DataProcessor {
    func processLargeData(_ data: Data) -> ProcessedResult {
        // Копирование данных для безопасности
        let dataCopy = data
        let result = heavyProcessing(dataCopy)
        return result
    }
    
    private func heavyProcessing(_ data: Data) -> ProcessedResult {
        // Сложная обработка
        return ProcessedResult()
    }
}
 
// Использование
let largeData = fetchLargeData()
let result = processor.processLargeData(largeData)

class DataProcessor {
    func processLargeData(@consuming data: Data) -> ProcessedResult {
        // Забираем владение данными, избегая копирования
        let result = heavyProcessing(data)
        // data больше не используется после этой точки
        return result
    }
    
    private func heavyProcessing(_ data: Data) -> ProcessedResult {
        // Сложная обработка
        return ProcessedResult()
    }
}
 
// Использование остается тем же
let largeData = fetchLargeData()
let result = processor.processLargeData(largeData)
// largeData больше недоступно здесь, если это необходимо

// Package.swift
let package = Package(
    name: "MyUtilities",
    platforms: [.iOS(.v15), .macOS(.v12)],
    products: [
        .library(name: "MyUtilities", targets: ["MyUtilities"])
    ],
    targets: [
        .target(
            name: "MyUtilities",
            dependencies: [],
            swiftSettings: [
                .define("iOS", .when(platforms: [.iOS])),
                .define("macOS", .when(platforms: [.macOS]))
            ]
        )
    ]
)
 
// В коде библиотеки
#if iOS
public func setupForDevice() {
    // iOS-специфичный код
}
#elseif macOS
public func setupForDevice() {
    // macOS-специфичный код
}
#endif

// Package.swift
let package = Package(
    name: "MyUtilities",
    traits: ["iOS", "macOS"],
    platforms: [.iOS(.v15), .macOS(.v12)],
    products: [
        .library(
            name: "MyUtilities",
            targets: ["MyUtilities"],
            traits: ["iOS", "macOS"]
        )
    ],
    targets: [
        .target(
            name: "MyUtilities",
            dependencies: []
        )
    ]
)
 
// В коде теперь можно использовать более элегантный подход
@available(trait: iOS)
public func setupForiOS() {
    // iOS-специфичный код
}
 
@available(trait: macOS)
public func setupForMacOS() {
    // macOS-специфичный код
}
 
// Общий интерфейс
public func setupForDevice() {
    #if os(iOS)
    setupForiOS()
    #elseif os(macOS)
    setupForMacOS()
    #endif
}

actor ImageProcessor {
    private let device: MTLDevice
    private let commandQueue: MTLCommandQueue
    
    init?() {
        guard let device = MTLCreateSystemDefaultDevice(),
              let commandQueue = device.makeCommandQueue() else {
            return nil
        }
        
        self.device = device
        self.commandQueue = commandQueue
    }
    
    func applyFilter(to pixelBuffer: CVPixelBuffer) async throws -> CVPixelBuffer {
        let width = CVPixelBufferGetWidth(pixelBuffer)
        let height = CVPixelBufferGetHeight(pixelBuffer)
        
        // Создаем текстуру из входного буфера
        let textureDescriptor = MTLTextureDescriptor.texture2DDescriptor(
            pixelFormat: .bgra8Unorm,
            width: width,
            height: height,
            mipmapped: false
        )
        
        guard let texture = CVMetalTextureGetTexture(CVMetalTextureRef) else {
            throw ProcessingError.textureCreationFailed
        }
        
        // Создаем выходной буфер
        var outputBuffer: CVPixelBuffer?
        CVPixelBufferCreate(
            kCFAllocatorDefault,
            width,
            height,
            kCVPixelFormatType_32BGRA,
            nil,
            &outputBuffer
        )
        
        guard let outputBuffer = outputBuffer else {
            throw ProcessingError.outputBufferCreationFailed
        }
        
        // Запускаем обработку на GPU
        return try await Task.detached {
            let commandBuffer = self.commandQueue.makeCommandBuffer()!
            
            // Создаем фильтр (например, размытие по Гауссу)
            let gaussianBlur = MPSImageGaussianBlur(
                device: self.device,
                sigma: 5.0
            )
            
            // Применяем фильтр
            gaussianBlur.encode(
                commandBuffer: commandBuffer,
                sourceTexture: texture,
                destinationTexture: outputTexture
            )
            
            // Запускаем и ждем выполнения
            commandBuffer.commit()
            commandBuffer.waitUntilCompleted()
            
            return outputBuffer
        }.value
    }
}

nonisolated extension ImageProcessor {
    func prepareBuffer(@consuming pixelBuffer: CVPixelBuffer) -> MTLBuffer {
        // Создаем Metal буфер без лишнего копирования
        let size = CVPixelBufferGetDataSize(pixelBuffer)
        let buffer = device.makeBuffer(
            bytesNoCopy: CVPixelBufferGetBaseAddress(pixelBuffer)!,
            length: size,
            options: .storageModeShared,
            deallocator: nil
        )
        
        // pixelBuffer больше не используется здесь
        return buffer!
    }
}

func processImageBatch(_ images: [UIImage]) async throws -> [UIImage] {
    try await withThrowingTaskGroup(of: (Int, UIImage).self) { group in
        for (index, image) in images.enumerated() {
            group.addTask {
                let processedImage = try await self.processWithMetal(image)
                return (index, processedImage)
            }
        }
        
        var results = Array<UIImage?>(repeating: nil, count: images.count)
        for try await (index, image) in group {
            results[index] = image
        }
        
        return results.compactMap { $0 }
    }
}
 
private func processWithMetal(_ image: UIImage) async throws -> UIImage {
    // Реализация обработки отдельного изображения с использованием Metal
}