[CMake] Eliminate the use of Darwin/Glibc in the CMake build.

Reduce platform dependencies by going single-threaded-only when building
within the compiler (which is hopelessly single-threaded anyway). This
helps eliminate cyclic build dependencies.

Author: DougGregor

CMakeLists.txt

@@ -23,10 +23,16 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
 set(CMAKE_MACOSX_RPATH YES)
 
+# Ensure that we do not link the _StringProcessing module.
 add_compile_options(
   $<$<COMPILE_LANGUAGE:Swift>:-Xfrontend>
   $<$<COMPILE_LANGUAGE:Swift>:-disable-implicit-string-processing-module-import>)
 
+# Force single-threaded builds to eliminate the Darwin dependency.
+add_compile_definitions(
+  $<$<COMPILE_LANGUAGE:Swift>:SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED>
+)
+
 add_subdirectory(Sources)
 
 export(EXPORT SwiftSyntaxTargets

Sources/SwiftSyntax/CMakeLists.txt

@@ -11,7 +11,9 @@ add_library(SwiftSyntax STATIC
   BumpPtrAllocator.swift
   CommonAncestor.swift
   IncrementalParseTransition.swift
-  PlatformMutex.swift
+  # PlatformMutex.swift is intentionally excluded because it brings in
+  # platform dependencies we don't want within the CMake build, which is
+  # trying to minimize such dependencies.
   SourceLength.swift
   SourceLocation.swift
   SourcePresence.swift

Sources/SwiftSyntax/SyntaxArena.swift

@@ -28,43 +28,55 @@ public class SyntaxArena {
   private var hasParent: Bool
   private var parseTriviaFunction: ParseTriviaFunction
 
+  #if !SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
   /// Thread safe guard.
   private let lock: PlatformMutex
   private var singleThreadMode: Bool
+  #endif
 
   @_spi(RawSyntax)
   public init(parseTriviaFunction: @escaping ParseTriviaFunction) {
     self.allocator = BumpPtrAllocator()
+#if !SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
     self.lock = PlatformMutex(allocator: self.allocator)
     self.singleThreadMode = false
+#endif
     self.children = []
     self.sourceBuffer = .init(start: nil, count: 0)
     self.hasParent = false
     self.parseTriviaFunction = parseTriviaFunction
   }
 
   deinit {
+#if !SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
     // Make sure we give the platform lock a chance to deinitialize any
     // memory it used.
     lock.deinitialize()
+#endif
   }
 
   public convenience init() {
     self.init(parseTriviaFunction: _defaultParseTriviaFunction(_:_:))
   }
 
   private func withGuard<R>(_ body: () throws -> R) rethrows -> R {
+#if SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
+    return try body()
+#else
     if self.singleThreadMode {
       return try body()
     } else {
       return try self.lock.withGuard(body: body)
     }
+#endif
   }
 
   public func assumingSingleThread<R>(body: () throws -> R) rethrows -> R {
+#if !SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
     let oldValue = self.singleThreadMode
     defer { self.singleThreadMode = oldValue }
     self.singleThreadMode = true
+#endif
     return try body()
   }
 

Sources/SwiftSyntax/SyntaxText.swift

@@ -10,11 +10,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if !SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
 #if canImport(Darwin)
 @_implementationOnly import Darwin
 #elseif canImport(Glibc)
 @_implementationOnly import Glibc
 #endif
+#endif
 
 /// Represent a string.
 ///
@@ -222,7 +224,10 @@ private func compareMemory(
   _ s1: UnsafePointer<UInt8>, _ s2: UnsafePointer<UInt8>, _ count: Int
 ) -> Bool {
   assert(count >= 0)
-#if canImport(Darwin)
+#if SWIFT_SYNTAX_ALWAYS_SINGLE_THREADED
+  return UnsafeBufferPointer(start: s1, count: count)
+    .elementsEqual(UnsafeBufferPointer(start: s2, count: count))
+#elseif canImport(Darwin)
   return Darwin.memcmp(s1, s2, count) == 0
 #elseif canImport(Glibc)
   return Glibc.memcmp(s1, s2, count) == 0

Tests/SwiftParserTest/LinkageTests.swift

@@ -32,7 +32,7 @@ final class LinkageTest: XCTestCase {
       .library("-lswiftCompatibility56", condition: .mayBeAbsent("Starting in Xcode 14 this library is not always autolinked")),
       .library("-lswiftCompatibilityConcurrency"),
       .library("-lswiftCore"),
-      .library("-lswiftDarwin"),
+      .library("-lswiftDarwin", condition: .mayBeAbsent("Not present when building inside the compiler"),
       .library("-lswiftSwiftOnoneSupport", condition: .when(configuration: .debug)),
       .library("-lswift_Concurrency"),
       .library("-lswift_StringProcessing", condition: .mayBeAbsent("Starting in Xcode 14 this library is not always autolinked")),