Что нового в Swift 6 и особенности миграции

static func validate(name: String) throws(ValidationError) {
    guard !name.isEmpty else {
        throw ValidationError.emptyName
    }
    guard name.count > 2 else {
        throw ValidationError.nameTooShort(nameLength: name.count)
    }
}

internal import FrameworkDependency
private import FrameworkDependencyOnlyForThisFile
package import FrameworkDependencyOnlyForFilesInThisPackage

struct UserProfile {
    var name: String
    var age: Int
    var settings: UserSettings // Ошибка: UserSettings не соответствует Sendable
}

func fetchData() throws(NetworkError) -> Data {
    // Эта функция может выбрасывать только ошибки типа NetworkError
}

internal import UIKit
private import MyPrivateFramework
package import SharedUtilities

[1, 2, 3, -1, -2].count(where: { $0 > 0 }) // → 3

[1, 2, 3, -1, -2].contains(where: { $0 > 0 }) // → true

import Synchronization
 
let mutex = Mutex()
mutex.sync {
    // Код, требующий взаимного исключения
}

// Swift 5
let service: ServiceProtocol = MyService()
 
// Swift 6
let service: any ServiceProtocol = MyService()

@Observable
class UserViewModel {
    var name: String = ""
    var age: Int = 0
}

let text = "Swift 6 выглядит многообещающе!"
if let range = text.range(of: "Swift") {
    let modified = text.replacingCharacters(in: range, with: "Новый Swift")
    print(modified) // "Новый Swift 6 выглядит многообещающе!"
}

func fetchUser() -> Result<User, NetworkError> {
    // Реализация
}
 
// Теперь можно проще преобразовывать между Result и throws
try fetchUser().get() // Преобразует Result в User или выбрасывает ошибку

.target(
    name: "WindowMonitoring",
    dependencies: [],
    swiftSettings: [
        .enableUpcomingFeature("SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES")
    ]
)

.target(
    name: "CoreExtensions",
    dependencies: ["Logging"],
    path: "CoreExtensions/Sources",
    swiftSettings: [
        // В Xcode 15 и 16. Уберите '=targeted', чтобы использовать 'complete' по умолчанию
        .enableExperimentalFeature("StrictConcurrency=targeted", .when(platforms: [.macOS]))
    ]
)

// swift-tools-version:6.0
// Версия swift-tools объявляет минимальную версию Swift, необходимую для сборки этого пакета.
 
import PackageDescription

.target(
    name: "WindowMonitoring",
    dependencies: [],
    swiftSettings: [
        .swiftLanguageMode(.v5) // По-прежнему требуется Swift 5
    ]
)

struct Configuration: Sendable {
    let apiKey: String
    let serverURL: URL
}

final class SafeCounter: @unchecked Sendable {
    private let lock = NSLock()
    private var _value = 0
    
    var value: Int {
        get { lock.withLock { _value } }
        set { lock.withLock { _value = newValue } }
    }
}

actor UserManager {
    private let nonSendableObject: NonSendableType
    
    init(nonSendableObject: NonSendableType) {
        self.nonSendableObject = nonSendableObject
    }
    
    func processData() {
        // Безопасный доступ к nonSendableObject внутри актора
    }
}

// Неправильно:
let value = myActor.someProperty
 
// Правильно:
let value = await myActor.someProperty

// Неправильно:
myActor.doSomething()
 
// Правильно:
await myActor.doSomething()

// Неправильно:
@MainActor
class ViewModel {
    func updateUI() {
        // Код обновления UI
    }
    
    func fetchData() { // Ошибка: не помечено как async
        updateUI() // Ошибка: требуется await
    }
}
 
// Правильно:
@MainActor
class ViewModel {
    func updateUI() {
        // Код обновления UI
    }
    
    func fetchData() async {
        await updateUI()
    }
}

-warn-concurrency -strict-concurrency=complete

swiftSettings: [.unsafeFlags(["-warn-concurrency", "-strict-concurrency=complete"])]

.target(
    name: "ModernModule",
    dependencies: [],
    swiftSettings: [.swiftLanguageMode(.v6)]
),
.target(
    name: "LegacyModule",
    dependencies: [],
    swiftSettings: [.swiftLanguageMode(.v5)]
)

// Адаптер для работы с устаревшим кодом
actor LegacyServiceAdapter {
    private let legacyService: LegacyService
    
    init(legacyService: LegacyService) {
        self.legacyService = legacyService
    }
    
    func performOperation() async throws -> Result {
        // Вызов устаревшего синхронного API безопасно внутри актора
        return try legacyService.performOperation()
    }
}

enum NetworkError: Error {
    case connectionFailed
    case invalidResponse
}
 
func fetchData() throws -> Data {
    // Может выбросить любую ошибку
    if !isConnected {
        throw NetworkError.connectionFailed
    }
    return Data()
}
 
// Использование
do {
    let data = try fetchData()
    process(data)
} catch let error as NetworkError {
    handleNetworkError(error)
} catch {
    handleGenericError(error)
}

enum NetworkError: Error {
    case connectionFailed
    case invalidResponse
}
 
func fetchData() throws(NetworkError) -> Data {
    // Может выбросить только NetworkError
    if !isConnected {
        throw NetworkError.connectionFailed
    }
    return Data()
}
 
// Использование
do {
    let data = try fetchData()
    process(data)
} catch {
    // Мы знаем, что это только NetworkError
    handleNetworkError(error as! NetworkError)
}

class UserManager {
    private var users: [User] = []
    private let queue = DispatchQueue(label: "com.app.userManager")
    
    func addUser(_ user: User) {
        queue.async {
            self.users.append(user)
        }
    }
    
    func getUsers() -> [User] {
        var result: [User] = []
        queue.sync {
            result = self.users
        }
        return result
    }
}

actor UserManager {
    private var users: [User] = []
    
    func addUser(_ user: User) {
        users.append(user)
    }
    
    func getUsers() -> [User] {
        return users
    }
}
 
// Использование
func updateUsersList() async {
    let manager = UserManager()
    await manager.addUser(newUser)
    let users = await manager.getUsers()
    updateUI(with: users)
}

// NetworkModule.swift
import Foundation
import Logging // Доступен для всех импортеров NetworkModule
 
class NetworkClient {
    private let logger = Logger()
    // ...
}

// NetworkModule.swift
import Foundation
private import Logging // Доступен только внутри этого файла
 
class NetworkClient {
    private let logger = Logger()
    // ...
}

enum NetworkError: Error {
    case invalidURL
    case requestFailed(statusCode: Int)
    case decodingFailed
    case noInternet
}
 
func fetchUser(id: Int) async throws(NetworkError) -> User {
    guard let url = URL(string: "https://api.example.com/users/\(id)") else {
        throw NetworkError.invalidURL
    }
    
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse else {
        throw NetworkError.requestFailed(statusCode: 0)
    }
    
    guard httpResponse.statusCode == 200 else {
        throw NetworkError.requestFailed(statusCode: httpResponse.statusCode)
    }
    
    do {
        return try JSONDecoder().decode(User.self, from: data)
    } catch {
        throw NetworkError.decodingFailed
    }
}
 
// Использование
func loadUserProfile() async {
    do {
        let user = try await fetchUser(id: currentUserId)
        await MainActor.run {
            updateUI(with: user)
        }
    } catch let error as NetworkError {
        switch error {
        case .noInternet:
            showOfflineMessage()
        case .requestFailed(let statusCode) where statusCode == 404:
            showUserNotFoundMessage()
        default:
            showGenericErrorMessage()
        }
    }
}

// Модель данных
struct User: Sendable, Decodable {
    let id: Int
    let name: String
    let email: String
}
 
// Сервисный слой с актором для безопасности данных
actor UserService {
    private let networkClient: NetworkClient
    
    init(networkClient: NetworkClient) {
        self.networkClient = networkClient
    }
    
    func fetchUser(id: Int) async throws -> User {
        return try await networkClient.fetchUser(id: id)
    }
    
    func updateUser(_ user: User) async throws {
        try await networkClient.updateUser(user)
    }
}
 
// ViewModel с использованием MainActor
@MainActor
class UserViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var error: Error?
    
    private let userService: UserService
    
    init(userService: UserService) {
        self.userService = userService
    }
    
    func loadUser(id: Int) async {
        isLoading = true
        error = nil
        
        do {
            user = try await userService.fetchUser(id: id)
        } catch {
            self.error = error
        }
        
        isLoading = false
    }
    
    func saveUser() async {
        guard let user = user else { return }
        
        isLoading = true
        error = nil
        
        do {
            try await userService.updateUser(user)
        } catch {
            self.error = error
        }
        
        isLoading = false
    }
}
 
// Использование с SwiftUI
struct UserView: View {
    @StateObject private var viewModel: UserViewModel
    let userId: Int
    
    init(userId: Int, userService: UserService) {
        self._viewModel = StateObject(wrappedValue: UserViewModel(userService: userService))
        self.userId = userId
    }
    
    var body: some View {
        VStack {
            if viewModel.isLoading {
                ProgressView()
            } else if let user = viewModel.user {
                Text(user.name)
                Text(user.email)
                Button("Save") {
                    Task {
                        await viewModel.saveUser()
                    }
                }
            } else if let error = viewModel.error {
                Text("Error: \(error.localizedDescription)")
            }
        }
        .task {
            await viewModel.loadUser(id: userId)
        }
    }
}

// Неоптимально - много мелких акторов
actor UserCache { /* ... */ }
actor PostCache { /* ... */ }
actor ImageCache { /* ... */ }
actor SettingsManager { /* ... */ }
 
// Лучше - объединить в один актор для связанной функциональности
actor CacheManager {
    private var userCache = [Int: User]()
    private var postCache = [Int: Post]()
    private var imageCache = [URL: UIImage]()
    
    func getUser(id: Int) -> User? { return userCache[id] }
    func cacheUser(_ user: User) { userCache[user.id] = user }
    
    func getPost(id: Int) -> Post? { return postCache[id] }
    func cachePost(_ post: Post) { postCache[post.id] = post }
    
    // И так далее...
}

// Неоптимально - лишняя асинхронность
actor DataProcessor {
    func processItems(_ items: [Item]) async -> [ProcessedItem] {
        var results = [ProcessedItem]()
        for item in items {
            let processed = await processItem(item) // Лишний await, если processItem не требует асинхронности
            results.append(processed)
        }
        return results
    }
    
    func processItem(_ item: Item) async -> ProcessedItem {
        // Простая синхронная операция, не требующая асинхронности
        return ProcessedItem(value: item.value * 2)
    }
}
 
// Лучше
actor DataProcessor {
    func processItems(_ items: [Item]) -> [ProcessedItem] {
        return items.map { ProcessedItem(value: $0.value * 2) }
    }
}

// Вместо создания актора для одной функции
func processDataSafely(_ data: [Int]) async -> Int {
    // Эта функция автоматически изолирована в своем собственном домене
    return data.reduce(0, +)
}
 
// Использование
let result = await processDataSafely(numbers)

// Неоптимально - много переключений
await operation1()
await operation2()
await operation3()
 
// Лучше - одна группа операций
await withTaskGroup(of: Void.self) { group in
    group.addTask { await operation1() }
    group.addTask { await operation2() }
    group.addTask { await operation3() }
}

func processLargeData(_ data: [Int]) async -> Int {
    actor Counter {
        var count = 0
        func increment(by value: Int) { count += value }
        func getCount() -> Int { return count }
    }
    
    let counter = Counter()
    
    // Параллельная обработка с общим счетчиком
    await withTaskGroup(of: Void.self) { group in
        let chunkSize = data.count / 4
        for i in 0..<4 {
            let start = i * chunkSize
            let end = i == 3 ? data.count : (i + 1) * chunkSize
            
            group.addTask {
                let sum = data[start..<end].reduce(0, +)
                await counter.increment(by: sum)
            }
        }
    }
    
    return await counter.getCount()
}