Factor out exit test ID construction to a separate function, just use a full 128 bits of hash

Author: grynspan

Sources/Testing/ExitTests/ExitTest.swift

@@ -45,11 +45,10 @@ public struct ExitTest: Sendable, ~Copyable {
   /// same version of the testing library that encoded them.
   @_spi(ForToolsIntegrationOnly)
   public struct ID: Sendable, Equatable, Codable {
-    /// The underlying UUID (stored as two `UInt64` values to avoid relying on
-    /// `UUID` from Foundation or any platform-specific interfaces.)
+    /// Storage for the underlying bits of the ID.
     ///
     /// - Note: On Apple platforms, we deploy to OS versions that do not include
-    ///   support for `UInt128`.
+    ///   support for `UInt128`, so we use two `UInt64`s for storage instead.
     private var _lo: UInt64
     private var _hi: UInt64
 

Sources/TestingMacros/ConditionMacro.swift

@@ -447,17 +447,7 @@ extension ExitTestConditionMacro {
       context.diagnose(.captureClauseUnsupported(captureClause, in: closureExpr, inExitTest: macro))
     }
 
-    let exitTestID: (UInt64, UInt64)
-    if let sourceLocation = context.location(of: macro, at: .afterLeadingTrivia, filePathMode: .fileID),
-       var fileID = sourceLocation.file.as(StringLiteralExprSyntax.self)?.representedLiteralValue,
-       let line = sourceLocation.line.as(IntegerLiteralExprSyntax.self)?.representedLiteralValue,
-       let column = sourceLocation.column.as(IntegerLiteralExprSyntax.self)?.representedLiteralValue {
-      exitTestID.0 = fileID.withUTF8(make64BitHash)
-      exitTestID.1 = (UInt64(line) << 32) | UInt64(column)
-    } else {
-      fatalError("Could not determine the source location of this exit test. Please file a bug report at https://github.com/swiftlang/swift-testing/issues/new")
-    }
-    let exitTestIDExpr: ExprSyntax = "(\(IntegerLiteralExprSyntax(exitTestID.0, radix: .hex)), \(IntegerLiteralExprSyntax(exitTestID.1, radix: .hex)))"
+    let exitTestIDExpr = _makeExitTestIDExpr(for: macro, in: context)
 
     var decls = [DeclSyntax]()
 
@@ -550,6 +540,44 @@ extension ExitTestConditionMacro {
 
     return try Base.expansion(of: macro, primaryExpression: bodyArgumentExpr, in: context)
   }
+
+  /// Make an expression representing an exit test ID that can be passed to the
+  /// `ExitTest.__store()` function at runtime.
+  ///
+  /// - Parameters:
+  ///   - macro: The exit test macro being inspected.
+  ///   - context: The macro context in which the expression is being parsed.
+  ///
+  /// - Returns: An expression representing the exit test's unique ID.
+  private static func _makeExitTestIDExpr(
+    for macro: some FreestandingMacroExpansionSyntax,
+    in context: some MacroExpansionContext
+  ) -> ExprSyntax {
+    let exitTestID: (UInt64, UInt64)
+    if let sourceLocation = context.location(of: macro, at: .afterLeadingTrivia, filePathMode: .fileID),
+       let fileID = sourceLocation.file.as(StringLiteralExprSyntax.self)?.representedLiteralValue,
+       let line = sourceLocation.line.as(IntegerLiteralExprSyntax.self)?.representedLiteralValue,
+       let column = sourceLocation.column.as(IntegerLiteralExprSyntax.self)?.representedLiteralValue {
+      // Hash the entire source location and store as many bits as possible in
+      // the resulting ID.
+      let stringValue = "\(fileID):\(line):\(column)"
+      exitTestID = SHA256.hash(stringValue.utf8).withUnsafeBytes { sha256 in
+        sha256.loadUnaligned(as: (UInt64, UInt64).self)
+      }
+    } else {
+      // This branch is dead code in production, but is used when we expand a
+      // macro in our own unit tests because the macro expansion context does
+      // not have real source location information.
+      exitTestID.0 = .random(in: 0 ... .max)
+      exitTestID.1 = .random(in: 0 ... .max)
+    }
+
+    // Return a tuple of integer literals (which is what the runtime __store()
+    // function is expecting.)
+    return """
+    (\(IntegerLiteralExprSyntax(exitTestID.0, radix: .hex)), \(IntegerLiteralExprSyntax(exitTestID.1, radix: .hex)))
+    """
+  }
 }
 
 /// A type describing the expansion of the `#expect(exitsWith:)` macro.

Sources/TestingMacros/Support/Additions/MacroExpansionContextAdditions.swift

@@ -63,7 +63,9 @@ extension MacroExpansionContext {
       .tokens(viewMode: .fixedUp)
       .map(\.textWithoutBackticks)
       .joined()
-    let hashValue = make64BitHash(identifierCharacters.utf8)
+    let hashValue = SHA256.hash(identifierCharacters.utf8).withUnsafeBytes { sha256 in
+      sha256.loadUnaligned(as: UInt64.self)
+    }
     let suffix = String(hashValue, radix: 16, uppercase: false)
 
     // If the caller did not specify a prefix and the hash value starts with a

Sources/TestingMacros/Support/SHA256.swift

@@ -13,20 +13,20 @@
 
 /// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of
 /// cryptographic hash functions (FIPS PUB 180-2).
-struct SHA256 {
+enum SHA256 {
   /// The length of the output digest (in bits).
-  private static let digestLength = 256
+  private static let _digestLength = 256
 
   /// The size of each blocks (in bits).
-  private static let blockBitSize = 512
+  private static let _blockBitSize = 512
 
   /// The initial hash value.
-  private static let initalHashValue: [UInt32] = [
+  private static let _initialHashValue: [UInt32] = [
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
   ]
 
   /// The constants in the algorithm (K).
-  private static let konstants: [UInt32] = [
+  private static let _konstants: [UInt32] = [
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -37,28 +37,25 @@ struct SHA256 {
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
   ]
 
-  public init() {
-  }
-
-  public func hash(_ bytes: [UInt8]) -> [UInt8] {
-    var input = bytes
+  public static func hash(_ bytes: some Sequence<UInt8>) -> [UInt8] {
+    var input = Array(bytes)
 
     // Pad the input.
-    pad(&input)
+    _pad(&input)
 
     // Break the input into N 512-bit blocks.
-    let messageBlocks = input.blocks(size: Self.blockBitSize / 8)
+    let messageBlocks = input.blocks(size: _blockBitSize / 8)
 
     /// The hash that is being computed.
-    var hash = Self.initalHashValue
+    var hash = _initialHashValue
 
     // Process each block.
     for block in messageBlocks {
-      process(block, hash: &hash)
+      _process(block, hash: &hash)
     }
 
     // Finally, compute the result.
-    var result = [UInt8](repeating: 0, count: Self.digestLength / 8)
+    var result = [UInt8](repeating: 0, count: _digestLength / 8)
     for (idx, element) in hash.enumerated() {
       let pos = idx * 4
       result[pos + 0] = UInt8((element >> 24) & 0xff)
@@ -71,10 +68,10 @@ struct SHA256 {
   }
 
   /// Process and compute hash from a block.
-  private func process(_ block: ArraySlice<UInt8>, hash: inout [UInt32]) {
+  private static func _process(_ block: ArraySlice<UInt8>, hash: inout [UInt32]) {
 
     // Compute message schedule.
-    var W = [UInt32](repeating: 0, count: Self.konstants.count)
+    var W = [UInt32](repeating: 0, count: _konstants.count)
     for t in 0..<W.count {
       switch t {
       case 0...15:
@@ -101,10 +98,10 @@ struct SHA256 {
     var h = hash[7]
 
     // Run the main algorithm.
-    for t in 0..<Self.konstants.count {
+    for t in 0..<_konstants.count {
       let Σ1 = e.rotateRight(by: 6) ^ e.rotateRight(by: 11) ^ e.rotateRight(by: 25)
       let ch = (e & f) ^ (~e & g)
-      let t1 = h &+ Σ1 &+ ch &+ Self.konstants[t] &+ W[t]
+      let t1 = h &+ Σ1 &+ ch &+ _konstants[t] &+ W[t]
 
       let Σ0 = a.rotateRight(by: 2) ^ a.rotateRight(by: 13) ^ a.rotateRight(by: 22)
       let maj = (a & b) ^ (a & c) ^ (b & c)
@@ -131,7 +128,7 @@ struct SHA256 {
   }
 
   /// Pad the given byte array to be a multiple of 512 bits.
-  private func pad(_ input: inout [UInt8]) {
+  private static func _pad(_ input: inout [UInt8]) {
     // Find the bit count of input.
     let inputBitLength = input.count * 8
 
@@ -157,24 +154,24 @@ struct SHA256 {
 
 // MARK:- Helpers
 
-private extension UInt64 {
+extension UInt64 {
   /// Converts the 64 bit integer into an array of single byte integers.
-  func toByteArray() -> [UInt8] {
+  fileprivate func toByteArray() -> [UInt8] {
     var value = self.littleEndian
     return withUnsafeBytes(of: &value, Array.init)
   }
 }
 
-private extension UInt32 {
+extension UInt32 {
   /// Rotates self by given amount.
-  func rotateRight(by amount: UInt32) -> UInt32 {
+  fileprivate func rotateRight(by amount: UInt32) -> UInt32 {
     return (self >> amount) | (self << (32 - amount))
   }
 }
 
-private extension Array {
+extension Array {
   /// Breaks the array into the given size.
-  func blocks(size: Int) -> AnyIterator<ArraySlice<Element>> {
+  fileprivate func blocks(size: Int) -> AnyIterator<ArraySlice<Element>> {
     var currentIndex = startIndex
     return AnyIterator {
       if let nextIndex = self.index(currentIndex, offsetBy: size, limitedBy: self.endIndex) {
@@ -185,18 +182,3 @@ private extension Array {
     }
   }
 }
-
-// MARK: - 64-bit hash value
-
-/// Compute a 64-bit hash value of a sequence of bytes by computing its SHA-256
-/// hash and truncating the result.
-///
-/// - Parameters:
-///   - bytes: The bytes for which a hash value should be computed.
-///
-/// - Returns: The hash value computed for `bytes`.
-func make64BitHash(_ bytes: some Sequence<UInt8>) -> UInt64 {
-  SHA256().hash(Array(bytes)).withUnsafeBytes { hashBuffer in
-    hashBuffer.loadUnaligned(as: UInt64.self)
-  }
-}