Test sanitizers with build plans. (#2720)

The current tests for sanitizers in SwiftPM are essentially "live": they
build a package that will do something to trigger a sanitizer, and then
run it and confirm it fails. This is a pretty fragile way to test, and
it exposes SwiftPM to a number of possible test failures that don't
have anything to do with the core mission (exposing the sanitizer).

This patch replaces those tests with build plan tests that validate that
SwiftPM correctly invokes swiftc and clang. These tests are acceptable
because for now SwiftPM doesn't have any smarts with the sanitizers: it
just passes them all through to swiftc and clang.

This patch also deletes the current live tests, as they are no longer
necessary.

Author: Lukasa

Fixtures/Miscellaneous/DoubleFree/Package.swift

@@ -2351,6 +2351,73 @@ final class BuildPlanTests: XCTestCase {
         let dynamicLibraryPathExtension = try result.buildProduct(for: "Library").binary.extension
         XCTAssertMatch(dynamicLibraryPathExtension, "dylib")
     }
+
+    func testAddressSanitizer() throws {
+        try sanitizerTest(.address, expectedName: "address")
+    }
+
+    func testThreadSanitizer() throws {
+        try sanitizerTest(.thread, expectedName: "thread")
+    }
+
+    func testUndefinedSanitizer() throws {
+        try sanitizerTest(.undefined, expectedName: "undefined")
+    }
+
+    func testScudoSanitizer() throws {
+        try sanitizerTest(.scudo, expectedName: "scudo")
+    }
+
+    private func sanitizerTest(_ sanitizer: Sanitizer, expectedName: String) throws {
+        let fs = InMemoryFileSystem(emptyFiles:
+            "/Pkg/Sources/exe/main.swift",
+            "/Pkg/Sources/lib/lib.swift",
+            "/Pkg/Sources/clib/clib.c",
+            "/Pkg/Sources/clib/include/clib.h"
+        )
+
+        let diagnostics = DiagnosticsEngine()
+        let graph = loadPackageGraph(fs: fs, diagnostics: diagnostics,
+            manifests: [
+                Manifest.createV4Manifest(
+                    name: "Pkg",
+                    path: "/Pkg",
+                    url: "/Pkg",
+                    packageKind: .root,
+                    targets: [
+                        TargetDescription(name: "exe", dependencies: ["lib", "clib"]),
+                        TargetDescription(name: "lib", dependencies: []),
+                        TargetDescription(name: "clib", dependencies: []),
+                    ]),
+            ]
+        )
+        XCTAssertNoDiagnostics(diagnostics)
+
+        // Unrealistic: we can't enable all of these at once on all platforms.
+        // This test codifies current behaviour, not ideal behaviour, and
+        // may need to be amended if we change it.
+        var parameters = mockBuildParameters(shouldLinkStaticSwiftStdlib: true)
+        parameters.sanitizers = EnabledSanitizers([sanitizer])
+
+        let result = BuildPlanResult(plan: try BuildPlan(
+            buildParameters: parameters,
+            graph: graph, diagnostics: diagnostics, fileSystem: fs)
+        )
+
+        result.checkProductsCount(1)
+        result.checkTargetsCount(3)
+
+        let exe = try result.target(for: "exe").swiftTarget().compileArguments()
+        XCTAssertTrue(exe.contains("-sanitize=\(expectedName)"))
+
+        let lib = try result.target(for: "lib").swiftTarget().compileArguments()
+        XCTAssertTrue(lib.contains("-sanitize=\(expectedName)"))
+
+        let clib  = try result.target(for: "clib").clangTarget().basicArguments()
+        XCTAssertTrue(clib.contains("-fsanitize=\(expectedName)"))
+
+        XCTAssertTrue(try result.buildProduct(for: "exe").linkArguments().contains("-sanitize=\(expectedName)"))
+    }
 }
 
 // MARK:- Test Helpers

Fixtures/Miscellaneous/DoubleFree/README.md

@@ -103,52 +103,4 @@ final class RunToolTests: XCTestCase {
             }
         }
     }
-
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-      #if os(macOS)
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftRun.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
-
-    func testSanitizeScudo() throws {
-        // Scudo is only supported on Linux.
-      #if os(Linux)
-        fixture(name: "Miscellaneous/DoubleFree") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let cmdline = {
-                try SwiftPMProduct.SwiftRun.execute(
-                    ["--sanitize=scudo"], packagePath: path)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("invalid chunk state"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
 }

Fixtures/Miscellaneous/DoubleFree/Sources/exec/main.swift

@@ -30,32 +30,6 @@ final class TestToolTests: XCTestCase {
         XCTAssert(try execute(["--version"]).stdout.contains("Swift Package Manager"))
     }
 
-    // Test that thread sanitizer works.
-    func testSanitizeThread() throws {
-        // FIXME: We need to figure out how to test this for linux.
-        // Disabled because of https://bugs.swift.org/browse/SR-7272
-      #if false
-        fixture(name: "Miscellaneous/ThreadRace") { path in
-            // Ensure that we don't abort() when we find the race. This avoids
-            // generating the crash report on macOS.
-            let env = ["TSAN_OPTIONS": "abort_on_error=0"]
-            let cmdline = {
-                try SwiftPMProduct.SwiftTest.execute(
-                    ["--sanitize=thread"], packagePath: path, env: env)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("ThreadSanitizer: data race"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
-    
     func testNumWorkersParallelRequeriment() throws {
         // Running swift-test fixtures on linux is not yet possible.
         #if os(macOS)
@@ -80,25 +54,4 @@ final class TestToolTests: XCTestCase {
         }
         #endif
     }
-
-    func testSanitizeScudo() throws {
-        // This test only runs on Linux because Scudo only runs on Linux
-      #if os(Linux)
-        fixture(name: "Miscellaneous/DoubleFree") { path in
-            let cmdline = {
-                try SwiftPMProduct.SwiftTest.execute(
-                    ["--sanitize=scudo"], packagePath: path)
-            }
-            XCTAssertThrows(try cmdline()) { (error: SwiftPMProductError) in
-                switch error {
-                case .executionFailure(_, _, let error):
-                    XCTAssertMatch(error, .contains("invalid chunk state"))
-                    return true
-                default:
-                    return false
-                }
-            }
-        }
-      #endif
-    }
 }