Implement --enable-parseable-module-interfaces for swift-build buildsystem

daveinglis · daveinglis · commit 395acee430fa · 2025-03-27T14:02:59.000-04:00
- this also fixes -enable-library-evolution when used as a unsafeFlags

Closes: 8337
diff --git a/Sources/SwiftBuildSupport/SwiftBuildSystem.swift b/Sources/SwiftBuildSupport/SwiftBuildSystem.swift
@@ -470,6 +470,11 @@ public final class SwiftBuildSystem: SPMBuildCore.BuildSystem {
             settings["ARCHS"] = architectures.joined(separator: " ")
         }
 
+        // support for --enable-parseable-module-interfaces
+        if buildParameters.driverParameters.enableParseableModuleInterfaces {
+            settings["SWIFT_EMIT_MODULE_INTERFACE"] = "YES"
+        }
+
         // Generate the build parameters.
         var params = SwiftBuild.SWBBuildParameters()
         params.configurationName = buildParameters.configuration.swiftbuildName
diff --git a/Sources/_InternalTestSupport/SwiftPMProduct.swift b/Sources/_InternalTestSupport/SwiftPMProduct.swift
@@ -97,7 +97,8 @@ extension SwiftPM {
         
         let returnValue = (stdout: stdout, stderr: stderr)
         if (!throwIfCommandFails) { return returnValue }
-
+        // print("STDOUT:\n\(stdout)")
+        // print("STDER:\n\(stderr)")
         if result.exitStatus == .terminated(code: 0) {
             return returnValue
         }
@@ -142,6 +143,7 @@ extension SwiftPM {
             completeArgs += ["--package-path", packagePath.pathString]
         }
         completeArgs += args
+//        print("EXE:\(completeArgs)")
 
         return try await AsyncProcess.popen(arguments: completeArgs, environment: environment)
     }
diff --git a/Tests/CommandsTests/BuildCommandTests.swift b/Tests/CommandsTests/BuildCommandTests.swift
@@ -38,7 +38,7 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
     }
 
     @discardableResult
-    private func execute(
+    func execute(
         _ args: [String] = [],
         environment: Environment? = nil,
         packagePath: AbsolutePath? = nil
@@ -70,7 +70,18 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
                 // is what `binContents` is meant to represent.
                 return contents != ["output-file-map.json"]
             }
-            let moduleContents = (try? localFileSystem.getDirectoryContents(binPath.appending(component: "Modules"))) ?? []
+            var moduleContents:[String] = []
+            if buildSystemProvider == .native {
+                moduleContents = (try? localFileSystem.getDirectoryContents(binPath.appending(component: "Modules"))) ?? []
+            } else {
+                let moduleDirs = (try? localFileSystem.getDirectoryContents(binPath).filter {
+                    return $0.hasSuffix(".swiftmodule")
+                }) ?? []
+                for dir: String in moduleDirs {
+                    moduleContents += (try? localFileSystem.getDirectoryContents(binPath.appending(component: dir)).map { "\(dir)/\($0)" }) ?? []
+                }
+            }
+            
 
             if cleanAfterward {
                 try! await executeSwiftPackage(
@@ -190,48 +201,6 @@ class BuildCommandTestCases: CommandsBuildProviderTestCase {
         }
     }
 
-    func testBinSymlink() async throws {
-        try await fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { fixturePath in
-            let fullPath = try resolveSymlinks(fixturePath)
-            let targetPath = try fullPath.appending(
-                components: ".build",
-                UserToolchain.default.targetTriple.platformBuildPathComponent
-            )
-            let xcbuildTargetPath = fullPath.appending(components: ".build", "apple")
-            try await XCTAssertAsyncEqual(
-                try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout,
-                "\(targetPath.appending("debug").pathString)\n"
-            )
-            try await XCTAssertAsyncEqual(
-                try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath).stdout,
-                "\(targetPath.appending("release").pathString)\n"
-            )
-
-            guard buildSystemProvider == .xcode  || buildSystemProvider == .swiftbuild else {
-                // The remainder of this test only applies to XCBuild or Swift Build
-                return
-            }
-
-            // Print correct path when building with XCBuild or Swift Build
-            let xcodeDebugOutput = try await execute(
-                ["-c", "debug", "--show-bin-path"],
-                packagePath: fullPath)
-            .stdout
-            let xcodeReleaseOutput = try await execute(
-                ["-c", "release", "--show-bin-path"],
-                packagePath: fullPath
-            ).stdout
-            XCTAssertEqual(
-                xcodeDebugOutput,
-                "\(xcbuildTargetPath.appending(components: "Products", "Debug").pathString)\n"
-            )
-            XCTAssertEqual(
-                xcodeReleaseOutput,
-                "\(xcbuildTargetPath.appending(components: "Products", "Release").pathString)\n"
-            )
-        }
-    }
-
     func testSymlink() async throws {
         try await fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { fixturePath in
             let fullPath = try resolveSymlinks(fixturePath)
@@ -792,6 +761,24 @@ class BuildCommandNativeTests: BuildCommandTestCases {
     override func testUsage() async throws {
         try await super.testUsage()
     }
+
+    func testBinSymlink() async throws {
+        try await fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { fixturePath in
+            let fullPath = try resolveSymlinks(fixturePath)
+            let targetPath = try fullPath.appending(
+                components: ".build",
+                UserToolchain.default.targetTriple.platformBuildPathComponent
+            )
+            try await XCTAssertAsyncEqual(
+                try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout,
+                "\(targetPath.appending("debug").pathString)\n"
+            )
+            try await XCTAssertAsyncEqual(
+                try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath).stdout,
+                "\(targetPath.appending("release").pathString)\n"
+            )
+        }
+    }
 }
 
 #if os(macOS)
@@ -806,47 +793,47 @@ class BuildCommandXcodeTests: BuildCommandTestCases {
     }
 
     override func testAutomaticParseableInterfacesWithLibraryEvolution() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testNonReachableProductsAndTargetsFunctional() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testCodeCoverage() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testBuildStartMessage() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
-    override func testBinSymlink() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+    func testBinSymlink() async throws {
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testSymlink() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testSwiftGetVersion() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testParseableInterfaces() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testProductAndTarget() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testImportOfMissedDepWarning() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testGetTaskAllowEntitlement() async throws {
-        try XCTSkip("Test not implemented for xcode build system.")
+        throw XCTSkip("Test not implemented for xcode build system.")
     }
 
     override func testBuildCompleteMessage() async throws {
@@ -861,14 +848,36 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
         return .swiftbuild
     }
 
-    override func testNonReachableProductsAndTargetsFunctional() async throws {
-        throw XCTSkip("SWBINTTODO: Test failed. This needs to be investigated")
-    }
-
     override func testParseableInterfaces() async throws {
-        throw XCTSkip("SWBINTTODO: Test failed with swiftbuild engine because the --enable-parseable-module-interfaces flag doesn't yet produce .swiftinterface files. This needs to be investigated")
+        try await fixture(name: "Miscellaneous/ParseableInterfaces") { fixturePath in
+            do {
+                let result = try await build(["--enable-parseable-module-interfaces"], packagePath: fixturePath)
+                XCTAssertMatch(result.moduleContents, [.regex(#"A\.swiftmodule\/.*\.swiftinterface"#)])
+                XCTAssertMatch(result.moduleContents, [.regex(#"B\.swiftmodule\/.*\.swiftmodule"#)])
+            } catch SwiftPMError.executionFailure(_, _, let stderr) {
+                XCTFail(stderr)
+            }
+        }
     }
 
+    func testBinSymlink() async throws {
+        try await fixture(name: "ValidLayouts/SingleModule/ExecutableNew") { fixturePath in
+            let fullPath = try resolveSymlinks(fixturePath)
+            let targetPath = try fullPath.appending(
+                components: ".build",
+                UserToolchain.default.targetTriple.platformBuildPathComponent
+            )
+            try await XCTAssertAsyncEqual(
+                try await self.execute(["--show-bin-path"], packagePath: fullPath).stdout,
+                "\(targetPath.appending(components: "Products", "Debug").pathString)\n"
+            )
+            try await XCTAssertAsyncEqual(
+                try await self.execute(["-c", "release", "--show-bin-path"], packagePath: fullPath).stdout,
+                "\(targetPath.appending(components: "Products", "Release").pathString)\n"
+            )
+        }    
+    }
+    
     override func testGetTaskAllowEntitlement() async throws {
         throw XCTSkip("SWBINTTODO: Test failed because swiftbuild doesn't output precis codesign commands. Once swift run works with swiftbuild the test can be investigated.")
     }
@@ -886,7 +895,13 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
     }
 
     override func testAutomaticParseableInterfacesWithLibraryEvolution() async throws {
-        throw XCTSkip("SWBINTTODO: The test fails because when the unsafe flag for a target is set to '-enable-library-evolution' it is not producing the correct .swiftinterface files. This needs to be investigated")
+        try await fixture(name: "Miscellaneous/LibraryEvolution") { fixturePath in
+            do {
+                let result = try await build([], packagePath: fixturePath)
+                XCTAssertMatch(result.moduleContents, [.regex(#"A\.swiftmodule\/.*\.swiftinterface"#)])
+                XCTAssertMatch(result.moduleContents, [.regex(#"B\.swiftmodule\/.*\.swiftmodule"#)])
+            }
+        }
     }
 
     override func testImportOfMissedDepWarning() async throws {
@@ -901,10 +916,6 @@ class BuildCommandSwiftBuildTests: BuildCommandTestCases {
         throw XCTSkip("SWBINTTODO: Test fails because the dummy-swiftc used in the test isn't accepted by swift-build. This needs to be investigated")
     }
 
-    override func testBinSymlink() async throws {
-        throw XCTSkip("SWBINTTODO: Test fails because of a difference in the build layout. This needs to be updated to the expected path")
-    }
-
     override func testSymlink() async throws {
         throw XCTSkip("SWBINTTODO: Test fails because of a difference in the build layout. This needs to be updated to the expected path")
     }

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,8 @@ extension SwiftPM {`
`97`	`97`
`98`	`98`	`let returnValue = (stdout: stdout, stderr: stderr)`
`99`	`99`	`if (!throwIfCommandFails) { return returnValue }`
`100`		`-`
	`100`	`+ // print("STDOUT:\n\(stdout)")`
	`101`	`+ // print("STDER:\n\(stderr)")`
`101`	`102`	`if result.exitStatus == .terminated(code: 0) {`
`102`	`103`	`return returnValue`
`103`	`104`	`}`
`@@ -142,6 +143,7 @@ extension SwiftPM {`
`142`	`143`	`completeArgs += ["--package-path", packagePath.pathString]`
`143`	`144`	`}`
`144`	`145`	`completeArgs += args`
	`146`	`+// print("EXE:\(completeArgs)")`
`145`	`147`
`146`	`148`	`return try await AsyncProcess.popen(arguments: completeArgs, environment: environment)`
`147`	`149`	`}`