Package.swift

// swift-tools-version: 6.2
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription
import CompilerPluginSupport

// Embedded Swift builds Foundation as one module, named Foundation. See the end of this file.
let embeddedLayout = !(Context.environment["SWIFT_FOUNDATION_EMBEDDED"] ?? "").isEmpty

// Availability Macros

let availabilityTags: [_Availability] = [
    _Availability("FoundationPreview"), // Default FoundationPreview availability
]
let versionNumbers = ["6.0.2", "6.1", "6.2", "6.3", "6.4", "6.4.2", "6.5"]

// Availability Macro Utilities

enum _OSAvailability: String {
    case alwaysAvailable = "macOS 26, iOS 26, tvOS 26, watchOS 26, visionOS 26" // This should match the package's deployment target
    // Use 10000 for future availability to avoid compiler magic around the 9999 version number but ensure it is greater than 9999
    case future = "macOS 10000, iOS 10000, tvOS 10000, watchOS 10000, visionOS 10000"
    // Embedded Swift links Foundation into each program, so its availability is the embedded deployment target, not an OS release.
    case embedded = "macOS 15, iOS 18, tvOS 18, watchOS 11, visionOS 2" // This should match the embedded deployment target
}
struct _Availability {
    let name: String
    let osAvailability: _OSAvailability
    
    init(_ name: String, availability: _OSAvailability = .alwaysAvailable) {
        self.name = name
        self.osAvailability = availability
    }
}
let availabilityMacros: [SwiftSetting] = versionNumbers.flatMap { version in
    availabilityTags.map {
        let osAvailability: _OSAvailability = embeddedLayout && $0.osAvailability == .alwaysAvailable ? .embedded : $0.osAvailability
        return .enableExperimentalFeature("AvailabilityMacro=\($0.name) \(version):\(osAvailability.rawValue)")
    }
}

let availabilityCheckingSettings: [SwiftSetting] = [
    .unsafeFlags(["-library-level", "api", "-Xfrontend", "-require-explicit-availability=ignore"], .when(platforms: [.macOS]))
]

let featureSettings: [SwiftSetting] = [
    .enableExperimentalFeature("StrictConcurrency"),
    .enableExperimentalFeature("ImportMacroAliases"),
    .enableUpcomingFeature("InferSendableFromCaptures"),
    .enableUpcomingFeature("MemberImportVisibility"),
    .swiftLanguageMode(.v5)
]

var dependencies: [Package.Dependency] = []

if let useLocalDepsEnv = Context.environment["SWIFTCI_USE_LOCAL_DEPS"], !useLocalDepsEnv.isEmpty {
    let root: String
    if useLocalDepsEnv == "1" {
        root = ".."
    } else {
        root = useLocalDepsEnv
    }
    dependencies += 
        [
            .package(
                name: "swift-collections",
                path: "\(root)/swift-collections"),
            .package(
                name: "swift-syntax",
                path: "\(root)/swift-syntax"),
            .package(
                name: "swift-foundation-icu",
                path: "\(root)/swift-foundation-icu")
        ]
} else {
    // These dependencies should match `update-checkout`
    // See `update-checkout-config.json` for the `main` branch-scheme
    dependencies += 
        [
            .package(
                url: "https://github.com/apple/swift-collections",
                exact: "1.7.3"),
            .package(
                url: "https://github.com/swiftlang/swift-syntax",
                branch: "main"),
            .package(
                url: "https://github.com/apple/swift-foundation-icu",
                branch: "main")
        ]
}

let wasiLibcCSettings: [CSetting] = [
    .define("_WASI_EMULATED_SIGNAL", .when(platforms: [.wasi])),
    .define("_WASI_EMULATED_MMAN", .when(platforms: [.wasi])),
]

let testOnlySwiftSettings: [SwiftSetting] = [
    .define("FOUNDATION_EXIT_TESTS", .when(platforms: [.macOS, .linux, .openbsd, .windows]))
]

var package = Package(
    name: "swift-foundation",
    platforms: [.macOS("26"), .iOS("26"), .tvOS("26"), .watchOS("26"), .visionOS("26")],
    products: [
        .library(name: "FoundationEssentials", targets: ["FoundationEssentials"]),
        .library(name: "FoundationInternationalization", targets: ["FoundationInternationalization"]),
    ],
    dependencies: dependencies,
    targets: [
        // _FoundationCShims (Internal)
        .target(
            name: "_FoundationCShims",
            cSettings: [
                .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows]))
            ] + wasiLibcCSettings
        ),

        // _FoundationRefs (Internal)
        // Temporary: stands in for the standard library's `Ref` and `MutableRef` in Darwin package builds. It has its own target because some compiler builds assert when compiling `Ref` with strict concurrency checking, which `featureSettings` enables.
        .target(
            name: "_FoundationRefs",
            swiftSettings: [
                .enableExperimentalFeature("Lifetimes"),
                .enableExperimentalFeature("AllowUnsafeAttribute"),
                .enableExperimentalFeature("BuiltinModule"),
                .swiftLanguageMode(.v5)
            ]
        ),

        // TestSupport (Internal)
        .target(
            name: "TestSupport",
            path: "Tests/TestSupport",
            cSettings: wasiLibcCSettings,
            swiftSettings: availabilityMacros + featureSettings
        ),

        // FoundationEssentials
        .target(
          name: "FoundationEssentials",
          dependencies: [
            "_FoundationCShims",
            "FoundationMacros",
            .target(name: "_FoundationRefs", condition: .when(platforms: [.macOS, .iOS, .tvOS, .watchOS, .visionOS])),
            .product(name: "_RopeModule", package: "swift-collections"),
            .product(name: "DequeModule", package: "swift-collections"),
            .product(name: "OrderedCollections", package: "swift-collections"),
            // Temporary: provides `UniqueArray` in Darwin package builds.
            .product(name: "BasicContainers", package: "swift-collections", condition: .when(platforms: [.macOS, .iOS, .tvOS, .watchOS, .visionOS])),
          ],
          exclude: [
            "Bytes/CMakeLists.txt",
            "Formatting/CMakeLists.txt",
            "PropertyList/CMakeLists.txt",
            "Decimal/CMakeLists.txt",
            "String/CMakeLists.txt",
            "Error/CMakeLists.txt",
            "Locale/CMakeLists.txt",
            "Data/CMakeLists.txt",
            "TimeZone/CMakeLists.txt",
            "JSON/CMakeLists.txt",
            "Codable/CMakeLists.txt",
            "AttributedString/CMakeLists.txt",
            "Calendar/CMakeLists.txt",
            "Predicate/CMakeLists.txt",
            "CMakeLists.txt",
            "ProcessInfo/CMakeLists.txt",
            "FileManager/CMakeLists.txt",
            "URL/CMakeLists.txt",
            "NotificationCenter/CMakeLists.txt",
            "ProgressManager/CMakeLists.txt",
            "CharacterSet/CMakeLists.txt",
          ],
          cSettings: [
            .define("_GNU_SOURCE", .when(platforms: [.linux, .wasi]))
          ] + wasiLibcCSettings,
          swiftSettings: [
            .enableExperimentalFeature("VariadicGenerics"),
            .enableExperimentalFeature("Lifetimes"),
            .enableExperimentalFeature("AddressableTypes"),
            .enableExperimentalFeature("AllowUnsafeAttribute"),
            .enableExperimentalFeature("BuiltinModule"),
            .enableExperimentalFeature("AccessLevelOnImport"),
            .define("DATA_LEGACY_ABI", .when(platforms: [.macOS, .iOS, .tvOS, .watchOS, .visionOS])),
          ] + availabilityMacros + featureSettings + availabilityCheckingSettings,
          linkerSettings: [
            .linkedLibrary("wasi-emulated-getpid", .when(platforms: [.wasi])),
          ]
        ),
        .testTarget(
            name: "FoundationEssentialsTests",
            dependencies: [
                "TestSupport",
                "FoundationEssentials"
            ],
            resources: [
                .copy("Resources")
            ],
            swiftSettings: [
                .define("DATA_LEGACY_ABI", .when(platforms: [.macOS, .iOS, .tvOS, .watchOS, .visionOS]))
            ] + availabilityMacros + featureSettings + testOnlySwiftSettings
        ),

        // FoundationInternationalization
        .target(
            name: "_FoundationInternationalizationData",
            exclude: ["CMakeLists.txt", "DateFormatData.json", "ListFormatData.json"],
            swiftSettings: [
                .enableExperimentalFeature("AccessLevelOnImport"),
                .enableExperimentalFeature("Lifetimes"),
            ] + availabilityMacros + featureSettings + availabilityCheckingSettings
        ),
        .target(
            name: "FoundationInternationalization",
            dependencies: [
                .target(name: "FoundationEssentials"),
                .target(name: "_FoundationCShims"),
                .target(name: "_FoundationInternationalizationData"),
                .product(name: "_FoundationICU", package: "swift-foundation-icu")
            ],
            exclude: [
                "String/CMakeLists.txt",
                "TimeZone/CMakeLists.txt",
                "ICU/CMakeLists.txt",
                "Formatting/CMakeLists.txt",
                "Locale/CMakeLists.txt",
                "Calendar/CMakeLists.txt",
                "CMakeLists.txt",
                "Predicate/CMakeLists.txt",
            ],
            cSettings: wasiLibcCSettings,
            swiftSettings: [
                .enableExperimentalFeature("AccessLevelOnImport"),
                .enableExperimentalFeature("Lifetimes"),
            ] + availabilityMacros + featureSettings + availabilityCheckingSettings
        ),
        
        .testTarget(
            name: "FoundationInternationalizationTests",
            dependencies: [
                "TestSupport",
                "FoundationInternationalization",
            ],
            swiftSettings: availabilityMacros + featureSettings + testOnlySwiftSettings
        ),
        
        // FoundationMacros
        .macro(
            name: "FoundationMacros",
            dependencies: [
                .product(name: "SwiftSyntax", package: "swift-syntax"),
                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                .product(name: "SwiftOperators", package: "swift-syntax"),
                .product(name: "SwiftParser", package: "swift-syntax"),
                .product(name: "SwiftParserDiagnostics", package: "swift-syntax"),
                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
            ],
            exclude: ["CMakeLists.txt"],
            swiftSettings: [
                .enableExperimentalFeature("AccessLevelOnImport")
            ] + availabilityMacros + featureSettings
        ),
        
        .testTarget(
            name: "FoundationMacrosTests",
            dependencies: [
                "FoundationMacros",
                "FoundationEssentials"
            ],
            swiftSettings: availabilityMacros + featureSettings + testOnlySwiftSettings
        )
    ]
)

// Embedded Swift always builds FoundationEssentials and FoundationInternationalization as one module, named Foundation. Embedded Swift has no dynamic replacement, so in embedded mode FoundationEssentials uses the ICU implementations of FoundationInternationalization directly. A Swift SDK cannot change the manifest, so set SWIFT_FOUNDATION_EMBEDDED=1 to use this layout.
if embeddedLayout {
    let essentials = package.targets.first { $0.name == "FoundationEssentials" }!
    let internationalization = package.targets.first { $0.name == "FoundationInternationalization" }!
    // The OS availability annotations describe which Foundation.framework release has an API. Embedded Swift links Foundation into each program, so every API is available at the embedded deployment target, and every `#available` check for Foundation's own code is true.
    let embeddedSwiftSettings: [SwiftSetting] = (essentials.swiftSettings ?? []) + [.unsafeFlags(["-Xfrontend", "-disable-availability-checking"])]

    // Two targets cannot have the same source files, so remove the separate modules and the tests that use them.
    package.targets.removeAll {
        $0.name == "FoundationEssentials" || $0.name == "FoundationInternationalization" || $0.name == "TestSupport" || $0.type == .test
    }
    package.targets.append(
        .target(
            name: "Foundation",
            dependencies: [
                "_FoundationCShims",
                "_FoundationInternationalizationData",
                "FoundationMacros",
                .product(name: "_RopeModule", package: "swift-collections"),
                .product(name: "DequeModule", package: "swift-collections"),
                .product(name: "OrderedCollections", package: "swift-collections"),
                .product(name: "_FoundationICU", package: "swift-foundation-icu"),
            ],
            path: "Sources",
            exclude: essentials.exclude.map { "FoundationEssentials/\($0)" } + internationalization.exclude.map { "FoundationInternationalization/\($0)" } + [
                // With explicit source directories, SwiftPM gives the documentation catalogs to the compiler.
                "FoundationEssentials/FoundationEssentials.docc",
                "FoundationInternationalization/FoundationInternationalization.docc",
            ],
            sources: ["FoundationEssentials", "FoundationInternationalization"],
            cSettings: essentials.cSettings,
            // The settings of FoundationInternationalization are a subset of these.
            swiftSettings: embeddedSwiftSettings,
            linkerSettings: essentials.linkerSettings
        )
    )
    package.platforms = [.macOS("15"), .iOS("18"), .tvOS("18"), .watchOS("11"), .visionOS("2")]
    package.products = [
        .library(name: "Foundation", targets: ["Foundation"]),
    ]
}