Make the Regex type Sendable

Regex stores a `Program` instance, which lazily lowers the DSLTree
into a compiled program. In unprotected, this lazy compilation is
under concurrency. This change uses UnsafeAtomicLazyReference
from `swift-atomics` as storage for the lowered program, which
makes storing the compiled program an atomic operation.

Author: natecook1000

Package.swift

@@ -44,6 +44,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-atomics", from: "1.0.0"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
@@ -62,7 +63,11 @@ let package = Package(
             dependencies: []),
         .target(
             name: "_StringProcessing",
-            dependencies: ["_RegexParser", "_CUnicode"],
+            dependencies: [
+              .product(name: "Atomics", package: "swift-atomics"),
+              "_RegexParser",
+              "_CUnicode",
+            ],
             swiftSettings: publicStdlibSettings),
         .target(
             name: "RegexBuilder",

Sources/_StringProcessing/Regex/Core.swift

@@ -10,7 +10,7 @@
 //===----------------------------------------------------------------------===//
 
 @_implementationOnly import _RegexParser
-
+@_implementationOnly import Atomics
 
 /// A type that represents a regular expression.
 @available(SwiftStdlib 5.7, *)
@@ -68,20 +68,35 @@ extension Regex {
   }
 }
 
+
 @available(SwiftStdlib 5.7, *)
 extension Regex {
   /// A program representation that caches any lowered representation for
   /// execution.
-  internal class Program {
+  internal final class Program: @unchecked Sendable {
     /// The underlying IR.
     ///
     /// FIXME: If Regex is the unit of composition, then it should be a Node instead,
     /// and we should have a separate type that handled both global options and,
     /// likely, compilation/caching.
     let tree: DSLTree
 
+    private final class ProgramBox {
+      let value: MEProgram<String>
+      init(_ value: MEProgram<String>) { self.value = value }
+    }
+
+    private var _loweredProgramStorage: UnsafeAtomicLazyReference<ProgramBox>
+      = .create()
+    
     /// The program for execution with the matching engine.
-    lazy private(set) var loweredProgram = try! Compiler(tree: tree).emit()
+    var loweredProgram: MEProgram<String> {
+      if let lowered = _loweredProgramStorage.load() {
+        return lowered.value
+      }
+      let lowered = try! ProgramBox(Compiler(tree: tree).emit())
+      return _loweredProgramStorage.storeIfNilThenLoad(lowered).value
+    }
 
     init(ast: AST) {
       self.tree = ast.dslTree
@@ -90,6 +105,10 @@ extension Regex {
     init(tree: DSLTree) {
       self.tree = tree
     }
+    
+    deinit {
+      _loweredProgramStorage.destroy()
+    }
   }
 
   /// The set of matching options that applies to the start of this regex.