Fixup Usage of pthread Mutexes on macOS

Did you know that pthread_mutex_init can _fail_?

On macOS, the value of PTHREAD_MUTEX_INITIALIZER is not just zeroes -
there's optional signature bits in there. POSIX says that you're allowed
to check for those signature bits in the API and issue EINVAL if they
don't match. By default, pthread_mutex_t() in swift will zero-fill
through those signature bits, which results in an invalid mutex
variable - even WRT pthread_mutex_init. Once that fails, all
subsequent calls to lock and unlock will fail too and leave all of
your critical sections completely unguarded.

Thank you POSIX

On Linuxes this is (often) not the case, and they tend to just use zeroes
here, don't check the signature, or both. This allows compilers to allocate
lock variables in .bss, which is kinda neat.

So, on macOS, we need to install those signature bits, BUT Swift cannot
import PTHREAD_MUTEX_INITIALIZER since it's a non-trivial macro that uses
brace initialization. Really what we care about is just the signature bits,
so we'll install those by hand.

Author: CodaFi

Sources/SwiftParser/Parser.swift

@@ -122,7 +122,8 @@ extension Parser {
 /// tokens as needed to disambiguate a parse. However, because lookahead
 /// operates on a copy of the lexical stream, no input tokens are lost..
 public struct Parser: TokenConsumer {
-  let arena: SyntaxArena
+  @_spi(RawSyntax)
+  public var arena: SyntaxArena
   /// A view of the sequence of lexemes in the input.
   var lexemes: Lexer.LexemeSequence
   /// The current token. If there was no input, this token will have a kind of `.eof`.

Sources/SwiftSyntax/PlatformMutex.swift

@@ -19,7 +19,7 @@
 #endif
 
 /// A protocol that platform-specific mutual exclusion primitives should conform to.
-struct PlatformMutex {
+final class PlatformMutex {
   // FIXME: Use os_unfair_lock when we bump to macOS 12.0 on Darwin
 #if canImport(Darwin) || canImport(Glibc)
   typealias Primitive = pthread_mutex_t
@@ -36,12 +36,8 @@ struct PlatformMutex {
   init(allocator: BumpPtrAllocator) {
     let storage = allocator.allocate(Primitive.self, count: 1).baseAddress!
     storage.initialize(to: Primitive())
-#if canImport(Darwin) || canImport(Glibc)
-    pthread_mutex_init(storage, nil)
-#elseif canImport(WinSDK)
-    InitializeSRWLock(storage)
-#endif
     self.lock = storage
+    Self.initialize(self.lock)
   }
 
   /// Deinitialize the memory associated with the mutex.
@@ -64,17 +60,39 @@ struct PlatformMutex {
 }
 
 extension PlatformMutex {
+  private static func initialize(_ platformLock: PlatformLock) {
+#if canImport(Darwin)
+    // HACK: On Darwin, the value of PTHREAD_MUTEX_INITIALIZER installs
+    // signature bits into the mutex that are later checked by other aspects
+    // of the mutex API. This is a completely optional POSIX-ism that most
+    // Linuxes don't implement - often so that (global) lock variables can be
+    // stuck in .bss. Swift doesn't know how to import
+    // PTHREAD_MUTEX_INITIALIZER, so we'll replicate its signature-installing
+    // magic with the bit it can import.
+    platformLock.pointee.__sig = Int(_PTHREAD_MUTEX_SIG_init)
+    let result = pthread_mutex_init(platformLock, nil)
+    precondition(result == 0)
+#elseif canImport(Glibc)
+    let result = pthread_mutex_init(platformLock, nil)
+    precondition(result == 0)
+#elseif canImport(WinSDK)
+    InitializeSRWLock(platformLock)
+#endif
+  }
+
   private static func lock(_ platformLock: PlatformLock) {
 #if canImport(Darwin) || canImport(Glibc)
-    pthread_mutex_lock(platformLock)
+    let result = pthread_mutex_lock(platformLock)
+    assert(result == 0)
 #elseif canImport(WinSDK)
     AcquireSRWLockExclusive(platformLock)
 #endif
   }
 
   private static func unlock(_ platformLock: PlatformLock) {
 #if canImport(Darwin) || canImport(Glibc)
-    pthread_mutex_unlock(platformLock)
+    let result = pthread_mutex_unlock(platformLock)
+    assert(result == 0)
 #elseif canImport(WinSDK)
     ReleaseSRWLockExclusive(platformLock)
 #endif

Sources/SwiftSyntax/SyntaxArena.swift

@@ -15,10 +15,6 @@ public class SyntaxArena {
   @_spi(RawSyntax)
   public typealias ParseTriviaFunction = (_ source: SyntaxText, _ position: TriviaPosition) -> [RawTriviaPiece]
 
-  /// Thread safe guard.
-  private let lock: PlatformMutex
-  private var singleThreadMode: Bool
-
   /// Bump-pointer allocator for all "intern" methods.
   private let allocator: BumpPtrAllocator
   /// Source file buffer the Syntax tree represents.
@@ -32,15 +28,18 @@ public class SyntaxArena {
   private var hasParent: Bool
   private var parseTriviaFunction: ParseTriviaFunction
 
+  /// Thread safe guard.
+  private let lock: PlatformMutex
+  private var singleThreadMode: Bool
+
   @_spi(RawSyntax)
   public init(parseTriviaFunction: @escaping ParseTriviaFunction) {
-    let allocator = BumpPtrAllocator()
-    self.lock = PlatformMutex(allocator: allocator)
+    self.allocator = BumpPtrAllocator()
+    self.lock = PlatformMutex(allocator: self.allocator)
     self.singleThreadMode = false
-    self.allocator = allocator
-    children = []
-    sourceBuffer = .init(start: nil, count: 0)
-    hasParent = false
+    self.children = []
+    self.sourceBuffer = .init(start: nil, count: 0)
+    self.hasParent = false
     self.parseTriviaFunction = parseTriviaFunction
   }
 

Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift

@@ -1,6 +1,5 @@
-@_spi(RawSyntax)
-import SwiftSyntax
-import SwiftParser
+@_spi(RawSyntax) import SwiftSyntax
+@_spi(RawSyntax) import SwiftParser
 
 /// An individual interpolated syntax node.
 struct InterpolatedSyntaxNode {