x

.github/workflows/build-and-test.yml

@@ -33,27 +33,29 @@ jobs:
             destination: 'platform=macOS,name=My Mac'
           - name: watchOS
             destination: 'platform=watchOS Simulator,name=Apple Watch Series 11 (46mm)'
+      fail-fast: false
     with:
-      runsonlabels: '["macOS", "self-hosted"]'
-      scheme: ThreadLocal-Package
+      # runsonlabels: '["macOS", "self-hosted"]'
+      scheme: ThreadLocal
       destination: ${{ matrix.platform.destination }}
       buildConfig: ${{ matrix.config }}
-      resultBundle: ${{ format('ThreadLocal-Package-{0}-{1}.xcresult', matrix.platform.name, matrix.config) }}
-      artifactname: ${{ format('ThreadLocal-Package-{0}-{1}.xcresult', matrix.platform.name, matrix.config) }}
+      resultBundle: ${{ format('ThreadLocal-{0}-{1}.xcresult', matrix.platform.name, matrix.config) }}
+      artifactname: ${{ format('ThreadLocal-{0}-{1}.xcresult', matrix.platform.name, matrix.config) }}
+      spm-disable-prebuilts: true
   package_tests_linux:
     name: Build and Test Swift Package Linux (${{ matrix.config }})
     uses: StanfordBDHG/.github/.github/workflows/swift-test.yml@v2
     strategy:
       matrix:
         config: [Debug, Release]
     with:
-      artifact_name: ${{ format('ThreadLocal-Package-Linux-{0}.lcov', matrix.config) }}
+      artifact_name: ${{ format('ThreadLocal-Linux-{0}.lcov', matrix.config) }}
   uploadcoveragereport:
     name: Upload Coverage Report
     needs: [package_tests, package_tests_linux]
     uses: StanfordBDHG/.github/.github/workflows/create-and-upload-coverage-report.yml@v2
     with:
-      coveragereports: ThreadLocal-Package-*.xcresult
-      coveragereports_lcov: ThreadLocal-Package-Linux-*.lcov
+      coveragereports: ThreadLocal-*.xcresult
+      coveragereports_lcov: ThreadLocal-Linux-*.lcov
     secrets:
       token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/static-analysis.yml

@@ -26,9 +26,9 @@ jobs:
   swiftlint:
     name: SwiftLint
     uses: StanfordSpezi/.github/.github/workflows/swiftlint.yml@v2
-  markdown_link_check:
-    name: Markdown Link Check
-    uses: StanfordBDHG/.github/.github/workflows/markdown-link-check.yml@v2
+  # markdown_link_check:
+  #   name: Markdown Link Check
+  #   uses: StanfordBDHG/.github/.github/workflows/markdown-link-check.yml@v2
   breaking_changes:
     name: Diagnose Breaking Changes
     uses: StanfordSpezi/.github/.github/workflows/breaking-changes.yml@v2

.spi.yml

@@ -0,0 +1,14 @@
+#
+# This source file is part of the TemplatePackage open source project
+#
+# SPDX-FileCopyrightText: 2022 Stanford University and the project authors (see CONTRIBUTORS.md)
+#
+# SPDX-License-Identifier: MIT
+# 
+
+version: 1
+builder:
+  configs:
+    - platform: ios
+      documentation_targets:
+      - ThreadLocal

Package.swift

@@ -44,6 +44,6 @@ let package = Package(
                 .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                 .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax")
             ]
-        ),
+        )
     ]
 )

Sources/ThreadLocal/ThreadLocal.swift

@@ -6,8 +6,14 @@
 // SPDX-License-Identifier: MIT
 //
 
+// swiftlint:disable type_name identifier_name
+
 import Foundation
-import pthread
+#if os(Linux)
+import Glibc
+#else
+import Darwin.C
+#endif
 
 
 /// Manages a thread-local defined via the ``ThreadLocal()`` macro.
@@ -17,24 +23,32 @@ public final class ThreadLocal<Value>: Sendable {
     nonisolated(unsafe) public private(set) var _key: pthread_key_t
     public let _deallocator: Deallocator
 
-    @_unavailableFromAsync
-    public init(_deallocator deallocator: Deallocator = .default) {
-        _key = pthread_key_t()
-        pthread_key_create(&_key) { (ptr: UnsafeMutableRawPointer) in
-            unsafeBitCast(ptr, to: Unmanaged<AnyObject>.self).release()
-        }
-        self._deallocator = deallocator
-    }
-
-    @inlinable
-    var _box: _Box? {
+    @inlinable var _box: _Box? {
         guard let ptr = pthread_getspecific(_key) else {
             return nil
         }
         let unmanaged = Unmanaged<_Box>.fromOpaque(ptr)
         return unmanaged.takeUnretainedValue()
     }
 
+    @_unavailableFromAsync
+    public init(_deallocator deallocator: Deallocator = .default) {
+        _key = pthread_key_t()
+        _deallocator = deallocator
+        #if os(Linux)
+        let destroyFn: @convention(c) (UnsafeMutableRawPointer?) -> Void = { ptr in
+            if let ptr {
+                unsafeBitCast(ptr, to: Unmanaged<AnyObject>.self).release()
+            }
+        }
+        #else
+        let destroyFn: @convention(c) (UnsafeMutableRawPointer) -> Void = { ptr in
+            unsafeBitCast(ptr, to: Unmanaged<AnyObject>.self).release()
+        }
+        #endif
+        pthread_key_create(&_key, destroyFn)
+    }
+
     @inlinable
     @_unavailableFromAsync
     func _makeBox(_ value: Value) -> _Box {

Sources/ThreadLocalMacros/ThreadLocalMacro.swift

@@ -65,12 +65,6 @@ extension ThreadLocalMacro: AccessorMacro {
 }
 
 
-extension VariableDeclSyntax {
-    var isStatic: Bool {
-        modifiers.contains(where: { $0.name.trimmed.text == "static" })
-    }
-}
-
 extension ThreadLocalMacro: PeerMacro {
     public static func expansion( // swiftlint:disable:this function_body_length cyclomatic_complexity
         of node: AttributeSyntax,
@@ -130,8 +124,34 @@ extension ThreadLocalMacro: PeerMacro {
             throw SimpleError("unexpected")
         }
 
+        let attrs: AttributeSyntax? = variableDeclaration.isInlinable ? "@usableFromInline" : nil
+        let modifiers = DeclModifierSyntax(name: variableDeclaration.isInlinable ? "internal" : "private")
+
         return [
-            "private static let _\(identifier) = ThreadLocal<\(valueTypeInitializer.trimmed)>(\(args))"
+            "\(attrs) \(modifiers) static let _\(identifier) = ThreadLocal<\(valueTypeInitializer.trimmed)>(\(args))"
         ]
     }
 }
+
+
+// MARK: Utils
+
+extension VariableDeclSyntax {
+    var isStatic: Bool {
+        modifiers.contains { $0.name.trimmed.text == "static" }
+    }
+    var isInlinable: Bool {
+        attributes.contains { $0.attribute?.attributeName.trimmed.as(IdentifierTypeSyntax.self)?.name.text == "inlinable" }
+    }
+}
+
+extension AttributeListSyntax.Element {
+    var attribute: AttributeSyntax? {
+        switch self {
+        case .attribute(let attr):
+            attr
+        case .ifConfigDecl:
+            nil
+        }
+    }
+}

Tests/ThreadLocalTests/ThreadLocalMacroTests.swift

@@ -8,12 +8,12 @@
 
 #if os(macOS) // macro tests can only be run on the host machine
 import Foundation
-import ThreadLocal
-import ThreadLocalMacros
 import SwiftSyntaxMacroExpansion
 import SwiftSyntaxMacros
 import SwiftSyntaxMacrosGenericTestSupport
 import Testing
+import ThreadLocal
+import ThreadLocalMacros
 
 let testMacrosSpecs: [String: MacroSpec] = [
     "ThreadLocal": MacroSpec(type: ThreadLocalMacro.self)
@@ -46,6 +46,30 @@ struct ThreadLocalMacroTests {
         )
     }
 
+    @Test
+    func inlinable() {
+        assertMacroExpansion(
+            """
+            @ThreadLocal @inlinable static var counter: Int = 0
+            """,
+            expandedSource:
+            """
+            @inlinable static var counter: Int {
+                get {
+                    _counter._get(default: 0)
+                }
+                set {
+                    _counter._set(newValue)
+                }
+            }
+
+            @usableFromInline internal static let _counter = ThreadLocal<Int>()
+            """,
+            macroSpecs: testMacrosSpecs,
+            failureHandler: { Issue.record("\($0.message)") }
+        )
+    }
+
     @Test
     func customDeallocator() {
         assertMacroExpansion(

Tests/ThreadLocalTests/ThreadLocalTests.swift

@@ -7,8 +7,8 @@
 //
 
 import Foundation
-import ThreadLocal
 import Testing
+import ThreadLocal
 
 
 @Suite
@@ -39,6 +39,5 @@ struct ThreadLocalTests {
             thread.cancel()
         }
         sleep(1)
-        fatalError()
     }
 }