WWDC26: всё, что нужно знать iOS-разработчику

// Было:
extension Mission {
    @available(macOS 27, iOS 27, watchOS 27, tvOS 27, visionOS 27, *)
    func showStatus() { ... }

    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS) || os(visionOS)
    func makeLiveActivityWidget() -> some Widget { ... }
    #endif
}

// Стало:
extension Mission {
    @available(anyAppleOS 27, *)
    func showStatus() { ... }

    #if os(anyAppleOS)
    func makeLiveActivityWidget() -> some Widget { ... }
    #endif
}

@diagnose(DeprecatedDeclaration, as: ignored, reason: "Flying with surplus hardware")
func makeApolloSoyuzMission() -> Mission { ... }

@diagnose(StrictMemorySafety, as: warning)
func uplinkCommand(from receiver: inout Receiver, to computer: inout Computer) { ... }

@diagnose(ErrorInFutureSwiftVersion, as: error)
func fetchPosition() -> (x: Double, y: Double, z: Double) {
    return self.rotation
}

// Module selectors: однозначный выбор модуля при коллизии имён
import Rocket
import GiftShopToys

let rocket1 = SaturnV()          // неоднозначно: Rocket или GiftShopToys?
let rocket3 = Rocket::SaturnV()  // ровно тот, что нужен

// @C: безопасная обёртка для C через Span вместо pointer + count
@C
func getAverageLaunchWindowLength(_ windows: Span<LaunchWindow>) -> Double { ... }

// InlineArray — массив фиксированной длины на стеке
func histogram<Values>(of values: Values) -> [256 of Int]
    where Values: Sequence<UInt8> {
    var result = makeInts(randomized: false)   // [256 of Int]
    for value in values { result[Int(value)] += 1 }
    return result
}

// async прямо в defer
let landingTask = Task { try lander.fly(to: moon) }
defer { await orbiter.rendezvous(with: lander) }
try await orbiter.justHangOut(waitingFor: landingTask)

List {
    ForEach(stickers) { sticker in
        StickerListItemView(sticker: sticker)
    }
    .reorderable()
}
.reorderContainer(for: Sticker.self) { difference in
    difference.apply(to: &stickers)
}

// Тот же приём работает и в LazyVGrid, и в кастомных контейнерах

ScrollView {
    LazyVStack {
        ForEach(stickers) { sticker in
            StickerListItemView(sticker: sticker)
                .swipeActions {
                    DeleteButton(sticker: sticker)
                }
        }
    }
}
.swipeActionsContainer()

TabView {
    Tab { EventsTab() }
    Tab { HolidaysTab() }
    Tab { FunTab() }

    Tab(role: .prominent) {
        CartTab()
    }
}

@Observable
final class StickerDocument: WritableDocument {
    static let writableContentTypes: [UTType] = [.stickerDocument, .png]

    @MainActor
    func snapshot(contentType: UTType) async throws -> sending PageSnapshot {
        makeSnapshot()
    }

    func writer(configuration: sending WriteConfiguration) -> sending Writer {
        Writer(contentType: configuration.contentType)
    }
}

struct Writer<Snapshot>: DocumentWriter {
    typealias Snapshot = PageSnapshot
    let contentType: UTType

    nonisolated func write(
        content: sending PageSnapshot, to destination: URL,
        previous: sending PageSnapshot?, progress: consuming Subprogress
    ) async throws {
        // запись вне главного потока; можно сравнить с previous и писать только diff
    }
}

StickerPageView()
    .toolbar {
        ToolbarItemGroup {
            UndoButton()
            RedoButton()
        }
        .visibilityPriority(.high)

        ToolbarOverflowMenu {
            ChoosePhotoButton()
            ExportAsImageButton()
            ClearAllStickersButton()
        }

        ToolbarItem(placement: .topBarPinnedTrailing) {
            ShareButton()
        }
    }

@Observable class StickerStore {
    static let imageSession: URLSession = {
        let config = URLSessionConfiguration.default
        config.urlCache = URLCache(
            memoryCapacity: 64 * 1024 * 1024,
            diskCapacity: 256 * 1024 * 1024)
        return URLSession(configuration: config)
    }()
}

ForEach(pets) { pet in
    AsyncImage(request: URLRequest(
        url: pet.imageURL,
        cachePolicy: .returnCacheDataElseLoad))
}
.asyncImageURLSession(StickerStore.imageSession)

// @State теперь макрос: @Observable-объект инициализируется лениво,
// ровно один раз за время жизни View (бэкпорт на iOS 17 / macOS 14)
struct StickerStoreView: View {
    @State private var store = StickerStore()
    var body: some View { ... }
}

// item-binding вместо отдельного isPresented
.confirmationDialog("Delete?", item: $stickerToDelete) { sticker in
    DeleteStickerButton(sticker)
}

let model = SystemLanguageModel.default
print(model.contextSize)   // напр. 8192

let count = try await model.tokenCount(
    for: "What are the Japanese characters for origami?")

// Управление «глубиной размышления» и инспекция usage
let session = LanguageModelSession()
let response = try await session.respond(
    to: "Recommend a craft that doesn't require scissors.",
    contextOptions: ContextOptions(reasoningLevel: .light)
)
print(response.usage.input.totalTokenCount)
print(response.usage.input.cachedTokenCount)
print(response.usage.output.reasoningTokenCount)

// Новое в iOS 27: изображение прямо в промпте через Attachment
let response = try await session.respond {
    "What animal is this?"
    Attachment(UIImage(named: "mystery-pet")!)
}

struct SwitchModeTool: Tool {
    let description = "Switch to a different mode."
    let states: AppStates

    @Generable
    struct Arguments {
        let mode: Mode
    }

    func call(arguments: Arguments) async throws -> some PromptRepresentable {
        states.mode = arguments.mode
        return "Successfully switched to \(arguments.mode)."
    }
}

struct CraftProfile: LanguageModelSession.DynamicProfile {
    let states: CraftProjectStates

    var body: some DynamicProfile {
        switch states.mode {
        case .craftAnalysis:
            Profile {
                Instructions { ... }
                SwitchModeTool(states: states)
            }
        case .brainstorm:
            Profile { Instructions { ... } }
                .model(states.privateCloudCompute)
                .reasoningLevel(.deep)
        }
    }
}