Merge pull request #1446 from swiftlang/automerge/merge-main-2026-06-05_22-21

Author: bkhouri

Sources/SWBCore/Core.swift

@@ -628,14 +628,18 @@ public final class Core: Sendable {
         }
     }
 
-    package static func effectivePlatformName(platformName: String, archComponent: String) -> String {
-        // `archComponent` is currently unused, but will be used to disambiguate build directories for platforms that
-        // don't support universal binaries once this API is adopted.
+    package func effectivePlatformName(platformName: String, archComponent: String) -> String {
         if platformName == "macosx" {
+            // For historical compatibility reasons, macOS does not have an effective platform name.
             return ""
-        } else {
+        } else if let platform = platformRegistry.lookup(name: platformName), platform.isApplePlatform {
+            // When targeting an Apple platform we may be building a Universal binary, so disambiguate based on only the platform.
             return "-\(platformName)"
-        }
+        } else {
+            // Otherwise disambiguate based on the arch and platform to ensure products built for different architectures one after
+            // another don't overwrite each other.
+            return "-\(platformName)-\(archComponent)"
+       }
     }
 
     public func buildTargetInfo(triple: String) throws -> (sdkName: String, platformName: String, buildProductsDirectorySuffix: String, sdkVariant: String?, deploymentTargetSettingName: String?, deploymentTarget: String?) {
@@ -648,7 +652,7 @@ public final class Core: Sendable {
             throw StubError.error("unable to find a single platform name for triple '\(triple)'. results: \(platformNames)")
         }
 
-        let buildProductsDirectorySuffix = Self.effectivePlatformName(platformName: platformName, archComponent: llvmTriple.arch)
+        let buildProductsDirectorySuffix = effectivePlatformName(platformName: platformName, archComponent: llvmTriple.arch)
 
         let sdkVariants = Set(platformExtensions.compactMap({ $0.sdkVariant(triple: llvmTriple) }))
         if sdkVariants.count > 1 {

Sources/SWBCore/PlatformRegistry.swift

@@ -122,6 +122,10 @@ public final class Platform: Sendable {
         return correspondingDevicePlatformName != nil
     }
 
+    public var isApplePlatform: Bool {
+        defaultSDKVariant?.llvmTargetTripleVendor == "apple"
+    }
+
     /// The type of platform for the purposes of signing.
     @_spi(Testing) public var signingContext: any PlatformSigningContext {
         return signingContextCache.getValue(self)

Sources/SWBCore/Settings/BuiltinMacros.swift

@@ -150,6 +150,7 @@ public final class BuiltinMacros {
     public static let SWIFT_PLATFORM_TARGET_PREFIX = BuiltinMacros.declareStringMacro("SWIFT_PLATFORM_TARGET_PREFIX")
     public static let TVOS_DEPLOYMENT_TARGET = BuiltinMacros.declareStringMacro("TVOS_DEPLOYMENT_TARGET")
     public static let VALID_ARCHS = BuiltinMacros.declareStringListMacro("VALID_ARCHS")
+    public static let ONLY_ARCH = BuiltinMacros.declareStringMacro("ONLY_ARCH")
     public static let WATCHOS_DEPLOYMENT_TARGET = BuiltinMacros.declareStringMacro("WATCHOS_DEPLOYMENT_TARGET")
 
     // MARK: Swift module-only properties.
@@ -2510,6 +2511,7 @@ public final class BuiltinMacros {
         VALIDATE_DEPENDENCIES,
         VALIDATE_DEVELOPMENT_ASSET_PATHS,
         VALID_ARCHS,
+        ONLY_ARCH,
         VECTOR_SUFFIX,
         VERBOSE_PBXCP,
         VERSIONING_STUB,

Sources/SWBCore/Settings/Settings.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Copyright (c) 2025-2026 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
@@ -2528,7 +2528,7 @@ private class SettingsBuilder: ProjectMatchLookup {
             platformTable.push(BuiltinMacros.PLATFORM_DISPLAY_NAME, literal: platform.displayName)
             platformTable.push(BuiltinMacros.PLATFORM_DIR, literal: platform.path.str)
 
-            platformTable.push(BuiltinMacros.EFFECTIVE_PLATFORM_NAME, BuiltinMacros.namespace.parseString(Core.effectivePlatformName(platformName: platform.name, archComponent: "$(CURRENT_ARCH)")))
+            platformTable.push(BuiltinMacros.EFFECTIVE_PLATFORM_NAME, BuiltinMacros.namespace.parseString(core.effectivePlatformName(platformName: platform.name, archComponent: "$(ONLY_ARCH:default=unknown_arch)")))
 
             if platform.name.hasSuffix("simulator") {
                 platformTable.push(BuiltinMacros.EFFECTIVE_PLATFORM_SUFFIX, literal: "simulator")
@@ -4136,6 +4136,37 @@ private class SettingsBuilder: ProjectMatchLookup {
         // This is the method which computes the list of architectures to build for, and so is a funnel point for a bunch of load-bearing logic.
         push(getCommonTargetTaskOverrides(specLookupContext, deploymentTarget, sdk), .exported)
 
+        // FIXME: There is a more random, but questionable stuff here. To be added in a test case driven fashion.
+
+        // Resolve some of the key path settings to be absolute.
+        //
+        // This is important, because they can be used to derive paths via xcspecs, and we want those paths to be absolute.
+        //
+        // FIXME: This is a bad way to enforce this, it doesn't have any type safety. What would be much better would be to introduce new macro evaluation features that let us write the specs to clearly demarcate paths.
+        //
+        // FIXME: <rdar://problem/41339901> In Xcode, this also does tilde expansion. We should support that (and test exactly where we want it to work).
+        // Now that these are paths not really required.
+        // These paths must only be normalized after we have bound the architecture settings via getCommonTargetTaskOverrides above, as they may be interpolated into the paths.
+        do {
+            var table = MacroValueAssignmentTable(namespace: userNamespace)
+            let scope = createScope(sdkToUse: sdk)
+            let macrosToNormalize = [
+                BuiltinMacros.SRCROOT, BuiltinMacros.SYMROOT, BuiltinMacros.OBJROOT, BuiltinMacros.DSTROOT,
+                BuiltinMacros.LOCROOT, BuiltinMacros.LOCSYMROOT,
+                BuiltinMacros.CCHROOT,
+                BuiltinMacros.CONFIGURATION_BUILD_DIR, BuiltinMacros.SHARED_PRECOMPS_DIR,
+                BuiltinMacros.CONFIGURATION_TEMP_DIR, BuiltinMacros.TARGET_TEMP_DIR, BuiltinMacros.TEMP_DIR,
+                BuiltinMacros.PROJECT_DIR, BuiltinMacros.BUILT_PRODUCTS_DIR
+            ]
+            for macro in macrosToNormalize {
+                table.push(macro, literal: (project?.sourceRoot ?? workspaceContext.workspace.path.dirname).join(scope.evaluate(macro), normalize: true).str)
+            }
+            push(table, .exported)
+        }
+
+
+        // FIXME: Xcode also normalizes SDKROOT to an absolute path here, although native targets also do this (in a different place).
+
         do {
             // Also set each a build setting with the name of each architecture to `YES`.
             // This is much more amenable to composable build setting names than using `ARCHS`.
@@ -4402,13 +4433,14 @@ private class SettingsBuilder: ProjectMatchLookup {
                 // Sort the archs for stability.
                 let sortedArchs = archs.sorted()
 
-                // Compute the base arch. The purpose of this is to always choose the same base arch from the same list of archs (if we don't have a preferredArch), and picking the first one from a sorted list is a simple way to do that.
+                // Compute the base arch. The purpose of this is to always choose the same base arch from the same list of archs in a stable manner.
+                // If the name of the arch cohort is in the list, then we prefer that one. Otherwise we pick the first one from the sorted list, which is a simple way to ensure stability.
+                // We don't want to use self.preferredArch here, because that can vary depending on context (for example different run destinations may provide different preferredArchs).
                 guard let firstArch = sortedArchs.first else {
                     // If there are no archs then we don't need to set up a cohort.
                     continue
                 }
-                let preferredBaseArch = self.preferredArch ?? cohortArch
-                let baseArch = archs.contains(preferredBaseArch) ? preferredBaseArch : firstArch
+                let baseArch = archs.contains(cohortArch) ? cohortArch : firstArch
                 let otherArchs = sortedArchs.filter({ $0 != baseArch })
 
                 // Set up the build settings for the cohort which CURRENT_ARCH is in.  (They will of course be empty if there is no cohort - we won't even have gotten here.)
@@ -4464,6 +4496,12 @@ private class SettingsBuilder: ProjectMatchLookup {
         // This will omit cohort archs, code for which is generated by the task for the base arch of the cohort.
         table.push(BuiltinMacros.ARCHS_BASE, literal: archsBase)
 
+        if let onlyArch = archsBase.only {
+            table.push(BuiltinMacros.ONLY_ARCH, literal: onlyArch)
+        } else {
+            table.push(BuiltinMacros.ONLY_ARCH, literal: "multiple_archs")
+        }
+
         // The set of Swift module-only architectures should be a set of valid architectures that's disjoint from the
         // set of effective architectures. We don't necessarily care about these architectures being deprecated as this
         // setting will primarily be used to support building Swift modules for deprecated (or at least unsupported)
@@ -4493,31 +4531,6 @@ private class SettingsBuilder: ProjectMatchLookup {
             table.push(BuiltinMacros._LD_ARCH, literal: prefix)
         }
 
-        // FIXME: There is a more random, but questionable stuff here. To be added in a test case driven fashion.
-
-        // Resolve some of the key path settings to be absolute.
-        //
-        // This is important, because they can be used to derive paths via xcspecs, and we want those paths to be absolute.
-        //
-        // FIXME: This is a bad way to enforce this, it doesn't have any type safety. What would be much better would be to introduce new macro evaluation features that let us write the specs to clearly demarcate paths.
-        //
-        // FIXME: <rdar://problem/41339901> In Xcode, this also does tilde expansion. We should support that (and test exactly where we want it to work).
-        // Now that these are paths not really required.
-        let macrosToNormalize = [
-            BuiltinMacros.SRCROOT, BuiltinMacros.SYMROOT, BuiltinMacros.OBJROOT, BuiltinMacros.DSTROOT,
-            BuiltinMacros.LOCROOT, BuiltinMacros.LOCSYMROOT,
-            BuiltinMacros.CCHROOT,
-            BuiltinMacros.CONFIGURATION_BUILD_DIR, BuiltinMacros.SHARED_PRECOMPS_DIR,
-            BuiltinMacros.CONFIGURATION_TEMP_DIR, BuiltinMacros.TARGET_TEMP_DIR, BuiltinMacros.TEMP_DIR,
-            BuiltinMacros.PROJECT_DIR, BuiltinMacros.BUILT_PRODUCTS_DIR
-        ]
-        for macro in macrosToNormalize {
-            table.push(macro, literal: (project?.sourceRoot ?? workspaceContext.workspace.path.dirname).join(scope.evaluate(macro), normalize: true).str)
-        }
-
-
-        // FIXME: Xcode also normalizes SDKROOT to an absolute path here, although native targets also do this (in a different place).
-
         // Compute the resolved value for GCC_VERSION, if not otherwise set.
         if scope.evaluate(BuiltinMacros.GCC_VERSION).isEmpty {
             table.push(BuiltinMacros.GCC_VERSION, literal: "com.apple.compilers.llvm.clang.1_0")

Sources/SWBMacro/MacroValueAssignmentTable.swift

@@ -342,6 +342,7 @@ public struct MacroValueAssignmentTable: Serializable, Sendable {
                 case 3: decl = delegate.namespace.lookupOrDeclareMacro(UserDefinedMacroDeclaration.self, name)
                 case 4: decl = delegate.namespace.lookupOrDeclareMacro(PathMacroDeclaration.self, name)
                 case 5: decl = delegate.namespace.lookupOrDeclareMacro(PathListMacroDeclaration.self, name)
+                case 6: decl = delegate.namespace.lookupOrDeclareMacro(PathOrderedSetMacroDeclaration.self, name)
                 default: throw DeserializerError.deserializationFailed("Unrecognized code for MacroType for MacroDeclaration \(name): \(typeCode)")
                 }
             }

Sources/SWBTestSupport/PlatformFilter.swift

@@ -154,9 +154,9 @@ extension CoreBasedTests {
                     results.checkNoTask(.matchTargetName("FwkTarget"))
                     results.checkNoTask(.matchTargetName("PkgTarget"))
 
-                    results.checkNote("Skipping '/tmp/Test/aProject/build/Debug\(runDestination.builtProductsDirSuffix)/FwkTarget.framework' because its platform filter (\(filtersString)) does not match the platform filter of the current context (\(runDestination.platformFilterString)). (in target 'AppTarget' from project 'aProject')")
+                    results.checkNote("Skipping '/tmp/Test/aProject/build/Debug\(runDestination.builtProductsDirSuffix(core: core))/FwkTarget.framework' because its platform filter (\(filtersString)) does not match the platform filter of the current context (\(runDestination.platformFilterString)). (in target 'AppTarget' from project 'aProject')")
 
-                    results.checkNote("Skipping '/tmp/Test/Package/build/Debug\(runDestination.builtProductsDirSuffix)/PackageProduct::PkgTarget' because its platform filter (\(filtersString)) does not match the platform filter of the current context (\(runDestination.platformFilterString)). (in target 'AppTarget' from project 'aProject')")
+                    results.checkNote("Skipping '/tmp/Test/Package/build/Debug\(runDestination.builtProductsDirSuffix(core: core))/PackageProduct::PkgTarget' because its platform filter (\(filtersString)) does not match the platform filter of the current context (\(runDestination.platformFilterString)). (in target 'AppTarget' from project 'aProject')")
                 } else {
                     results.checkTasks(.matchTargetName("FwkTarget")) { tasks in
                         #expect(tasks.count != 0, "Expected at least one task for dependent framework target, but the dependent target was incorrectly filtered out")

Sources/SWBTestSupport/RunDestinationTestSupport.swift

@@ -22,6 +22,7 @@ package protocol _RunDestinationInfo {
     var platform: String { get }
     var sdk: String { get }
     var sdkVariant: String? { get }
+    var targetArchitecture: String { get }
 }
 
 extension _RunDestinationInfo {
@@ -377,15 +378,11 @@ extension _RunDestinationInfo {
         }
     }
 
-    package var builtProductsDirSuffix: String {
-        switch platform {
-        case "macosx" where sdk == "macosx" && sdkVariant == MacCatalystInfo.sdkVariantName:
+    package func builtProductsDirSuffix(core: Core) -> String {
+        if platform == "macosx" && sdkVariant == MacCatalystInfo.sdkVariantName {
             return MacCatalystInfo.publicSDKBuiltProductsDirSuffix
-        case "macosx":
-            return ""
-        default:
-            return "-\(platform)"
         }
+        return core.effectivePlatformName(platformName: platform, archComponent: targetArchitecture)
     }
 }
 

Sources/SwiftBuild/SWBBuildServiceConnection.swift

@@ -57,6 +57,12 @@ typealias swb_build_service_connection_message_handler_t = @Sendable (UInt64, SW
 
         /// Track whether the channels have been cleared because the service has crashed.
         var channelsHaveBeenCleared = false
+
+        /// A nil handler for a known channel is expected, service crash or client closed the channel before the reply arrived.
+        /// A nil handler for an unknown channel is unexpected.
+        func isChannelKnown(_ channel: UInt64) -> Bool {
+            return channel <= nextChannelID
+        }
     }
 
     /// An "unfair lock" that protects the channels state.  Should be held only for very short periods of time.
@@ -303,14 +309,6 @@ typealias swb_build_service_connection_message_handler_t = @Sendable (UInt64, SW
                         let channel = headerFrame.channel
                         let msgSize = Int(headerFrame.messageSize)
 
-                        // Look up the channel by its number.
-                        let handler = self.channelState.withLock({ $0.channels[channel] })
-                        if handler == nil {
-                            // It’s an error if we didn’t find a channel here.
-                            // FIXME: We need to handle this error in a better way.
-                            assertionFailure("no handler for channel: \(channel)")
-                        }
-
                         // If we don’t have all the data yet, we can go no further.
                         if offset + msgSize > data.count {
                             // Move the offset back to just before the header, so we’ll see it again next time around.
@@ -320,7 +318,15 @@ typealias swb_build_service_connection_message_handler_t = @Sendable (UInt64, SW
                         }
 
                         // Otherwise, look up the channel by its number.
-                        handler?(channel, data.subdata(in: offset..<(offset + msgSize)))
+                        let (handler, isChannelKnown) = self.channelState.withLock {
+                            return ($0.channels[channel], $0.isChannelKnown(channel))
+                        }
+
+                        if let handler {
+                            handler(channel, data.subdata(in: offset..<(offset + msgSize)))
+                        } else {
+                            assert(isChannelKnown, "Received reply for unknown channel: \(channel)")
+                        }
 
                         // Move on to the next message.
                         offset += msgSize