WIP: Prototype for a TemporaryDirectoryTrait and AsyncDeferrableTrait

I just want to raise the idea of using test traits over `with` function to avoid nesting levels due to `with*` functions in tests.

Author: ahoppen

Tests/SwiftBuildTests/PreferredRunDestinationTests.swift

@@ -18,36 +18,118 @@ import SWBTestSupport
 
 @Suite
 fileprivate struct PreferredRunDestinationTests {
-    @Test(.requireSDKs(.macOS))
+    @Test(.requireSDKs(.macOS), .temporaryDirectory, .asyncDeferrable)
     func platformExists() async throws {
-        try await withTemporaryDirectory { (temporaryDirectory: NamedTemporaryDirectory) in
-            try await withAsyncDeferrable { deferrable in
-                let testSession = try await TestSWBSession(temporaryDirectory: temporaryDirectory)
-                await deferrable.addBlock {
-                    await #expect(throws: Never.self) {
-                        try await testSession.close()
-                    }
+        let testSession = try await TestSWBSession(temporaryDirectory: TemporaryDirectoryTrait.temporaryDirectory)
+        try await AsyncDeferrableTrait.defer {
+            try await testSession.close()
+        }
+        let runDestination = try await testSession.session.preferredRunDestination(forPlatform: "macosx")
+        #expect(runDestination.sdk == "macosx")
+    }
+
+    @Test(.temporaryDirectory, .asyncDeferrable)
+    func unknownPlatform() async throws {
+        let testSession = try await TestSWBSession(temporaryDirectory: TemporaryDirectoryTrait.temporaryDirectory)
+        try await AsyncDeferrableTrait.defer {
+            try await testSession.close()
+        }
+        await #expect(throws: (any Error).self) {
+            try await testSession.session.preferredRunDestination(forPlatform: "unknown_platform")
+        }
+    }
+}
+
+struct TemporaryDirectoryTrait: TestTrait {
+    @TaskLocal private static var _temporaryDirectory: NamedTemporaryDirectory?
+
+    static var temporaryDirectory: NamedTemporaryDirectory {
+        get throws {
+            guard let _temporaryDirectory else {
+                throw StubError.error("Accessing temporary directory in test that doesn't specify .temporaryDirectory trait")
+            }
+            return _temporaryDirectory
+        }
+    }
+
+    package init() {}
+
+    struct TestScopeProvider: TestScoping {
+        func provideScope(
+            for test: Test,
+            testCase: Test.Case?,
+            performing function: @Sendable () async throws -> Void
+        ) async throws {
+            try await withTemporaryDirectory { temporaryDirectory in
+                try await $_temporaryDirectory.withValue(temporaryDirectory) {
+                    try await function()
                 }
-                let runDestination = try await testSession.session.preferredRunDestination(forPlatform: "macosx")
-                #expect(runDestination.sdk == "macosx")
             }
         }
     }
 
-    @Test
-    func unknownPlatform() async throws {
-        try await withTemporaryDirectory { (temporaryDirectory: NamedTemporaryDirectory) in
+    func scopeProvider(for test: Test, testCase: Test.Case?) -> TestScopeProvider? {
+        guard testCase != nil else {
+            // We only need to set up a new temporary directory for the execution of a parameterized version of the test.
+            return nil
+        }
+        return TestScopeProvider()
+    }
+}
+
+extension Trait where Self == TemporaryDirectoryTrait {
+    static var temporaryDirectory: TemporaryDirectoryTrait {
+        return TemporaryDirectoryTrait()
+    }
+}
+
+struct AsyncDeferrableTrait: TestTrait {
+    @TaskLocal private static var _deferrable: Deferrable?
+
+    static var deferrable: Deferrable {
+        get throws {
+            guard let _deferrable else {
+                throw StubError.error("Accessing temporary directory in test that doesn't specify .asyncDeferrable trait")
+            }
+            return _deferrable
+        }
+    }
+
+    static func `defer`(sourceLocation: SourceLocation = #_sourceLocation, _ body: @escaping @Sendable () async throws -> Void) async throws {
+        try await deferrable.addBlock {
+            await #expect(throws: Never.self, sourceLocation: sourceLocation) {
+                try await body()
+            }
+        }
+    }
+
+    package init() {}
+
+    struct TestScopeProvider: TestScoping {
+        func provideScope(
+            for test: Test,
+            testCase: Test.Case?,
+            performing function: @Sendable () async throws -> Void
+        ) async throws {
             try await withAsyncDeferrable { deferrable in
-                let testSession = try await TestSWBSession(temporaryDirectory: temporaryDirectory)
-                await deferrable.addBlock {
-                    await #expect(throws: Never.self) {
-                        try await testSession.close()
-                    }
-                }
-                await #expect(throws: (any Error).self) {
-                    try await testSession.session.preferredRunDestination(forPlatform: "unknown_platform")
+                try await $_deferrable.withValue(deferrable) {
+                    try await function()
                 }
             }
         }
     }
+
+    func scopeProvider(for test: Test, testCase: Test.Case?) -> TestScopeProvider? {
+        guard testCase != nil else {
+            // We only need to set up a deferrable for the execution of a parameterized version of the test.
+            return nil
+        }
+        return TestScopeProvider()
+    }
+}
+
+extension Trait where Self == AsyncDeferrableTrait {
+    static var asyncDeferrable: AsyncDeferrableTrait {
+        return AsyncDeferrableTrait()
+    }
 }