Strengthen wasmSwiftSDKDependencySpecialization test

Author: MaxDesiatov

Tests/SWBWebAssemblyPlatformTests/SWBWebAssemblyPlatformTests.swift

@@ -130,14 +130,21 @@ fileprivate struct SWBWebAssemblyPlatformTests: CoreBasedTests {
     /// Regression test: a wasm app target depending on a library with platform specialization
     /// must not fail with `unable to find sdk 'webassembly'`.
     ///
-    /// The failure is triggered by `SpecializationParameters.imposed(on:workspaceContext:)`
-    /// in `swift-build/Sources/SWBCore/DependencyResolution.swift`, which sets
-    /// `SDKROOT = platform.sdkCanonicalName` (= `"webassembly"`) on dependencies — and the
-    /// SDK registry has no SDK or alias by that canonical name when only a Swift SDK is
-    /// providing the wasm sysroot.
+    /// Two code paths in swift-build push `SDKROOT = platform.sdkCanonicalName` (= `"webassembly"`)
+    /// for Swift-SDK-backed builds, neither of which has a matching SDK in the registry when the
+    /// only wasm sysroot comes from a synthesized Swift SDK (whose canonical name is the manifest
+    /// path, not the platform name):
+    ///
+    /// 1. `SpecializationParameters.imposed(on:workspaceContext:)`
+    ///    in `swift-build/Sources/SWBCore/DependencyResolution.swift` — exercised by `MyLibrary`,
+    ///    which is reachable via specialization from `MyApp`.
+    /// 2. `addRunDestinationSettingsPlatformSDK` in
+    ///    `swift-build/Sources/SWBCore/Settings/Settings.swift` else branch — exercised by
+    ///    `MyMacOSLib`, whose configured SDK (`macosx`) does not match the destination platform
+    ///    (`webassembly`) but whose `SUPPORTED_PLATFORMS` still includes wasm.
     @Test(.requireSDKs(.host))
     func wasmSwiftSDKDependencySpecialization() async throws {
-        try await withTemporaryDirectory { tmpDir in
+        try await withTemporaryDirectory { (tmpDir: Path) in
             let clangCompilerPath = try await self.clangCompilerPath
             let swiftCompilerPath = try await self.swiftCompilerPath
             let swiftVersion = try await self.swiftVersion
@@ -148,6 +155,7 @@ fileprivate struct SWBWebAssemblyPlatformTests: CoreBasedTests {
                     children: [
                         TestFile("App.swift"),
                         TestFile("Lib.swift"),
+                        TestFile("MacLib.swift"),
                     ]),
                 targets: [
                     TestStandardTarget(
@@ -170,8 +178,10 @@ fileprivate struct SWBWebAssemblyPlatformTests: CoreBasedTests {
                         buildPhases: [
                             TestSourcesBuildPhase([TestBuildFile("App.swift")]),
                         ],
-                        dependencies: ["MyLibrary"]
+                        dependencies: ["MyLibrary", "MyMacOSLib"]
                     ),
+                    // Exercises DependencyResolution.swift `SpecializationParameters.imposed(on:)`:
+                    // gets specialized to wasm via the dependency from MyApp.
                     TestStandardTarget(
                         "MyLibrary",
                         type: .staticLibrary,
@@ -193,6 +203,31 @@ fileprivate struct SWBWebAssemblyPlatformTests: CoreBasedTests {
                         buildPhases: [
                             TestSourcesBuildPhase([TestBuildFile("Lib.swift")]),
                         ]),
+                    // Exercises Settings.swift `addRunDestinationSettingsPlatformSDK` else branch:
+                    // configured SDK ("macosx") differs from destination platform ("webassembly")
+                    // but SUPPORTED_PLATFORMS includes wasm, so the SDK gets re-targeted.
+                    // No ALLOW_TARGET_PLATFORM_SPECIALIZATION here — that flag would short-circuit
+                    // the early-return guard at Settings.swift:3600 and skip the else branch.
+                    TestStandardTarget(
+                        "MyMacOSLib",
+                        type: .staticLibrary,
+                        buildConfigurations: [
+                            TestBuildConfiguration("Debug",
+                                                   buildSettings: [
+                                                    "PRODUCT_NAME": "$(TARGET_NAME)",
+                                                    "SDKROOT": "macosx",
+                                                    "SUPPORTED_PLATFORMS": "$(AVAILABLE_PLATFORMS)",
+                                                    "CLANG_ENABLE_MODULES": "YES",
+                                                    "SWIFT_EXEC": swiftCompilerPath.str,
+                                                    "SWIFT_VERSION": swiftVersion,
+                                                    "CC": clangCompilerPath.str,
+                                                    "CLANG_EXPLICIT_MODULES_LIBCLANG_PATH": libClangPath.str,
+                                                    "CLANG_USE_RESPONSE_FILE": "NO",
+                                                   ]),
+                        ],
+                        buildPhases: [
+                            TestSourcesBuildPhase([TestBuildFile("MacLib.swift")]),
+                        ]),
                 ])
             // Use a dedicated core for this test so the SDKs it registers do not impact other tests
             let core = try await Self.makeCore()
@@ -225,10 +260,42 @@ fileprivate struct SWBWebAssemblyPlatformTests: CoreBasedTests {
                 """)
             })
 
+            let sysroot = sdkManifestDir.join("WASI.sdk")
+            let sdkroot = sdkManifestDir.join("WASI.sdk")
+
             let destination = try RunDestinationInfo(sdkManifestPath: sdkManifestPath, triple: "wasm32-unknown-wasip1", targetArchitecture: "wasm32", supportedArchitectures: ["wasm32"], disableOnlyActiveArch: false, core: core)
             let parameters = BuildParameters(configuration: "Debug", activeRunDestination: destination)
-            await tester.checkBuild(parameters, runDestination: nil, fs: localFS) { results in
-                // The bug surfaces as an error literally containing "unable to find sdk 'webassembly'".
+
+            // Path 1: build MyApp — exercises DependencyResolution.swift `SpecializationParameters.imposed(on:)`
+            // because MyLibrary is reached via dependency from MyApp, which pre-imposes SDKROOT.
+            // Without the DependencyResolution fix, MyLibrary's specialized configuration would
+            // fail with `unable to find sdk 'webassembly'`.
+            await tester.checkBuild(parameters, runDestination: nil, targetName: "MyApp", fs: localFS) { results in
+                results.checkTask(.matchTargetName("MyLibrary"), .matchRuleType("SwiftDriver Compilation")) { task in
+                    task.checkCommandLineContains([
+                        ["-static-stdlib"],
+                        ["-sdk", sdkroot.str],
+                        ["-sysroot", sysroot.str],
+                        ["-target", "wasm32-unknown-wasip1"],
+                    ].reduce([], +))
+                }
+
+                results.checkNoErrors()
+            }
+
+            // Path 2: build MyMacOSLib standalone — exercises Settings.swift `addRunDestinationSettingsPlatformSDK`
+            // else branch because no dependency imposes SDKROOT, and the target's own SDK ("macosx")
+            // doesn't match the destination platform ("webassembly"). Without the Settings.swift fix,
+            // this branch would push SDKROOT="webassembly" and the lookup would fail.
+            await tester.checkBuild(parameters, runDestination: nil, targetName: "MyMacOSLib", fs: localFS) { results in
+                results.checkTask(.matchTargetName("MyMacOSLib"), .matchRuleType("SwiftDriver Compilation")) { task in
+                    task.checkCommandLineContains([
+                        ["-sdk", sdkroot.str],
+                        ["-sysroot", sysroot.str],
+                        ["-target", "wasm32-unknown-wasip1"],
+                    ].reduce([], +))
+                }
+
                 results.checkNoErrors()
             }
         }