C++ mutex

Author: rintaro

Sources/SwiftSyntax/CMakeLists.txt

@@ -18,7 +18,6 @@ add_swift_syntax_library(SwiftSyntax
   Identifier.swift
   MemoryLayout.swift
   MissingNodeInitializers.swift
-  PlatformMutex.swift
   SourceEdit.swift
   SourceLength.swift
   SourceLocation.swift

Sources/SwiftSyntax/PlatformMutex.swift

@@ -10,6 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if compiler(>=6)
+@_implementationOnly private import _SwiftSyntaxCShims
+#else
+@_implementationOnly import _SwiftSyntaxCShims
+#endif
+
 // `Syntax` is a user facing "red" tree. A value is a pair of strong reference to
 // the _arena_ and a pointer to the `SyntaxData` allocated in the arena.
 // The _arena_ is shared between the all node in the tree and only in the tree.
@@ -358,12 +364,16 @@ final class SyntaxDataArena: @unchecked Sendable {
     precondition(rawNodeArena == raw.arenaReference)
     assert(MemoryLayout<SyntaxData>.alignment >= MemoryLayout<UnsafePointer<SyntaxData>?>.alignment)
 
-    self.mutex = PlatformMutex()
+    self.mutex = PlatformMutex.create()
     self.allocator = BumpPtrAllocator(initialSlabSize: 4096)
     self.rawArena = rawNodeArena
     self.root = Self.createDataImpl(allocator: allocator, parent: nil, raw: raw, absoluteInfo: .forRoot(raw))
   }
 
+  deinit {
+    self.mutex.destroy()
+  }
+
   /// Return the childen data of the given node.
   ///
   /// The layout buffer is created and cached when it's first accssed.
@@ -395,15 +405,16 @@ final class SyntaxDataArena: @unchecked Sendable {
       return SyntaxDataReferenceBuffer(buffer)
     }
 
-    return mutex.withGuard {
-      // Recheck before populating, maybe some other thread has populated the buffer
-      // during acquiring the lock.
-      if !isPopulated() {
-        populateDataLayoutImpl(parent)
-      }
+    mutex.lock()
+    defer { mutex.unlock() }
 
-      return SyntaxDataReferenceBuffer(buffer)
+    // Recheck before populating, maybe some other thread has populated the buffer
+    // during acquiring the lock.
+    if !isPopulated() {
+      populateDataLayoutImpl(parent)
     }
+
+    return SyntaxDataReferenceBuffer(buffer)
   }
 
   /// Fill the layout buffer of the node.

Sources/SwiftSyntax/Syntax.swift

@@ -156,6 +156,9 @@ extension SyntaxProtocol {
   /// Return this subtree with this node as the root, ie. detach this node
   /// from its parent.
   public var detached: Self {
+    if !self.hasParent {
+      return self
+    }
     // Make sure `self` (and thus the arena of `self.raw`) can’t get deallocated
     // before the detached node can be created.
     return withExtendedLifetime(self) {

Sources/SwiftSyntax/SyntaxProtocol.swift

@@ -1,5 +1,7 @@
 set(target ${SWIFTSYNTAX_TARGET_NAMESPACE}_SwiftSyntaxCShims)
-add_library(${target} INTERFACE)
-target_include_directories(${target} INTERFACE "include")
+add_library(${target} STATIC
+  PlatformMutex.cpp
+)
+target_include_directories(${target} PUBLIC "include")
 set_property(GLOBAL APPEND PROPERTY SWIFT_EXPORTS ${target})
 install(TARGETS ${target} EXPORT SwiftSyntaxTargets)

Sources/_SwiftSyntaxCShims/CMakeLists.txt

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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 the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "PlatformMutex.h"
+
+#ifdef __APPLE__
+#include <os/lock.h>
+PlatformMutex swiftsyntax_platform_mutex_create() {
+  return {new os_unfair_lock(OS_UNFAIR_LOCK_INIT)};
+}
+
+__attribute__((swift_name("PlatformMutex.lock(self:)")))
+void swiftsyntax_platform_mutex_lock(PlatformMutex m) {
+  os_unfair_lock_lock(static_cast<os_unfair_lock_t>(m.opaque));
+}
+
+__attribute__((swift_name("PlatformMutex.unlock(self:)")))
+void swiftsyntax_platform_mutex_unlock(PlatformMutex m) {
+  os_unfair_lock_unlock(static_cast<os_unfair_lock_t>(m.opaque));
+}
+
+__attribute__((swift_name("PlatformMutex.destroy(self:)")))
+void swiftsyntax_platform_mutex_destroy(PlatformMutex m) {
+  delete static_cast<os_unfair_lock_t>(m.opaque);
+}
+
+#else
+#include <mutex>
+
+PlatformMutex swiftsyntax_platform_mutex_create() {
+  return {new std::mutex()};
+}
+
+__attribute__((swift_name("PlatformMutex.lock(self:)")))
+void swiftsyntax_platform_mutex_lock(PlatformMutex m) {
+  return static_cast<std::mutex *>(m.opaque)->lock();
+}
+
+__attribute__((swift_name("PlatformMutex.unlock(self:)")))
+void swiftsyntax_platform_mutex_unlock(PlatformMutex m) {
+  return static_cast<std::mutex *>(m.opaque)->unlock();
+}
+
+__attribute__((swift_name("PlatformMutex.destroy(self:)")))
+void swiftsyntax_platform_mutex_destroy(PlatformMutex m) {
+  delete static_cast<std::mutex *>(m.opaque);
+}
+#endif

Sources/_SwiftSyntaxCShims/PlatformMutex.cpp

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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 the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFTSYNTAX_PLATFORMMUTEX_H
+#define SWIFTSYNTAX_PLATFORMMUTEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PlatformMutex {
+  void *opaque;
+} PlatformMutex;
+
+__attribute__((swift_name("PlatformMutex.create()")))
+PlatformMutex swiftsyntax_platform_mutex_create(void);
+
+__attribute__((swift_name("PlatformMutex.lock(self:)")))
+void swiftsyntax_platform_mutex_lock(PlatformMutex m);
+
+__attribute__((swift_name("PlatformMutex.unlock(self:)")))
+void swiftsyntax_platform_mutex_unlock(PlatformMutex m);
+
+__attribute__((swift_name("PlatformMutex.destroy(self:)")))
+void swiftsyntax_platform_mutex_destroy(PlatformMutex m);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // SWIFTSYNTAX_PLATFORMMUTEX_H

Sources/_SwiftSyntaxCShims/dummy.c

@@ -12,5 +12,6 @@
 
 #include "_includes.h"
 #include "AtomicBool.h"
+#include "PlatformMutex.h"
 #include "swiftsyntax_errno.h"
 #include "swiftsyntax_stdio.h"

Sources/_SwiftSyntaxCShims/include/PlatformMutex.h

@@ -1,6 +1,7 @@
 module _SwiftSyntaxCShims {
   header "_includes.h"
   header "AtomicBool.h"
+  header "PlatformMutex.h"
   header "swiftsyntax_errno.h"
   header "swiftsyntax_stdio.h"
   export *