Don't capture arguments to #expect(exitsWith:) during macro expansion. (#912)

Other than the body closure, the arguments to `#expect(exitsWith:)` are
not guaranteed to be literals or otherwise context-free, but we capture
them during macro expansion. This can result in obscure errors if the
developer writes an exit test with an argument that is computed:

```swift
let foo = ...
await #expect(exitsWith: self.exitCondition(for: foo)) {
  // 🛑 error: closure captures 'foo' before it is declared
  // 🛑 error: enum declaration cannot close over value 'self' defined in outer scope
  // (and other possible errors)
  ...
}
```

This PR removes the macro's compile-time dependency on its
`exitCondition` and `sourceLocation` arguments and introduces an `ID`
type to identify exit tests (instead of using their source locations as
unique IDs.) The `ID` type is meant to be a UUID, but for the moment
I've just strung together two 64-bit integers instead to avoid a
dependency on Foundation or platform API.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Documentation/ABI/TestContent.md

@@ -118,9 +118,17 @@ to by `hint` depend on the kind of record:
 - For exit test declarations (kind `0x65786974`), the accessor produces a
   structure describing the exit test (of type `__ExitTest`.)
 
-  Test content records of this kind accept a `hint` of type `SourceLocation`.
-  They only produce a result if they represent an exit test declared at the same
-  source location (or if the hint is `nil`.)
+  Test content records of this kind accept a `hint` of type `__ExitTest.ID`.
+  They only produce a result if they represent an exit test declared with the
+  same ID (or if `hint` is `nil`.)
+
+> [!WARNING]
+> Calling code should use [`withUnsafeTemporaryAllocation(of:capacity:_:)`](https://developer.apple.com/documentation/swift/withunsafetemporaryallocation(of:capacity:_:))
+> and [`withUnsafePointer(to:_:)`](https://developer.apple.com/documentation/swift/withunsafepointer(to:_:)-35wrn),
+> respectively, to ensure the pointers passed to `accessor` are large enough and
+> are well-aligned. If they are not large enough to contain values of the
+> appropriate types (per above), or if `hint` points to uninitialized or
+> incorrectly-typed memory, the result is undefined.
 
 #### The context field
 

Sources/Testing/ExitTests/ExitTest.swift

@@ -52,16 +52,25 @@ public typealias ExitTest = __ExitTest
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 public struct __ExitTest: Sendable, ~Copyable {
-  /// The expected exit condition of the exit test.
-  @_spi(ForToolsIntegrationOnly)
-  public var expectedExitCondition: ExitCondition
+  /// A type whose instances uniquely identify instances of `__ExitTest`.
+  public struct ID: Sendable, Equatable, Codable {
+    /// An underlying UUID (stored as two `UInt64` values to avoid relying on
+    /// `UUID` from Foundation or any platform-specific interfaces.)
+    private var _lo: UInt64
+    private var _hi: UInt64
+
+    /// Initialize an instance of this type.
+    ///
+    /// - Warning: This member is used to implement the `#expect(exitsWith:)`
+    ///   macro. Do not use it directly.
+    public init(__uuid uuid: (UInt64, UInt64)) {
+      self._lo = uuid.0
+      self._hi = uuid.1
+    }
+  }
 
-  /// The source location of the exit test.
-  ///
-  /// The source location is unique to each exit test and is consistent between
-  /// processes, so it can be used to uniquely identify an exit test at runtime.
-  @_spi(ForToolsIntegrationOnly)
-  public var sourceLocation: SourceLocation
+  /// A value that uniquely identifies this instance.
+  public var id: ID
 
   /// The body closure of the exit test.
   ///
@@ -110,12 +119,10 @@ public struct __ExitTest: Sendable, ~Copyable {
   /// - Warning: This initializer is used to implement the `#expect(exitsWith:)`
   ///   macro. Do not use it directly.
   public init(
-    __expectedExitCondition expectedExitCondition: ExitCondition,
-    sourceLocation: SourceLocation,
+    __identifiedBy id: ID,
     body: @escaping @Sendable () async throws -> Void = {}
   ) {
-    self.expectedExitCondition = expectedExitCondition
-    self.sourceLocation = sourceLocation
+    self.id = id
     self.body = body
   }
 }
@@ -222,28 +229,24 @@ extension ExitTest: TestContent {
   }
 
   typealias TestContentAccessorResult = Self
-  typealias TestContentAccessorHint = SourceLocation
+  typealias TestContentAccessorHint = ID
 }
 
 @_spi(Experimental) @_spi(ForToolsIntegrationOnly)
 extension ExitTest {
   /// Find the exit test function at the given source location.
   ///
   /// - Parameters:
-  ///   - sourceLocation: The source location of the exit test to find.
+  ///   - id: The unique identifier of the exit test to find.
   ///
   /// - Returns: The specified exit test function, or `nil` if no such exit test
   ///   could be found.
-  public static func find(at sourceLocation: SourceLocation) -> Self? {
+  public static func find(identifiedBy id: ExitTest.ID) -> Self? {
     var result: Self?
 
-    enumerateTestContent(withHint: sourceLocation) { _, exitTest, _, stop in
-      if exitTest.sourceLocation == sourceLocation {
-        result = ExitTest(
-          __expectedExitCondition: exitTest.expectedExitCondition,
-          sourceLocation: exitTest.sourceLocation,
-          body: exitTest.body
-        )
+    enumerateTestContent(withHint: id) { _, exitTest, _, stop in
+      if exitTest.id == id {
+        result = ExitTest(__identifiedBy: id, body: exitTest.body)
         stop = true
       }
     }
@@ -252,14 +255,8 @@ extension ExitTest {
       // Call the legacy lookup function that discovers tests embedded in types.
       result = types(withNamesContaining: exitTestContainerTypeNameMagic).lazy
         .compactMap { $0 as? any __ExitTestContainer.Type }
-        .first { $0.__sourceLocation == sourceLocation }
-        .map { type in
-          ExitTest(
-            __expectedExitCondition: type.__expectedExitCondition,
-            sourceLocation: type.__sourceLocation,
-            body: type.__body
-          )
-        }
+        .first { $0.__id == id }
+        .map { ExitTest(__identifiedBy: $0.__id, body: $0.__body) }
     }
 
     return result
@@ -272,6 +269,7 @@ extension ExitTest {
 /// a given status.
 ///
 /// - Parameters:
+///   - exitTestID: The unique identifier of the exit test.
 ///   - expectedExitCondition: The expected exit condition.
 ///   - observedValues: An array of key paths representing results from within
 ///     the exit test that should be observed and returned by this macro. The
@@ -290,6 +288,7 @@ extension ExitTest {
 /// `await #expect(exitsWith:) { }` invocations regardless of calling
 /// convention.
 func callExitTest(
+  identifiedBy exitTestID: ExitTest.ID,
   exitsWith expectedExitCondition: ExitCondition,
   observing observedValues: [any PartialKeyPath<ExitTestArtifacts> & Sendable],
   expression: __Expression,
@@ -304,7 +303,7 @@ func callExitTest(
 
   var result: ExitTestArtifacts
   do {
-    var exitTest = ExitTest(__expectedExitCondition: expectedExitCondition, sourceLocation: sourceLocation)
+    var exitTest = ExitTest(__identifiedBy: exitTestID)
     exitTest.observedValues = observedValues
     result = try await configuration.exitTestHandler(exitTest)
 
@@ -424,23 +423,21 @@ extension ExitTest {
   /// `__swiftPMEntryPoint()` function. The effect of using it under other
   /// configurations is undefined.
   static func findInEnvironmentForEntryPoint() -> Self? {
-    // Find the source location of the exit test to run, if any, in the
-    // environment block.
-    var sourceLocation: SourceLocation?
-    if var sourceLocationString = Environment.variable(named: "SWT_EXPERIMENTAL_EXIT_TEST_SOURCE_LOCATION") {
-       sourceLocation = try? sourceLocationString.withUTF8 { sourceLocationBuffer in
-        let sourceLocationBuffer = UnsafeRawBufferPointer(sourceLocationBuffer)
-        return try JSON.decode(SourceLocation.self, from: sourceLocationBuffer)
+    // Find the ID of the exit test to run, if any, in the environment block.
+    var id: __ExitTest.ID?
+    if var idString = Environment.variable(named: "SWT_EXPERIMENTAL_EXIT_TEST_ID") {
+      id = try? idString.withUTF8 { idBuffer in
+        try JSON.decode(__ExitTest.ID.self, from: UnsafeRawBufferPointer(idBuffer))
       }
     }
-    guard let sourceLocation else {
+    guard let id else {
       return nil
     }
 
     // If an exit test was found, inject back channel handling into its body.
     // External tools authors should set up their own back channel mechanisms
     // and ensure they're installed before calling ExitTest.callAsFunction().
-    guard var result = find(at: sourceLocation) else {
+    guard var result = find(identifiedBy: id) else {
       return nil
     }
 
@@ -560,8 +557,8 @@ extension ExitTest {
 
       // Insert a specific variable that tells the child process which exit test
       // to run.
-      try JSON.withEncoding(of: exitTest.sourceLocation) { json in
-        childEnvironment["SWT_EXPERIMENTAL_EXIT_TEST_SOURCE_LOCATION"] = String(decoding: json, as: UTF8.self)
+      try JSON.withEncoding(of: exitTest.id) { json in
+        childEnvironment["SWT_EXPERIMENTAL_EXIT_TEST_ID"] = String(decoding: json, as: UTF8.self)
       }
 
       typealias ResultUpdater = @Sendable (inout ExitTestArtifacts) -> Void

Sources/Testing/Expectations/Expectation+Macro.swift

@@ -546,7 +546,7 @@ public macro require<R>(
   observing observedValues: [any PartialKeyPath<ExitTestArtifacts> & Sendable] = [],
   _ comment: @autoclosure () -> Comment? = nil,
   sourceLocation: SourceLocation = #_sourceLocation,
-  performing expression: @convention(thin) () async throws -> Void
+  performing expression: @escaping @Sendable @convention(thin) () async throws -> Void
 ) -> ExitTestArtifacts? = #externalMacro(module: "TestingMacros", type: "ExitTestExpectMacro")
 
 /// Check that an expression causes the process to terminate in a given fashion
@@ -658,5 +658,5 @@ public macro require<R>(
   observing observedValues: [any PartialKeyPath<ExitTestArtifacts> & Sendable] = [],
   _ comment: @autoclosure () -> Comment? = nil,
   sourceLocation: SourceLocation = #_sourceLocation,
-  performing expression: @convention(thin) () async throws -> Void
+  performing expression: @escaping @Sendable @convention(thin) () async throws -> Void
 ) -> ExitTestArtifacts = #externalMacro(module: "TestingMacros", type: "ExitTestRequireMacro")

Sources/Testing/Expectations/ExpectationChecking+Macro.swift

@@ -1147,6 +1147,7 @@ public func __checkClosureCall<R>(
 ///   `#require()` macros. Do not call it directly.
 @_spi(Experimental)
 public func __checkClosureCall(
+  identifiedBy exitTestID: __ExitTest.ID,
   exitsWith expectedExitCondition: ExitCondition,
   observing observedValues: [any PartialKeyPath<ExitTestArtifacts> & Sendable],
   performing body: @convention(thin) () -> Void,
@@ -1157,6 +1158,7 @@ public func __checkClosureCall(
   sourceLocation: SourceLocation
 ) async -> Result<ExitTestArtifacts?, any Error> {
   await callExitTest(
+    identifiedBy: exitTestID,
     exitsWith: expectedExitCondition,
     observing: observedValues,
     expression: expression,

Sources/Testing/Test+Discovery+Legacy.swift

@@ -32,11 +32,8 @@ let testContainerTypeNameMagic = "__🟠$test_container__"
 @_alwaysEmitConformanceMetadata
 @_spi(Experimental)
 public protocol __ExitTestContainer {
-  /// The expected exit condition of the exit test.
-  static var __expectedExitCondition: ExitCondition { get }
-
-  /// The source location of the exit test.
-  static var __sourceLocation: SourceLocation { get }
+  /// The unique identifier of the exit test.
+  static var __id: __ExitTest.ID { get }
 
   /// The body function of the exit test.
   static var __body: @Sendable () async throws -> Void { get }

Sources/TestingMacros/ConditionMacro.swift

@@ -416,6 +416,10 @@ extension ExitTestConditionMacro {
 
     let bodyArgumentExpr = arguments[trailingClosureIndex].expression
 
+    // TODO: use UUID() here if we can link to Foundation
+    let exitTestID = (UInt64.random(in: 0 ... .max), UInt64.random(in: 0 ... .max))
+    let exitTestIDExpr: ExprSyntax = "Testing.__ExitTest.ID(__uuid: (\(literal: exitTestID.0), \(literal: exitTestID.1)))"
+
     var decls = [DeclSyntax]()
 
     // Implement the body of the exit test outside the enum we're declaring so
@@ -436,15 +440,12 @@ extension ExitTestConditionMacro {
       """
       @available(*, deprecated, message: "This type is an implementation detail of the testing library. Do not use it directly.")
       enum \(enumName): Testing.__ExitTestContainer, Sendable {
-        static var __sourceLocation: Testing.SourceLocation {
-          \(createSourceLocationExpr(of: macro, context: context))
+        static var __id: Testing.__ExitTest.ID {
+          \(exitTestIDExpr)
         }
         static var __body: @Sendable () async throws -> Void {
           \(bodyThunkName)
         }
-        static var __expectedExitCondition: Testing.ExitCondition {
-          \(arguments[expectedExitConditionIndex].expression.trimmed)
-        }
       }
       """
     )
@@ -458,6 +459,16 @@ extension ExitTestConditionMacro {
       }
     )
 
+    // Insert the exit test's ID as the first argument. Note that this will
+    // invalidate all indices into `arguments`!
+    arguments.insert(
+      Argument(
+        label: "identifiedBy",
+        expression: exitTestIDExpr
+      ),
+      at: arguments.startIndex
+    )
+
     // Replace the exit test body (as an argument to the macro) with a stub
     // closure that hosts the type we created above.
     var macro = macro

Tests/TestingTests/ExitTestTests.swift

@@ -405,6 +405,17 @@ private import _TestingInternals
     #expect(result.standardOutputContent.isEmpty)
     #expect(result.standardErrorContent.contains("STANDARD ERROR".utf8.reversed()))
   }
+
+  @Test("Arguments to the macro are not captured during expansion (do not need to be literals/const)")
+  func argumentsAreNotCapturedDuringMacroExpansion() async throws {
+    let unrelatedSourceLocation = #_sourceLocation
+    func nonConstExitCondition() async throws -> ExitCondition {
+      .failure
+    }
+    await #expect(exitsWith: try await nonConstExitCondition(), sourceLocation: unrelatedSourceLocation) {
+      fatalError()
+    }
+  }
 }
 
 // MARK: - Fixtures