Replace CRC-32 with SHA-256 in our macro target (#1047)

This PR replaces CRC-32 with SHA-256 in our macro target.

We currently use CRC-32 to disambiguate test functions that would
otherwise generate identical derived symbol names (using
`context.makeUniqueName()`.) By replacing it with the first 64 bits of a
SHA-256 hash, we reduce the odds of a collision.

We also currently use a 128-bit random number as a unique ID for exit
tests during macro expansion (which is as unique as it gets, but
unstable.) Replacing this random number with half of a SHA-256 hash
allows us to generate _stable_ IDs (that are still statistically unique)
which can help when debugging an exit test and may also improve cache
quality for tools (e.g. an IDE's symbol cache.)

Because there is no SHA-256 implementation available in the Swift
standard library or other components we can reliably link to in the
macro target, I've borrowed the implementation of SHA-256 in
swift-tools-support-core. The original version is
[here](https://github.com/swiftlang/swift-tools-support-core/blob/main/Sources/TSCBasic/HashAlgorithms.swift).

### 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

Sources/Testing/ExitTests/ExitTest.swift

@@ -35,10 +35,20 @@ private import _TestingInternals
 #endif
 public struct ExitTest: Sendable, ~Copyable {
   /// A type whose instances uniquely identify instances of ``ExitTest``.
+  ///
+  /// An instance of this type uniquely identifies an exit test within the
+  /// context of the current test target. You can get an exit test's unique
+  /// identifier from its ``id`` property.
+  ///
+  /// The encoded form of an instance of this type is subject to change over
+  /// time. Instances of this type are only guaranteed to be decodable by the
+  /// same version of the testing library that encoded them.
   @_spi(ForToolsIntegrationOnly)
   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.)
+    /// Storage for the underlying bits of the ID.
+    ///
+    /// - Note: On Apple platforms, we deploy to OS versions that do not include
+    ///   support for `UInt128`, so we use two `UInt64`s for storage instead.
     private var _lo: UInt64
     private var _hi: UInt64
 

Sources/TestingMacros/CMakeLists.txt

@@ -99,9 +99,9 @@ target_sources(TestingMacros PRIVATE
   Support/AvailabilityGuards.swift
   Support/CommentParsing.swift
   Support/ConditionArgumentParsing.swift
-  Support/CRC32.swift
   Support/DiagnosticMessage.swift
   Support/DiagnosticMessage+Diagnosing.swift
+  Support/SHA256.swift
   Support/SourceCodeCapturing.swift
   Support/SourceLocationGeneration.swift
   Support/TestContentGeneration.swift

Sources/TestingMacros/ConditionMacro.swift

@@ -8,6 +8,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for Swift project authors
 //
 
+import SwiftParser
 public import SwiftSyntax
 import SwiftSyntaxBuilder
 public import SwiftSyntaxMacros
@@ -446,9 +447,8 @@ extension ExitTestConditionMacro {
       context.diagnose(.captureClauseUnsupported(captureClause, in: closureExpr, inExitTest: macro))
     }
 
-    // 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 = "(\(literal: exitTestID.0), \(literal: exitTestID.1))"
+    // Generate a unique identifier for this exit test.
+    let idExpr = _makeExitTestIDExpr(for: macro, in: context)
 
     var decls = [DeclSyntax]()
 
@@ -494,7 +494,7 @@ extension ExitTestConditionMacro {
         enum \(enumName) {
           private nonisolated static let accessor: Testing.__TestContentRecordAccessor = { outValue, type, hint, _ in
             Testing.ExitTest.__store(
-              \(exitTestIDExpr),
+              \(idExpr),
               \(bodyThunkName),
               into: outValue,
               asTypeAt: type,
@@ -525,10 +525,7 @@ 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
-      ),
+      Argument(label: "identifiedBy", expression: idExpr),
       at: arguments.startIndex
     )
 
@@ -541,6 +538,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,10 +63,12 @@ extension MacroExpansionContext {
       .tokens(viewMode: .fixedUp)
       .map(\.textWithoutBackticks)
       .joined()
-    let crcValue = crc32(identifierCharacters.utf8)
-    let suffix = String(crcValue, radix: 16, uppercase: false)
+    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 CRC32 value starts with a
+    // If the caller did not specify a prefix and the hash value starts with a
     // digit, include a single-character prefix to ensure that Swift's name
     // demangling still works correctly.
     var prefix = prefix

Sources/TestingMacros/Support/CRC32.swift

@@ -0,0 +1,184 @@
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014–2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+//
+
+/// The contents of this file were copied more-or-less verbatim from
+/// [swift-tools-support-core](https://github.com/swiftlang/swift-tools-support-core/blob/add9e1518ac37a8e52b7612d3eb2f009ae8f6ce8/Sources/TSCBasic/HashAlgorithms.swift).
+
+/// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of
+/// cryptographic hash functions (FIPS PUB 180-2).
+enum SHA256 {
+  /// The length of the output digest (in bits).
+  private static let _digestLength = 256
+
+  /// The size of each blocks (in bits).
+  private static let _blockBitSize = 512
+
+  /// The initial hash value.
+  private static let _initialHashValue: [UInt32] = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+  ]
+
+  /// The constants in the algorithm (K).
+  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,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  ]
+
+  public static func hash(_ bytes: some Sequence<UInt8>) -> [UInt8] {
+    var input = Array(bytes)
+
+    // Pad the input.
+    _pad(&input)
+
+    // Break the input into N 512-bit blocks.
+    let messageBlocks = input.blocks(size: _blockBitSize / 8)
+
+    /// The hash that is being computed.
+    var hash = _initialHashValue
+
+    // Process each block.
+    for block in messageBlocks {
+      _process(block, hash: &hash)
+    }
+
+    // Finally, compute the result.
+    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)
+      result[pos + 1] = UInt8((element >> 16) & 0xff)
+      result[pos + 2] = UInt8((element >> 8) & 0xff)
+      result[pos + 3] = UInt8(element & 0xff)
+    }
+
+    return result
+  }
+
+  /// Process and compute hash from a block.
+  private static func _process(_ block: ArraySlice<UInt8>, hash: inout [UInt32]) {
+
+    // Compute message schedule.
+    var W = [UInt32](repeating: 0, count: _konstants.count)
+    for t in 0..<W.count {
+      switch t {
+      case 0...15:
+        let index = block.startIndex.advanced(by: t * 4)
+        // Put 4 bytes in each message.
+        W[t]  = UInt32(block[index + 0]) << 24
+        W[t] |= UInt32(block[index + 1]) << 16
+        W[t] |= UInt32(block[index + 2]) << 8
+        W[t] |= UInt32(block[index + 3])
+      default:
+        let σ1 = W[t-2].rotateRight(by: 17) ^ W[t-2].rotateRight(by: 19) ^ (W[t-2] >> 10)
+        let σ0 = W[t-15].rotateRight(by: 7) ^ W[t-15].rotateRight(by: 18) ^ (W[t-15] >> 3)
+        W[t] = σ1 &+ W[t-7] &+ σ0 &+ W[t-16]
+      }
+    }
+
+    var a = hash[0]
+    var b = hash[1]
+    var c = hash[2]
+    var d = hash[3]
+    var e = hash[4]
+    var f = hash[5]
+    var g = hash[6]
+    var h = hash[7]
+
+    // Run the main algorithm.
+    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 &+ _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)
+      let t2 = Σ0 &+ maj
+
+      h = g
+      g = f
+      f = e
+      e = d &+ t1
+      d = c
+      c = b
+      b = a
+      a = t1 &+ t2
+    }
+
+    hash[0] = a &+ hash[0]
+    hash[1] = b &+ hash[1]
+    hash[2] = c &+ hash[2]
+    hash[3] = d &+ hash[3]
+    hash[4] = e &+ hash[4]
+    hash[5] = f &+ hash[5]
+    hash[6] = g &+ hash[6]
+    hash[7] = h &+ hash[7]
+  }
+
+  /// Pad the given byte array to be a multiple of 512 bits.
+  private static func _pad(_ input: inout [UInt8]) {
+    // Find the bit count of input.
+    let inputBitLength = input.count * 8
+
+    // Append the bit 1 at end of input.
+    input.append(0x80)
+
+    // Find the number of bits we need to append.
+    //
+    // inputBitLength + 1 + bitsToAppend ≡ 448 mod 512
+    let mod = inputBitLength % 512
+    let bitsToAppend = mod < 448 ? 448 - 1 - mod : 512 + 448 - mod - 1
+
+    // We already appended first 7 bits with 0x80 above.
+    input += [UInt8](repeating: 0, count: (bitsToAppend - 7) / 8)
+
+    // We need to append 64 bits of input length.
+    for byte in UInt64(inputBitLength).toByteArray().lazy.reversed() {
+      input.append(byte)
+    }
+    assert((input.count * 8) % 512 == 0, "Expected padded length to be 512.")
+  }
+}
+
+// MARK:- Helpers
+
+extension UInt64 {
+  /// Converts the 64 bit integer into an array of single byte integers.
+  fileprivate func toByteArray() -> [UInt8] {
+    var value = self.littleEndian
+    return withUnsafeBytes(of: &value, Array.init)
+  }
+}
+
+extension UInt32 {
+  /// Rotates self by given amount.
+  fileprivate func rotateRight(by amount: UInt32) -> UInt32 {
+    return (self >> amount) | (self << (32 - amount))
+  }
+}
+
+extension Array {
+  /// Breaks the array into the given size.
+  fileprivate func blocks(size: Int) -> AnyIterator<ArraySlice<Element>> {
+    var currentIndex = startIndex
+    return AnyIterator {
+      if let nextIndex = self.index(currentIndex, offsetBy: size, limitedBy: self.endIndex) {
+        defer { currentIndex = nextIndex }
+        return self[currentIndex..<nextIndex]
+      }
+      return nil
+    }
+  }
+}