Merge pull request #623 from swiftlang/automerge/merge-main-2025-06-30_09-02

Merge `release/6.2` into `main`

Author: owenv

Sources/SWBCore/Settings/BuiltinMacros.swift

@@ -420,6 +420,7 @@ public final class BuiltinMacros {
 
     // MARK: Mergeable libraries macros
 
+    public static let ADD_MERGEABLE_DEBUG_HOOK = BuiltinMacros.declareBooleanMacro("ADD_MERGEABLE_DEBUG_HOOK")
     public static let AUTOMATICALLY_MERGE_DEPENDENCIES = BuiltinMacros.declareBooleanMacro("AUTOMATICALLY_MERGE_DEPENDENCIES")
     public static let MERGEABLE_LIBRARY = BuiltinMacros.declareBooleanMacro("MERGEABLE_LIBRARY")
     public static let DONT_EMBED_REEXPORTED_MERGEABLE_LIBRARIES = BuiltinMacros.declareBooleanMacro("DONT_EMBED_REEXPORTED_MERGEABLE_LIBRARIES")
@@ -1000,6 +1001,7 @@ public final class BuiltinMacros {
     public static let SWIFT_ABI_CHECKER_EXCEPTIONS_FILE = BuiltinMacros.declareStringMacro("SWIFT_ABI_CHECKER_EXCEPTIONS_FILE")
     public static let SWIFT_ABI_GENERATION_TOOL_OUTPUT_DIR = BuiltinMacros.declareStringMacro("SWIFT_ABI_GENERATION_TOOL_OUTPUT_DIR")
     public static let SWIFT_ACCESS_NOTES_PATH = BuiltinMacros.declareStringMacro("SWIFT_ACCESS_NOTES_PATH")
+    public static let SWIFT_ACTIVE_COMPILATION_CONDITIONS = BuiltinMacros.declareStringListMacro("SWIFT_ACTIVE_COMPILATION_CONDITIONS")
     public static let SWIFT_ALLOW_INSTALL_OBJC_HEADER = BuiltinMacros.declareBooleanMacro("SWIFT_ALLOW_INSTALL_OBJC_HEADER")
     public static let __SWIFT_ALLOW_INSTALL_OBJC_HEADER_MESSAGE = BuiltinMacros.declareStringMacro("__SWIFT_ALLOW_INSTALL_OBJC_HEADER_MESSAGE")
     public static let SWIFT_COMPILATION_MODE = BuiltinMacros.declareStringMacro("SWIFT_COMPILATION_MODE")
@@ -1377,6 +1379,7 @@ public final class BuiltinMacros {
         ADDITIONAL_SDK_DIRS,
         AD_HOC_CODE_SIGNING_ALLOWED,
         __AD_HOC_CODE_SIGNING_NOT_ALLOWED_SUPPLEMENTAL_MESSAGE,
+        ADD_MERGEABLE_DEBUG_HOOK,
         AGGREGATE_TRACKED_DOMAINS,
         ALLOW_BUILD_REQUEST_OVERRIDES,
         ALLOW_DISJOINTED_DIRECTORIES_AS_DEPENDENCIES,
@@ -2174,6 +2177,7 @@ public final class BuiltinMacros {
         SWIFT_ABI_CHECKER_EXCEPTIONS_FILE,
         SWIFT_ABI_GENERATION_TOOL_OUTPUT_DIR,
         SWIFT_ACCESS_NOTES_PATH,
+        SWIFT_ACTIVE_COMPILATION_CONDITIONS,
         SWIFT_ALLOW_INSTALL_OBJC_HEADER,
         __SWIFT_ALLOW_INSTALL_OBJC_HEADER_MESSAGE,
         SWIFT_COMPILATION_MODE,

Sources/SWBCore/Settings/Settings.swift

@@ -1545,7 +1545,7 @@ private class SettingsBuilder {
         }
 
         // Push the target derived overriding settings.
-        addTargetDerivedSettings(self.target, boundProperties.platform, boundProperties.sdk, boundProperties.sdkVariant)
+        addTargetDerivedSettings(self.target, boundProperties.platform, boundProperties.sdk, boundProperties.sdkVariant, specLookupContext)
 
         if boundDeploymentTarget.platformDeploymentTargetMacro == BuiltinMacros.DRIVERKIT_DEPLOYMENT_TARGET, let deploymentTarget = boundDeploymentTarget.platformDeploymentTarget, deploymentTarget < Version(20) {
             var table = MacroValueAssignmentTable(namespace: userNamespace)
@@ -2030,13 +2030,13 @@ private class SettingsBuilder {
     /// Add the derived overriding settings for the target. These are settings whose values depend on the whole stack of build settings, and include settings which are forced to a value under certain conditions, and settings whose value is wholly derived from other settings.  They override settings from all lower levels, and thus cannot be overridden by (for example) xcodebuild or run destination overrides, so settings should only be assigned here when they represent true boundary conditions which users should never want to or be able to override.
     ///
     /// These are only added if we're constructing settings for a target.
-    func addTargetDerivedSettings(_ target: Target?, _ platform: Platform?, _ sdk: SDK?, _ sdkVariant: SDKVariant?) {
+    func addTargetDerivedSettings(_ target: Target?, _ platform: Platform?, _ sdk: SDK?, _ sdkVariant: SDKVariant?, _ specLookupContext: any SpecLookupContext) {
         guard target != nil else {
             return
         }
 
         push(getTargetDerivedSettings(platform, sdk, sdkVariant), .exportedForNative)
-        addSecondaryTargetDerivedSettings(sdk)
+        addSecondaryTargetDerivedSettings(sdk, specLookupContext)
     }
 
     /// Add the core derived overriding settings for the target.
@@ -2129,7 +2129,7 @@ private class SettingsBuilder {
     /// Add derived settings for the target which are themselves derived from the core target derived settings computed above. (Whee!)
     ///
     /// This is called from `addTargetDerivedSettings().
-    func addSecondaryTargetDerivedSettings(_ sdk: SDK?) {
+    func addSecondaryTargetDerivedSettings(_ sdk: SDK?, _ specLookupContext: any SpecLookupContext) {
         // Mergeable library/merged binary support.
         do {
             let scope = createScope(sdkToUse: sdk)
@@ -2155,22 +2155,36 @@ private class SettingsBuilder {
                 table.push(BuiltinMacros.MERGE_LINKED_LIBRARIES, literal: true)
             }
 
-            // If this is a mergeable library, then build it as mergeable if this is a release build.
-            if scope.evaluate(BuiltinMacros.MERGEABLE_LIBRARY), !scope.evaluate(BuiltinMacros.IS_UNOPTIMIZED_BUILD) {
-                table.push(BuiltinMacros.MAKE_MERGEABLE, literal: true)
+            // If this is a mergeable library, for a release build we want to build it as mergeable, whereas for a debug build we want to add the mergeable debug hook.
+            if scope.evaluate(BuiltinMacros.MERGEABLE_LIBRARY) {
+                if scope.evaluate(BuiltinMacros.IS_UNOPTIMIZED_BUILD) {
+                    table.push(BuiltinMacros.ADD_MERGEABLE_DEBUG_HOOK, literal: true)
+                }
+                else {
+                    table.push(BuiltinMacros.MAKE_MERGEABLE, literal: true)
+                }
             }
 
             push(table, .exportedForNative)
         }
         do {
             let scope = createScope(sdkToUse: sdk)
+            var table = MacroValueAssignmentTable(namespace: core.specRegistry.internalMacroNamespace)
 
             // If the product is being built as mergeable, then that overrides certain other settings.
             if scope.evaluate(BuiltinMacros.MAKE_MERGEABLE) {
-                var table = MacroValueAssignmentTable(namespace: core.specRegistry.internalMacroNamespace)
                 table.push(BuiltinMacros.STRIP_INSTALLED_PRODUCT, literal: false)
-                push(table, .exportedForNative)
             }
+
+            // Even if not being merged in this build, a mergeable library still uses a generated bundle lookup helper to power #bundle support.
+            if scope.evaluate(BuiltinMacros.MERGEABLE_LIBRARY) {
+                let pathResolver = FilePathResolver(scope: scope)
+                if (target as? StandardTarget)?.sourcesBuildPhase?.containsSwiftSources(workspaceContext.workspace, specLookupContext, scope, pathResolver) ?? false {
+                    table.push(BuiltinMacros.SWIFT_ACTIVE_COMPILATION_CONDITIONS, BuiltinMacros.namespace.parseStringList(["$(inherited)", "SWIFT_BUNDLE_LOOKUP_HELPER_AVAILABLE"]))
+                }
+            }
+
+            push(table, .exportedForNative)
         }
     }
 

Sources/SWBTaskConstruction/TaskProducers/BuildPhaseTaskProducers/SourcesTaskProducer.swift

@@ -774,6 +774,9 @@ final class SourcesTaskProducer: FilesBasedBuildPhaseTaskProducerBase, FilesBase
         let packageTargetBundleAccessorResult = await generatePackageTargetBundleAccessorResult(scope)
         tasks += packageTargetBundleAccessorResult?.tasks ?? []
 
+        let bundleLookupHelperResult = await generateBundleLookupHelper(scope)
+        tasks += bundleLookupHelperResult?.tasks ?? []
+
         let embedInCodeAccessorResult: GeneratedResourceAccessorResult?
         if scope.evaluate(BuiltinMacros.GENERATE_EMBED_IN_CODE_ACCESSORS), let configuredTarget = context.configuredTarget, buildPhase.containsSwiftSources(context.workspaceContext.workspace, context, scope, context.filePathResolver) {
             let ownTargetBuildFilesToEmbed = ((context.workspaceContext.workspace.target(for: configuredTarget.target.guid) as? StandardTarget)?.buildPhases.compactMap { $0 as? BuildPhaseWithBuildFiles }.flatMap { $0.buildFiles }.filter { $0.resourceRule == .embedInCode }) ?? []
@@ -871,6 +874,10 @@ final class SourcesTaskProducer: FilesBasedBuildPhaseTaskProducerBase, FilesBase
                         result.append((packageTargetBundleAccessorResult.fileToBuild, packageTargetBundleAccessorResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false))
                     }
 
+                    if let bundleLookupHelperResult {
+                        result.append((bundleLookupHelperResult.fileToBuild, bundleLookupHelperResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false))
+                    }
+
                     if let embedInCodeAccessorResult {
                         result.append((embedInCodeAccessorResult.fileToBuild, embedInCodeAccessorResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false))
                     }
@@ -1195,11 +1202,17 @@ final class SourcesTaskProducer: FilesBasedBuildPhaseTaskProducerBase, FilesBase
                 let buildFilesContext = BuildFilesProcessingContext(scope, belongsToPreferredArch: preferredArch == nil || preferredArch == arch, currentArchSpec: currentArchSpec)
                 var perArchTasks: [any PlannedTask] = []
                 await groupAndAddTasksForFiles(self, buildFilesContext, scope, filterToAPIRules: isForAPI, filterToHeaderRules: isForHeaders, &perArchTasks, extraResolvedBuildFiles: {
+                    var result: [(Path, FileTypeSpec, Bool)] = []
+
                     if let packageTargetBundleAccessorResult {
-                        return [(packageTargetBundleAccessorResult.fileToBuild, packageTargetBundleAccessorResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false)]
-                    } else {
-                        return []
+                        result.append((packageTargetBundleAccessorResult.fileToBuild, packageTargetBundleAccessorResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false))
+                    }
+
+                    if let bundleLookupHelperResult {
+                        result.append((bundleLookupHelperResult.fileToBuild, bundleLookupHelperResult.fileToBuildFileType, /* shouldUsePrefixHeader */ false))
                     }
+
+                    return result
                 }())
 
                 // Add all the collected per-arch tasks.
@@ -1728,7 +1741,43 @@ final class SourcesTaskProducer: FilesBasedBuildPhaseTaskProducerBase, FilesBase
         return GeneratedResourceAccessorResult(tasks: tasks, fileToBuild: filePath, fileToBuildFileType: context.lookupFileType(fileName: "sourcecode.swift")!)
     }
 
+    /// Generates a task for creating the `__BundleLookupHelper` class to enable `#bundle` support in mergeable libraries.
+    private func generateBundleLookupHelper(_ scope: MacroEvaluationScope) async -> GeneratedResourceAccessorResult? {
+        // We generate a __BundleLookupHelper class that Foundation's #bundle macro can use to lookup the resource bundle.
+        // ld will inject a mapping of class pointers to the correct resource bundle so that BundleForClass works at runtime.
+
+        // We only need this treatment for mergeable libraries at this time.
+        // Package targets do something similar but they generate the Bundle.module extensions and #bundle calls that.
+
+        // We need to do this for all mergeable libraries, even if it will just be re-exported in this build.
+        guard scope.evaluate(BuiltinMacros.MERGEABLE_LIBRARY) else {
+            return nil
+        }
+
+        let workspace = self.context.workspaceContext.workspace
+
+        // #bundle is a Swift macro, so this is only needed for Swift code.
+        guard buildPhase.containsSwiftSources(workspace, context, scope, context.filePathResolver) else {
+            return nil
+        }
+
+        let filePath = scope.evaluate(BuiltinMacros.DERIVED_SOURCES_DIR).join("bundle_lookup_helper.swift")
+
+        // We need one class with a relatively unique name that #bundle can use for bundle lookup.
+        // It cannot be less visible than internal since the #bundle expansion needs to be able to resolve it AND so ld will record the class->bundle mapping.
+        // We intentionally do not want a Foundation dependency in this generated code, so don't import Foundation.
+        let content = "internal class __BundleLookupHelper {}"
+
+        var tasks = [any PlannedTask]()
+        await appendGeneratedTasks(&tasks) { delegate in
+            context.writeFileSpec.constructFileTasks(CommandBuildContext(producer: context, scope: context.settings.globalScope, inputs: [], output: filePath), delegate, contents: ByteString(encodingAsUTF8: content), permissions: nil, preparesForIndexing: true, additionalTaskOrderingOptions: [.immediate, .ignorePhaseOrdering])
+        }
+        return GeneratedResourceAccessorResult(tasks: tasks, fileToBuild: filePath, fileToBuildFileType: context.lookupFileType(fileName: "sourcecode.swift")!)
+    }
+
     /// Generates a task for creating the resource bundle accessor for package targets.
+    ///
+    /// This produces the `Bundle.module` accessor.
     private func generatePackageTargetBundleAccessorResult(_ scope: MacroEvaluationScope) async -> GeneratedResourceAccessorResult? {
         let bundleName = scope.evaluate(BuiltinMacros.PACKAGE_RESOURCE_BUNDLE_NAME)
         let isRegularPackage = scope.evaluate(BuiltinMacros.PACKAGE_RESOURCE_TARGET_KIND) == .regular

Sources/SWBTaskExecution/TaskActions/InfoPlistProcessorTaskAction.swift

@@ -1451,35 +1451,49 @@ public final class InfoPlistProcessorTaskAction: TaskAction
                 case iOS
                 case tvOS
                 case watchOS
+                case visionOS = "xrOS" // must be "xrOS" as it's compared against Platform.familyName
             }
 
             /// The values of the key that are deprecated, if only specific values are deprecated. `nil` indicates the key as a whole is deprecated.
             let values: [PropertyListItem]?
 
-            /// An infix to display in the "use (alternative) instead" portion of the deprecation message.
-            let alternate: String
+            enum MoreInfo {
+                /// An infix to display in the "use (alternative) instead" portion of the deprecation message.
+                case alternate(String)
+
+                case ignored(String)
+            }
+
+            let moreInfo: MoreInfo
 
             /// Mapping of platforms and the version of that platform beginning in which the deprecation warning should be shown.
             ///
             /// If the version is empty, the warning will always be shown for that platform.
             /// If there is no version value present for a platform at all, no warning will ever be shown for that platform.
             let deprecationVersions: [DeprecationPlatform: Version]
 
-            init(values: [PropertyListItem]? = nil, alternate: String, deprecationVersions: [DeprecationPlatform: Version]) {
+            init(values: [PropertyListItem]? = nil, moreInfo: MoreInfo, deprecationVersions: [DeprecationPlatform: Version]) {
                 self.values = values
-                self.alternate = alternate
+                self.moreInfo = moreInfo
                 self.deprecationVersions = deprecationVersions
             }
         }
 
         let plistKeyDeprecationInfo: [PropertyListKeyPath: DeprecationInfo] = [
-            "UILaunchImages": .init(alternate: "launch storyboards", deprecationVersions: [.iOS: Version(), .tvOS: Version(13)]),
-            "CLKComplicationSupportedFamilies": .init(alternate: "the ClockKit complications API", deprecationVersions: [.watchOS: Version(7)]),
-            PropertyListKeyPath(.dict(.equal("NSAppTransportSecurity")), .dict(.equal("NSExceptionDomains")), .dict(.any), .any(.equal("NSExceptionMinimumTLSVersion"))): .init(values: [.plString("TLSv1.0"), .plString("TLSv1.1")], alternate: "TLSv1.2 or TLSv1.3", deprecationVersions: [
+            "UILaunchImages": .init(moreInfo: .alternate("launch storyboards"), deprecationVersions: [.iOS: Version(), .tvOS: Version(13)]),
+            "CLKComplicationSupportedFamilies": .init(moreInfo: .alternate("the ClockKit complications API"), deprecationVersions: [.watchOS: Version(7)]),
+            PropertyListKeyPath(.dict(.equal("NSAppTransportSecurity")), .dict(.equal("NSExceptionDomains")), .dict(.any), .any(.equal("NSExceptionMinimumTLSVersion"))): .init(values: [.plString("TLSv1.0"), .plString("TLSv1.1")], moreInfo: .alternate("TLSv1.2 or TLSv1.3"), deprecationVersions: [
                 .macOS: Version(12),
                 .iOS: Version(15),
                 .tvOS: Version(15),
                 .watchOS: Version(8)
+            ]),
+            "UIRequiresFullScreen": .init(moreInfo: .ignored("See the UIRequiresFullScreen documentation for more details."), deprecationVersions: [
+                .macOS: Version(26),
+                .iOS: Version(26),
+                .tvOS: Version(26),
+                .watchOS: Version(26),
+                .visionOS: Version(26),
             ])
         ]
 
@@ -1497,11 +1511,19 @@ public final class InfoPlistProcessorTaskAction: TaskAction
                         prefixPart = "'\(item.actualKeyPath.joined(separator: "' => '"))'"
                     }
 
+                    let suffixPart: String
+                    switch info.moreInfo {
+                    case let .alternate(alternate):
+                        suffixPart = ", use \(alternate) instead."
+                    case let .ignored(ignored):
+                        suffixPart = " and will be ignored in a future release. \(ignored)"
+                    }
+
                     let message: String
                     if deprecationVersion > Version() {
-                        message = "\(prefixPart) has been deprecated starting in \(context.platform?.familyDisplayName ?? "") \(deprecationVersion.canonicalDeploymentTargetForm.description), use \(info.alternate) instead."
+                        message = "\(prefixPart) has been deprecated starting in \(context.platform?.familyDisplayName ?? "") \(deprecationVersion.canonicalDeploymentTargetForm.description)\(suffixPart)"
                     } else {
-                        message = "\(prefixPart) has been deprecated, use \(info.alternate) instead."
+                        message = "\(prefixPart) has been deprecated\(suffixPart)"
                     }
 
                     if let deploymentTarget = deploymentTarget, deploymentTarget >= deprecationVersion {

Sources/SWBTestSupport/CoreBasedTests.swift

@@ -371,6 +371,13 @@ extension CoreBasedTests {
         try await SWBCore.discoveredSwiftCompilerInfo(MockCommandProducer(core: getCore(), productTypeIdentifier: "com.apple.product-type.framework", platform: nil, useStandardExecutableSearchPaths: true, toolchain: nil, fs: PseudoFS()), AlwaysDeferredCoreClientDelegate(), at: toolPath, blocklistsPathOverride: nil)
     }
 
+    package func discoveredLdLinkerInfo(at toolPath: Path) async throws -> DiscoveredLdLinkerToolSpecInfo {
+        guard let info = try await SWBCore.discoveredLinkerToolsInfo(MockCommandProducer(core: getCore(), productTypeIdentifier: "com.apple.product-type.framework", platform: nil, useStandardExecutableSearchPaths: true, toolchain: nil, fs: PseudoFS()), AlwaysDeferredCoreClientDelegate(), at: toolPath) as? DiscoveredLdLinkerToolSpecInfo else {
+            throw StubError.error("Could not get tool spec info for LdLinkerSpec")
+        }
+        return info
+    }
+
     package func discoveredTAPIToolInfo(at toolPath: Path) async throws -> DiscoveredTAPIToolSpecInfo {
         try await SWBCore.discoveredTAPIToolInfo(MockCommandProducer(core: getCore(), productTypeIdentifier: "com.apple.product-type.framework", platform: nil, useStandardExecutableSearchPaths: true, toolchain: nil, fs: PseudoFS()), AlwaysDeferredCoreClientDelegate(), at: toolPath)
     }