Verify module interfaces generated from emit-module jobs

The Verify job was previously only added after merge-module jobs.

Author: xymus

Sources/SwiftDriver/Jobs/Planning.swift

@@ -104,7 +104,7 @@ extension Driver {
 
     try addPrecompileModuleDependenciesJobs(addJob: addJobBeforeCompiles)
     try addPrecompileBridgingHeaderJob(addJob: addJobBeforeCompiles)
-    try addEmitModuleJob(addJob: addJobBeforeCompiles)
+    try addEmitModuleJob(addJobBeforeCompiles: addJobBeforeCompiles, addJobAfterCompiles: addJobAfterCompiles)
     let linkerInputs = try addJobsFeedingLinker(
       addJobBeforeCompiles: addJobBeforeCompiles,
       addCompileJobGroup: addCompileJobGroup,
@@ -183,9 +183,11 @@ extension Driver {
     )
   }
 
-  private mutating func addEmitModuleJob(addJob: (Job) -> Void) throws {
+  private mutating func addEmitModuleJob(addJobBeforeCompiles: (Job) -> Void, addJobAfterCompiles: (Job) -> Void) throws {
     if shouldCreateEmitModuleJob {
-      addJob( try emitModuleJob() )
+      let emitModuleJob = try emitModuleJob()
+      addJobBeforeCompiles(emitModuleJob)
+      try addVerifyJobs(mergeJob: emitModuleJob, addJob: addJobAfterCompiles)
     }
   }
 
@@ -221,9 +223,11 @@ extension Driver {
       }
     }
 
-    try addSingleCompileJobs(addJob: addJobBeforeCompiles,
+    if let compileJob = try addSingleCompileJobs(addJob: addJobBeforeCompiles,
                              addJobOutputs: addJobOutputs,
-                             emitModuleTrace: loadedModuleTracePath != nil)
+                             emitModuleTrace: loadedModuleTracePath != nil) {
+      try addVerifyJobs(mergeJob: compileJob, addJob: addJobAfterCompiles)
+    }
 
     try addJobsForPrimaryInputs(
       addCompileJobGroup: addCompileJobGroup,
@@ -253,9 +257,9 @@ extension Driver {
     addJob: (Job) -> Void,
     addJobOutputs: ([TypedVirtualPath]) -> Void,
     emitModuleTrace: Bool
-  ) throws {
+  ) throws -> Job? {
     guard case .singleCompile = compilerMode
-    else { return }
+    else { return nil }
 
     if parsedOptions.hasArgument(.embedBitcode),
        inputFiles.allSatisfy({ $0.type.isPartOfSwiftCompilation }) {
@@ -270,6 +274,7 @@ extension Driver {
           : nil
       }
       backendJobs.forEach(addJob)
+      return compile
     } else {
       // We can skip the compile jobs if all we want is a module when it's
       // built separately.
@@ -278,6 +283,7 @@ extension Driver {
                                    addJobOutputs: addJobOutputs,
                                    emitModuleTrace: emitModuleTrace)
       addJob(compile)
+      return compile
     }
   }
 

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -3640,13 +3640,56 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertTrue(verifyJob.outputs.isEmpty)
       XCTAssertTrue(verifyJob.commandLine.contains(.path(mergeInterfaceOutputs[0].file)))
     }
+
     // No Evolution
     do {
       var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module", "-module-name",
                                      "foo", "-emit-module-interface", "-verify-emitted-module-interface"])
       let plannedJobs = try driver.planBuild()
       XCTAssertEqual(plannedJobs.count, 2)
     }
+
+    // Emit-module separately
+    do {
+      var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module", "-module-name",
+                                     "foo", "-emit-module-interface",
+                                     "-verify-emitted-module-interface",
+                                     "-enable-library-evolution",
+                                     "-experimental-emit-module-separately"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 2)
+      let emitJob = plannedJobs[0]
+      let verifyJob = plannedJobs[1]
+      XCTAssertEqual(emitJob.kind, .emitModule)
+      let emitInterfaceOutput = emitJob.outputs.filter { $0.type == .swiftInterface }
+      XCTAssertTrue(emitInterfaceOutput.count == 1,
+                    "Emit module job should only have one swiftinterface output")
+      XCTAssertEqual(verifyJob.kind, .verifyModuleInterface)
+      XCTAssertTrue(verifyJob.inputs.count == 1)
+      XCTAssertTrue(verifyJob.inputs[0] == emitInterfaceOutput[0])
+      XCTAssertTrue(verifyJob.commandLine.contains(.path(emitInterfaceOutput[0].file)))
+    }
+
+    // Whole-module
+    do {
+      var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module", "-module-name",
+                                     "foo", "-emit-module-interface",
+                                     "-verify-emitted-module-interface",
+                                     "-enable-library-evolution",
+                                     "-whole-module-optimization"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 2)
+      let emitJob = plannedJobs[0]
+      let verifyJob = plannedJobs[1]
+      XCTAssertEqual(emitJob.kind, .compile)
+      let emitInterfaceOutput = emitJob.outputs.filter { $0.type == .swiftInterface }
+      XCTAssertTrue(emitInterfaceOutput.count == 1,
+                    "Emit module job should only have one swiftinterface output")
+      XCTAssertEqual(verifyJob.kind, .verifyModuleInterface)
+      XCTAssertTrue(verifyJob.inputs.count == 1)
+      XCTAssertTrue(verifyJob.inputs[0] == emitInterfaceOutput[0])
+      XCTAssertTrue(verifyJob.commandLine.contains(.path(emitInterfaceOutput[0].file)))
+    }
   }
 
   func testPCHGeneration() throws {