Merge branch 'main' into jgrynspan/typed-throws-in-expect

grynspan · web-flow · commit 46b8d1643451 · 2025-10-06T11:48:03.000-04:00
diff --git a/Sources/Testing/Events/Recorder/Event.AdvancedConsoleOutputRecorder.swift b/Sources/Testing/Events/Recorder/Event.AdvancedConsoleOutputRecorder.swift
@@ -142,8 +142,8 @@ extension Event {
     /// The write function for this recorder.
     let write: @Sendable (String) -> Void
     
-    /// The fallback console recorder for standard output.
-    private let _fallbackRecorder: Event.ConsoleOutputRecorder
+    /// The base console output options.
+    private let _baseOptions: Event.ConsoleOutputRecorder.Options
     
     /// Context storage for test information and results.
     private let _context: Locked<_Context>
@@ -159,7 +159,7 @@ extension Event {
     init(options: Options = Options(), writingUsing write: @escaping @Sendable (String) -> Void) {
       self.options = options
       self.write = write
-      self._fallbackRecorder = Event.ConsoleOutputRecorder(options: options.base, writingUsing: write)
+      self._baseOptions = options.base
       self._context = Locked(rawValue: _Context())
       self._humanReadableRecorder = Event.HumanReadableOutputRecorder()
     }
@@ -258,7 +258,7 @@ extension Event.AdvancedConsoleOutputRecorder {
     // The hierarchical summary will be shown at the end
     switch eventKind {
     case .runStarted:
-      let symbol = Event.Symbol.default.stringValue(options: _fallbackRecorder.options)
+      let symbol = Event.Symbol.default.stringValue(options: _baseOptions)
       write("\(symbol) Test run started.\n")
       
     case .runEnded:
diff --git a/Sources/Testing/Events/Recorder/Event.HumanReadableOutputRecorder.swift b/Sources/Testing/Events/Recorder/Event.HumanReadableOutputRecorder.swift
@@ -361,7 +361,7 @@ extension Event.HumanReadableOutputRecorder {
           comments.append("Swift Standard Library Version: \(swiftStandardLibraryVersion)")
         }
         comments.append("Swift Compiler Version: \(swiftCompilerVersion)")
-#if canImport(Glibc) && !os(FreeBSD) && !os(OpenBSD)
+#if os(Linux) && canImport(Glibc)
         comments.append("GNU C Library Version: \(glibcVersion)")
 #endif
       }
diff --git a/Sources/Testing/ExitTests/ExitStatus.swift b/Sources/Testing/ExitTests/ExitStatus.swift
@@ -121,6 +121,7 @@ extension ExitStatus: CustomStringConvertible {
       var signalName: String?
 
 #if SWT_TARGET_OS_APPLE || os(FreeBSD) || os(OpenBSD) || os(Android)
+#if !SWT_NO_SYS_SIGNAME
       // These platforms define sys_signame with a size, which is imported
       // into Swift as a tuple.
       withUnsafeBytes(of: sys_signame) { sys_signame in
@@ -130,6 +131,7 @@ extension ExitStatus: CustomStringConvertible {
           }
         }
       }
+#endif
 #elseif os(Linux)
 #if !SWT_NO_DYNAMIC_LINKING
       signalName = _sigabbrev_np?(signal).flatMap(String.init(validatingCString:))
diff --git a/Sources/Testing/ExitTests/ExitTest.CapturedValue.swift b/Sources/Testing/ExitTests/ExitTest.CapturedValue.swift
@@ -12,6 +12,7 @@ private import _TestingInternals
 
 @_spi(ForToolsIntegrationOnly)
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest {
diff --git a/Sources/Testing/ExitTests/ExitTest.Condition.swift b/Sources/Testing/ExitTests/ExitTest.Condition.swift
@@ -11,6 +11,7 @@
 private import _TestingInternals
 
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest {
@@ -58,6 +59,7 @@ extension ExitTest {
 // MARK: -
 
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest.Condition {
@@ -177,6 +179,7 @@ extension ExitTest.Condition {
 // MARK: - CustomStringConvertible
 
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest.Condition: CustomStringConvertible {
@@ -199,6 +202,7 @@ extension ExitTest.Condition: CustomStringConvertible {
 // MARK: - Comparison
 
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest.Condition {
diff --git a/Sources/Testing/ExitTests/ExitTest.Result.swift b/Sources/Testing/ExitTests/ExitTest.Result.swift
@@ -9,6 +9,7 @@
 //
 
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 extension ExitTest {
diff --git a/Sources/Testing/ExitTests/ExitTest.swift b/Sources/Testing/ExitTests/ExitTest.swift
@@ -35,6 +35,7 @@ private import _TestingInternals
 ///   @Available(Xcode, introduced: 26.0)
 /// }
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 public struct ExitTest: Sendable, ~Copyable {
diff --git a/Sources/Testing/ExitTests/SpawnProcess.swift b/Sources/Testing/ExitTests/SpawnProcess.swift
@@ -113,6 +113,13 @@ func spawnExecutable(
       withUnsafeTemporaryAllocation(of: sigset_t.self, capacity: 1) { allSignals in
         let allSignals = allSignals.baseAddress!
         sigfillset(allSignals)
+#if os(OpenBSD)
+        // On OpenBSD, attempting to set the signal handler for SIGKILL or
+        // SIGSTOP will cause the child process of a call to posix_spawn() to
+        // exit abnormally with exit code 127. See https://man.openbsd.org/sigaction.2#ERRORS
+        sigdelset(allSignals, SIGKILL)
+        sigdelset(allSignals, SIGSTOP)
+#endif
         posix_spawnattr_setsigdefault(attrs, allSignals);
         flags |= CShort(POSIX_SPAWN_SETSIGDEF)
       }
@@ -137,7 +144,7 @@ func spawnExecutable(
             // standardized in POSIX.1-2024 (see https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_spawn_file_actions_adddup2.html
             // and https://www.austingroupbugs.net/view.php?id=411).
             _ = posix_spawn_file_actions_adddup2(fileActions, fd, fd)
-#if canImport(Glibc) && !os(FreeBSD) && !os(OpenBSD)
+#if os(Linux) && canImport(Glibc)
             if _slowPath(glibcVersion < VersionNumber(2, 29)) {
               // This system is using an older version of glibc that does not
               // implement FD_CLOEXEC clearing in posix_spawn_file_actions_adddup2(),
diff --git a/Sources/Testing/ExitTests/WaitFor.swift b/Sources/Testing/ExitTests/WaitFor.swift
@@ -85,11 +85,7 @@ private let _childProcessContinuations = LockedWith<pthread_mutex_t, [pid_t: Che
 /// A condition variable used to suspend the waiter thread created by
 /// `_createWaitThread()` when there are no child processes to await.
 private nonisolated(unsafe) let _waitThreadNoChildrenCondition = {
-#if os(FreeBSD) || os(OpenBSD)
-  let result = UnsafeMutablePointer<pthread_cond_t?>.allocate(capacity: 1)
-#else
   let result = UnsafeMutablePointer<pthread_cond_t>.allocate(capacity: 1)
-#endif
   _ = pthread_cond_init(result, nil)
   return result
 }()
diff --git a/Sources/Testing/Expectations/Expectation+Macro.swift b/Sources/Testing/Expectations/Expectation+Macro.swift
@@ -882,6 +882,7 @@ public macro require<R>(
 @freestanding(expression)
 @discardableResult
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 public macro expect<E>(
@@ -929,6 +930,7 @@ public macro expect<E>(
 @freestanding(expression)
 @discardableResult
 #if SWT_NO_EXIT_TESTS
+@_unavailableInEmbedded
 @available(*, unavailable, message: "Exit tests are not available on this platform.")
 #endif
 public macro require<E>(
diff --git a/Sources/Testing/SourceAttribution/Backtrace.swift b/Sources/Testing/SourceAttribution/Backtrace.swift
@@ -324,6 +324,24 @@ extension Backtrace {
   }
 #endif
 
+#if !hasFeature(Embedded) && SWT_TARGET_OS_APPLE && !SWT_NO_DYNAMIC_LINKING
+  /// A function provided by Core Foundation that copies the captured backtrace
+  /// from storage inside `CFError` or `NSError`.
+  ///
+  /// - Parameters:
+  ///   - error: The error whose backtrace is desired.
+  ///
+  /// - Returns: The backtrace (as an instance of `NSArray`) captured by `error`
+  ///   when it was created, or `nil` if none was captured. The caller is
+  ///   responsible for releasing this object when done.
+  ///
+  /// This function was added in an internal Foundation PR and is not available
+  /// on older systems.
+  private static let _CFErrorCopyCallStackReturnAddresses = symbol(named: "_CFErrorCopyCallStackReturnAddresses").map {
+    castCFunction(at: $0, to: (@convention(c) (_ error: any Error) -> Unmanaged<AnyObject>?).self)
+  }
+#endif
+
   /// Whether or not Foundation provides a function that triggers the capture of
   /// backtaces when instances of `NSError` or `CFError` are created.
   ///
@@ -339,7 +357,11 @@ extension Backtrace {
   ///   first time the value of this property is read.
   static let isFoundationCaptureEnabled = {
 #if !hasFeature(Embedded) && _runtime(_ObjC) && !SWT_NO_DYNAMIC_LINKING
-    if Environment.flag(named: "SWT_FOUNDATION_ERROR_BACKTRACING_ENABLED") == true {
+    // Check the environment variable; if it isn't set, enable if and only if
+    // the Core Foundation getter function is implemented.
+    let foundationBacktracesEnabled = Environment.flag(named: "SWT_FOUNDATION_ERROR_BACKTRACING_ENABLED")
+      ?? (_CFErrorCopyCallStackReturnAddresses != nil)
+    if foundationBacktracesEnabled {
       let _CFErrorSetCallStackCaptureEnabled = symbol(named: "_CFErrorSetCallStackCaptureEnabled").map {
         castCFunction(at: $0, to: (@convention(c) (DarwinBoolean) -> DarwinBoolean).self)
       }
@@ -422,11 +444,19 @@ extension Backtrace {
 #if !hasFeature(Embedded)
   @inline(never)
   init?(forFirstThrowOf error: any Error, checkFoundation: Bool = true) {
-    if checkFoundation && Self.isFoundationCaptureEnabled,
-       let userInfo = error._userInfo as? [String: Any],
-       let addresses = userInfo["NSCallStackReturnAddresses"] as? [Address], !addresses.isEmpty {
-      self.init(addresses: addresses)
-      return
+    if checkFoundation && Self.isFoundationCaptureEnabled {
+#if !hasFeature(Embedded) && SWT_TARGET_OS_APPLE && !SWT_NO_DYNAMIC_LINKING
+      if let addresses = Self._CFErrorCopyCallStackReturnAddresses?(error)?.takeRetainedValue() as? [Address] {
+        self.init(addresses: addresses)
+        return
+      }
+#endif
+
+      if let userInfo = error._userInfo as? [String: Any],
+         let addresses = userInfo["NSCallStackReturnAddresses"] as? [Address], !addresses.isEmpty {
+        self.init(addresses: addresses)
+        return
+      }
     }
 
     let entry = Self._errorMappingCache.withLock { cache in
diff --git a/Sources/Testing/Support/Locked+Platform.swift b/Sources/Testing/Support/Locked+Platform.swift
@@ -39,9 +39,10 @@ extension os_unfair_lock_s: Lockable {
 
 #if os(FreeBSD) || os(OpenBSD)
 typealias pthread_mutex_t = _TestingInternals.pthread_mutex_t?
+typealias pthread_cond_t = _TestingInternals.pthread_cond_t?
 #endif
 
-#if SWT_TARGET_OS_APPLE || os(Linux) || os(Android) || (os(WASI) && _runtime(_multithreaded)) || os(FreeBSD) || os(OpenBSD)
+#if SWT_TARGET_OS_APPLE || os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android) || (os(WASI) && _runtime(_multithreaded))
 extension pthread_mutex_t: Lockable {
   static func initializeLock(at lock: UnsafeMutablePointer<Self>) {
     _ = pthread_mutex_init(lock, nil)
@@ -83,7 +84,7 @@ extension SRWLOCK: Lockable {
 
 #if SWT_TARGET_OS_APPLE && !SWT_NO_OS_UNFAIR_LOCK
 typealias DefaultLock = os_unfair_lock
-#elseif SWT_TARGET_OS_APPLE || os(Linux) || os(Android) || (os(WASI) && _runtime(_multithreaded)) || os(FreeBSD) || os(OpenBSD)
+#elseif SWT_TARGET_OS_APPLE || os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android) || (os(WASI) && _runtime(_multithreaded))
 typealias DefaultLock = pthread_mutex_t
 #elseif os(Windows)
 typealias DefaultLock = SRWLOCK
diff --git a/Sources/Testing/Support/Versions.swift b/Sources/Testing/Support/Versions.swift
@@ -198,7 +198,7 @@ var swiftCompilerVersion: VersionNumber {
   )
 }
 
-#if canImport(Glibc) && !os(FreeBSD) && !os(OpenBSD)
+#if os(Linux) && canImport(Glibc)
 /// The (runtime, not compile-time) version of glibc in use on this system.
 ///
 /// This value is not part of the public interface of the testing library.
diff --git a/Sources/Testing/Test+Macro.swift b/Sources/Testing/Test+Macro.swift
@@ -556,7 +556,7 @@ extension Test {
 ///
 /// - Warning: This function is used to implement the `@Test` macro. Do not use
 ///   it directly.
-@unsafe @inlinable public func __requiringUnsafe<T>(_ value: consuming T) throws -> T where T: ~Copyable {
+@unsafe @inlinable public func __requiringUnsafe<T>(_ value: consuming T) -> T where T: ~Copyable {
   value
 }
 
diff --git a/Sources/Testing/Traits/ConditionTrait+Macro.swift b/Sources/Testing/Traits/ConditionTrait+Macro.swift
@@ -124,4 +124,27 @@ extension Trait where Self == ConditionTrait {
       sourceLocation: sourceLocation
     )
   }
+
+  /// Create a trait controlling availability of a test based on an
+  /// `@_unavailableInEmbedded` attribute applied to it.
+  ///
+  /// - Parameters:
+  ///   - sourceLocation: The source location of the test.
+  ///
+  /// - Returns: A trait.
+  ///
+  /// - Warning: This function is used to implement the `@Test` macro. Do not
+  ///   call it directly.
+  public static func __unavailableInEmbedded(sourceLocation: SourceLocation) -> Self {
+#if hasFeature(Embedded)
+    let isEmbedded = true
+#else
+    let isEmbedded = false
+#endif
+    return Self(
+      kind: .unconditional(!isEmbedded),
+      comments: ["Marked @_unavailableInEmbedded"],
+      sourceLocation: sourceLocation
+    )
+  }
 }
diff --git a/Sources/TestingMacros/Support/Additions/FunctionDeclSyntaxAdditions.swift b/Sources/TestingMacros/Support/Additions/FunctionDeclSyntaxAdditions.swift
@@ -87,14 +87,8 @@ extension FunctionDeclSyntax {
   var xcTestCompatibleSelector: ObjCSelectorPieceListSyntax? {
     // First, look for an @objc attribute with an explicit selector, and use
     // that if found.
-    let objcAttribute = attributes.lazy
-      .compactMap {
-        if case let .attribute(attribute) = $0 {
-          return attribute
-        }
-        return nil
-      }.first { $0.attributeNameText == "objc" }
-    if let objcAttribute, case let .objCName(objCName) = objcAttribute.arguments {
+    if let objcAttribute = attributes(named: "objc", inModuleNamed: "Swift").first,
+       case let .objCName(objCName) = objcAttribute.arguments {
       if true == objCName.first?.name?.textWithoutBackticks.hasPrefix("test") {
         return objCName
       }
diff --git a/Sources/TestingMacros/Support/Additions/WithAttributesSyntaxAdditions.swift b/Sources/TestingMacros/Support/Additions/WithAttributesSyntaxAdditions.swift
@@ -105,13 +105,13 @@ extension WithAttributesSyntax {
   /// The first `@available(*, noasync)` or `@_unavailableFromAsync` attribute
   /// on this instance, if any.
   var noasyncAttribute: AttributeSyntax? {
-    availability(when: .noasync).first?.attribute ?? attributes.lazy
-      .compactMap { attribute in
-        if case let .attribute(attribute) = attribute {
-          return attribute
-        }
-        return nil
-      }.first { $0.attributeNameText == "_unavailableFromAsync" }
+    availability(when: .noasync).first?.attribute
+      ?? attributes(named: "_unavailableFromAsync", inModuleNamed: "Swift").first
+  }
+
+  /// The first `@_unavailableInEmbedded` attribute on this instance, if any.
+  var unavailableInEmbeddedAttribute: AttributeSyntax? {
+    attributes(named: "_unavailableInEmbedded", inModuleNamed: "Swift").first
   }
 
   /// Find all attributes on this node, if any, with the given name.
diff --git a/Sources/TestingMacros/Support/AvailabilityGuards.swift b/Sources/TestingMacros/Support/AvailabilityGuards.swift
@@ -169,6 +169,11 @@ func createAvailabilityTraitExprs(
     _createAvailabilityTraitExpr(from: availability, when: .obsoleted, in: context)
   }
 
+  if let attribute = decl.unavailableInEmbeddedAttribute {
+    let sourceLocationExpr = createSourceLocationExpr(of: attribute, context: context)
+    result += [".__unavailableInEmbedded(sourceLocation: \(sourceLocationExpr))"]
+  }
+
   return result
 }
 
@@ -290,5 +295,16 @@ func createSyntaxNode(
     }
   }
 
+  // Handle Embedded Swift.
+  if decl.unavailableInEmbeddedAttribute != nil {
+    result = """
+      #if !hasFeature(Embedded)
+      \(result)
+      #else
+      \(exitStatement)
+      #endif
+      """
+  }
+
   return result
 }
diff --git a/Tests/TestingTests/ABIEntryPointTests.swift b/Tests/TestingTests/ABIEntryPointTests.swift
@@ -67,12 +67,12 @@ struct ABIEntryPointTests {
     passing arguments: __CommandLineArguments_v0,
     recordHandler: @escaping @Sendable (_ recordJSON: UnsafeRawBufferPointer) -> Void = { _ in }
   ) async throws -> Bool {
-#if !os(Linux) && !os(FreeBSD) && !os(Android) && !SWT_NO_DYNAMIC_LINKING
+#if !(os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android)) && !SWT_NO_DYNAMIC_LINKING
     // Get the ABI entry point by dynamically looking it up at runtime.
     //
-    // NOTE: The standard Linux linker does not allow exporting symbols from
-    // executables, so dlsym() does not let us find this function on that
-    // platform when built as an executable rather than a dynamic library.
+    // NOTE: The standard linkers on these platforms do not export symbols from
+    // executables, so dlsym() does not let us find this function on these
+    // platforms when built as an executable rather than a dynamic library.
     let abiv0_getEntryPoint = try withTestingLibraryImageAddress { testingLibrary in
       try #require(
         symbol(in: testingLibrary, named: "swt_abiv0_getEntryPoint").map {
@@ -187,8 +187,9 @@ private func withTestingLibraryImageAddress<R>(_ body: (ImageAddress?) throws ->
   defer {
     dlclose(testingLibraryAddress)
   }
-#elseif os(Linux) || os(FreeBSD) || os(Android)
-  // When using glibc, dladdr() is only available if __USE_GNU is specified.
+#elseif os(Linux) || os(FreeBSD) || os(OpenBSD) || os(Android)
+  // We can't dynamically look up a function linked into the test executable on
+  // ELF-based platforms.
 #elseif os(Windows)
   let flags = DWORD(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS)
   try addressInTestingLibrary.withMemoryRebound(to: wchar_t.self, capacity: MemoryLayout<UnsafeRawPointer>.stride / MemoryLayout<wchar_t>.stride) { addressInTestingLibrary in
diff --git a/Tests/TestingTests/AdvancedConsoleOutputRecorderTests.swift b/Tests/TestingTests/AdvancedConsoleOutputRecorderTests.swift
diff --git a/Tests/TestingTests/ExitTestTests.swift b/Tests/TestingTests/ExitTestTests.swift
diff --git a/Tests/TestingTests/RunnerTests.swift b/Tests/TestingTests/RunnerTests.swift

Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ extension Event.HumanReadableOutputRecorder {`
`361`	`361`	`comments.append("Swift Standard Library Version: \(swiftStandardLibraryVersion)")`
`362`	`362`	`}`
`363`	`363`	`comments.append("Swift Compiler Version: \(swiftCompilerVersion)")`
`364`		`-#if canImport(Glibc) && !os(FreeBSD) && !os(OpenBSD)`
	`364`	`+#if os(Linux) && canImport(Glibc)`
`365`	`365`	`comments.append("GNU C Library Version: \(glibcVersion)")`
`366`	`366`	`#endif`
`367`	`367`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,6 +121,7 @@ extension ExitStatus: CustomStringConvertible {`
`121`	`121`	`var signalName: String?`
`122`	`122`
`123`	`123`	`#if SWT_TARGET_OS_APPLE \|\| os(FreeBSD) \|\| os(OpenBSD) \|\| os(Android)`
	`124`	`+#if !SWT_NO_SYS_SIGNAME`
`124`	`125`	`// These platforms define sys_signame with a size, which is imported`
`125`	`126`	`// into Swift as a tuple.`
`126`	`127`	`withUnsafeBytes(of: sys_signame) { sys_signame in`
`@@ -130,6 +131,7 @@ extension ExitStatus: CustomStringConvertible {`
`130`	`131`	`}`
`131`	`132`	`}`
`132`	`133`	`}`
	`134`	`+#endif`
`133`	`135`	`#elseif os(Linux)`
`134`	`136`	`#if !SWT_NO_DYNAMIC_LINKING`
`135`	`137`	`signalName = _sigabbrev_np?(signal).flatMap(String.init(validatingCString:))`