Add cross-compilation regression test

Author: kabiroberai

Sources/SKTestSupport/SkipUnless.swift

@@ -477,6 +477,56 @@ package actor SkipUnless {
     }
   }
 
+  package static func canSwiftPMCompileForIOS(
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) async throws {
+    struct NoSwiftInToolchain: Error {}
+
+    return try await shared.skipUnlessSupported(file: file, line: line) {
+      #if os(macOS)
+      guard let swift = await ToolchainRegistry.forTesting.default?.swift else {
+        throw NoSwiftInToolchain()
+      }
+
+      let project = try await SwiftPMTestProject(
+        files: [
+          "Lib/MyFile.swift": """
+          public func foo() {}
+          """,
+        ],
+        manifest: """
+        let package = Package(
+          name: "MyLibrary",
+          targets: [
+           .target(name: "Lib"),
+          ]
+        )
+        """
+      )
+      do {
+        var arguments = [
+          try swift.filePath, "build", "--package-path", try project.scratchDirectory.filePath, "--target", "Lib",
+          "--swift-sdk", "arm64-apple-ios",
+        ]
+        if let globalModuleCache = try globalModuleCache {
+          arguments += ["-Xswiftc", "-module-cache-path", "-Xswiftc", try globalModuleCache.filePath]
+        }
+        let status = try await Process.run(arguments: arguments, workingDirectory: nil)
+        guard case .terminated(code: 0) = status.exitStatus else {
+          let error = (try? String(decoding: status.stderrOutput.get(), as: UTF8.self)) ?? "unknown error"
+          return .featureUnsupported(skipMessage: "Cannot build for iOS: \(error)")
+        }
+        return .featureSupported
+      } catch {
+        return .featureUnsupported(skipMessage: "Cannot build for iOS: \(error)")
+      }
+      #else
+      return .featureUnsupported(skipMessage: "Cannot build for iOS outside macOS by default")
+      #endif
+    }
+  }
+
   package static func canCompileForWasm(
     file: StaticString = #filePath,
     line: UInt = #line

Tests/SourceKitLSPTests/BackgroundIndexingTests.swift

@@ -1018,6 +1018,53 @@ final class BackgroundIndexingTests: XCTestCase {
     )
   }
 
+  func testUseSwiftSDKFlagsDuringPreparation() async throws {
+    try await SkipUnless.canSwiftPMCompileForIOS()
+
+    var options = SourceKitLSPOptions.testDefault()
+    options.swiftPMOrDefault.swiftSDK = "arm64-apple-ios"
+    let project = try await SwiftPMTestProject(
+      files: [
+        "Lib/Lib.swift": """
+        #if os(iOS)
+        public func foo() -> Int { 1 }
+        #endif
+        """,
+        "Client/Client.swift": """
+        import Lib
+
+        func test() -> String {
+          return foo()
+        }
+        """,
+      ],
+      manifest: """
+        let package = Package(
+          name: "MyLibrary",
+          targets: [
+            .target(name: "Lib"),
+            .target(name: "Client", dependencies: ["Lib"]),
+          ]
+        )
+        """,
+      options: options,
+      enableBackgroundIndexing: true
+    )
+
+    // Check that we get an error about the return type of `foo` (`Int`) not being convertible to the return type of
+    // `test` (`String`), which indicates that `Lib` had `foo` and was thus compiled for iOS
+    let (uri, _) = try project.openDocument("Client.swift")
+    let diagnostics = try await project.testClient.send(
+      DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
+    )
+    XCTAssert(
+      (diagnostics.fullReport?.items ?? []).contains(where: {
+        $0.message == "Cannot convert return expression of type 'Int' to return type 'String'"
+      }),
+      "Did not get expected diagnostic: \(diagnostics)"
+    )
+  }
+
   func testLibraryUsedByExecutableTargetAndPackagePlugin() async throws {
     try await SkipUnless.swiftPMStoresModulesForTargetAndHostInSeparateFolders()
     let project = try await SwiftPMTestProject(