Suppress compiler warnings about Errors with non-Sendable members.

A type conforming to `Error` must be `Sendable`, but `DelimiterLexError` and
`CompilerLexError` carry source locations represented by `UnsafeRawPointer`,
which is inherently non-`Sendable`. The compiler diagnoses the failure to meet
`Sendable` requirements on these error types, which will prevent Swift 6 adoption
in `_RegexParser` and also generates build log spam every time the compiler and
standard library are built. There are a couple ways to resolve this problem:

1. Refactor so that the errors to not need to carry source locations.
2. Refactor to avoid using `Error` (the code using these errors would not
   require `Sendable` if it were not for `Error`'s inherent `Sendable`
   requirement).
3. Suppress the warnings with a `@uncheck Sendable` wrapper.

Option 1 probably requires significant refactoring and option 2 seems
undesirable since it means that the implementation must forgo the convenience
of Swift's error handling model. Therefore this PR implements option 3 as the
most expedient way to stop the diagnostic spam, leaving improvement on the
status quo as a future exercise.

Author: tshortli

Sources/_RegexParser/Regex/Parse/CompilerInterface.swift

@@ -17,9 +17,19 @@ public let currentRegexLiteralFormatVersion = 1
 
 @_spi(CompilerInterface)
 public struct CompilerLexError: Error {
+  var underlyingLocation: UnsafeSourceLocation
+
   public var message: String
-  public var location: UnsafeRawPointer
+  public var location: UnsafeRawPointer { return underlyingLocation.ptr }
   public var completelyErroneous: Bool
+
+  init(
+    message: String, location: UnsafeRawPointer, completelyErroneous: Bool
+  ) {
+    self.message = message
+    self.underlyingLocation = UnsafeSourceLocation(location)
+    self.completelyErroneous = completelyErroneous
+  }
 }
 
 /// Interface for the Swift compiler.

Sources/_RegexParser/Regex/Parse/DelimiterLexing.swift

@@ -70,6 +70,20 @@ extension Delimiter {
   }
 }
 
+/// A wrapper for an `UnsafeRawPointer` representing a source location, marked
+/// `@unchecked Sendable` to help errors carrying such information satisfy their
+/// `Sendable` requirement.
+///
+/// TODO: consider further refactoring to avoid needing to lie to the compiler
+/// about Sendability.
+struct UnsafeSourceLocation: @unchecked Sendable {
+  let ptr: UnsafeRawPointer
+
+  init(_ ptr: UnsafeRawPointer) {
+    self.ptr = ptr
+  }
+}
+
 public struct DelimiterLexError: Error, CustomStringConvertible {
   public enum Kind: Hashable {
     case unterminated
@@ -81,12 +95,14 @@ public struct DelimiterLexError: Error, CustomStringConvertible {
 
   public var kind: Kind
 
+  var resumeLocation: UnsafeSourceLocation
+
   /// The pointer at which to resume lexing.
-  public var resumePtr: UnsafeRawPointer
+  public var resumePtr: UnsafeRawPointer { resumeLocation.ptr }
 
   init(_ kind: Kind, resumeAt resumePtr: UnsafeRawPointer) {
     self.kind = kind
-    self.resumePtr = resumePtr
+    self.resumeLocation = UnsafeSourceLocation(resumePtr)
   }
 
   public var description: String {